|
@@ -0,0 +1,150 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JConfiguration {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IConfiguration* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JConfiguration"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Method: 'persist' - Stores configuration to the persistent memory
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Configuration::PersistParamsInfo, void>(_T("persist"),
|
|
36
|
+
[_implementation__](const JsonData::Configuration::PersistParamsInfo& params) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
|
|
40
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConfiguration"), _T("persist")));
|
|
41
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
42
|
+
}
|
|
43
|
+
else {
|
|
44
|
+
Core::OptionalType<string> _callsign_{};
|
|
45
|
+
if (params.Callsign.IsSet() == true) {
|
|
46
|
+
_callsign_ = params.Callsign;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Persist(_callsign_);
|
|
50
|
+
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
_module__.PluginHost::JSONRPC::Register(_T("storeconfig"), _T("persist"));
|
|
57
|
+
|
|
58
|
+
// Method: 'restore' - Restores configuration back to default
|
|
59
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Configuration::PersistParamsInfo, void>(_T("restore"),
|
|
60
|
+
[_implementation__](const JsonData::Configuration::PersistParamsInfo& params) -> uint32_t {
|
|
61
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
62
|
+
|
|
63
|
+
if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
|
|
64
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConfiguration"), _T("restore")));
|
|
65
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
66
|
+
}
|
|
67
|
+
else {
|
|
68
|
+
Core::OptionalType<string> _callsign_{};
|
|
69
|
+
if (params.Callsign.IsSet() == true) {
|
|
70
|
+
_callsign_ = params.Callsign;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
_errorCode__ = _implementation__->Restore(_callsign_);
|
|
74
|
+
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
return (_errorCode__);
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
// Indexed Property: 'configuration' - Service configuration
|
|
81
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String, std::function<uint32_t(const string&, const Core::JSON::String&, Core::JSON::String&)>>(_T("configuration"),
|
|
82
|
+
[_implementation__](const string& callsign, const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
83
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
84
|
+
|
|
85
|
+
if (params.IsSet() == false) {
|
|
86
|
+
Core::OptionalType<string> _callsignOpt__{};
|
|
87
|
+
|
|
88
|
+
if (callsign.empty() == true) {
|
|
89
|
+
// no error, optional
|
|
90
|
+
}
|
|
91
|
+
else {
|
|
92
|
+
_callsignOpt__ = callsign;
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
string _result_{};
|
|
96
|
+
|
|
97
|
+
_errorCode__ = (static_cast<const IConfiguration*>(_implementation__))->Configuration(_callsignOpt__, _result_);
|
|
98
|
+
|
|
99
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
100
|
+
|
|
101
|
+
if (_result_.empty() == false) {
|
|
102
|
+
result = _result_;
|
|
103
|
+
result.SetQuoted(false);
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
else {
|
|
108
|
+
|
|
109
|
+
if (callsign.empty() == true) {
|
|
110
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JConfiguration"), _T("configuration")));
|
|
111
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
115
|
+
const string _params_{params};
|
|
116
|
+
|
|
117
|
+
_errorCode__ = _implementation__->Configuration(callsign, _params_);
|
|
118
|
+
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
result.Null(true);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
return (_errorCode__);
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
template<typename MODULE>
|
|
130
|
+
static void Unregister(MODULE& _module__)
|
|
131
|
+
{
|
|
132
|
+
// Unregister methods and properties...
|
|
133
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("persist"));
|
|
134
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("storeconfig"));
|
|
135
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("restore"));
|
|
136
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("configuration"));
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
POP_WARNING()
|
|
140
|
+
POP_WARNING()
|
|
141
|
+
POP_WARNING()
|
|
142
|
+
|
|
143
|
+
} // namespace JConfiguration
|
|
144
|
+
|
|
145
|
+
} // namespace Controller
|
|
146
|
+
|
|
147
|
+
} // namespace Exchange
|
|
148
|
+
|
|
149
|
+
} // namespace Thunder
|
|
150
|
+
|
|
@@ -0,0 +1,99 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JDiscovery {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IDiscovery* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JDiscovery"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Method: 'startdiscovery' - Starts SSDP network discovery
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Discovery::StartDiscoveryParamsData, void>(_T("startdiscovery"),
|
|
36
|
+
[_implementation__](const JsonData::Discovery::StartDiscoveryParamsData& params) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
|
|
40
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDiscovery"), _T("startdiscovery")));
|
|
41
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
42
|
+
}
|
|
43
|
+
else {
|
|
44
|
+
Core::OptionalType<uint8_t> _ttl_{};
|
|
45
|
+
if (params.Ttl.IsSet() == true) {
|
|
46
|
+
_ttl_ = params.Ttl;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->StartDiscovery(_ttl_);
|
|
50
|
+
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
// Property: 'discoveryresults' - SSDP network discovery results (r/o)
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Discovery::DiscoveryResultData>>(_T("discoveryresults"),
|
|
58
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::Discovery::DiscoveryResultData>& result) -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
RPC::IIteratorType<Exchange::Controller::IDiscovery::Data::DiscoveryResult, RPC::ID_CONTROLLER_DISCOVERY_RESULTS_ITERATOR>* _result_{};
|
|
62
|
+
|
|
63
|
+
_errorCode__ = _implementation__->DiscoveryResults(_result_);
|
|
64
|
+
|
|
65
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
66
|
+
result.Set(true);
|
|
67
|
+
|
|
68
|
+
if (_result_ != nullptr) {
|
|
69
|
+
Exchange::Controller::IDiscovery::Data::DiscoveryResult _resultItem__{};
|
|
70
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
71
|
+
_result_->Release();
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
return (_errorCode__);
|
|
76
|
+
});
|
|
77
|
+
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
template<typename MODULE>
|
|
81
|
+
static void Unregister(MODULE& _module__)
|
|
82
|
+
{
|
|
83
|
+
// Unregister methods and properties...
|
|
84
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("startdiscovery"));
|
|
85
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("discoveryresults"));
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
POP_WARNING()
|
|
89
|
+
POP_WARNING()
|
|
90
|
+
POP_WARNING()
|
|
91
|
+
|
|
92
|
+
} // namespace JDiscovery
|
|
93
|
+
|
|
94
|
+
} // namespace Controller
|
|
95
|
+
|
|
96
|
+
} // namespace Exchange
|
|
97
|
+
|
|
98
|
+
} // namespace Thunder
|
|
99
|
+
|
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JEvents {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IEvents*)
|
|
27
|
+
{
|
|
28
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JEvents"), Version::Major, Version::Minor, Version::Patch);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
template<typename MODULE>
|
|
32
|
+
static void Unregister(MODULE&)
|
|
33
|
+
{
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
namespace Event {
|
|
37
|
+
|
|
38
|
+
// Event: 'all' - Notifies all events forwarded by the framework
|
|
39
|
+
template<typename MODULE>
|
|
40
|
+
static void ForwardMessage(const MODULE& module_, const JsonData::Events::ForwardMessageParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
41
|
+
{
|
|
42
|
+
module_.Notify(_T("all"), params, sendIfMethod_);
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
// Event: 'all' - Notifies all events forwarded by the framework
|
|
46
|
+
template<typename MODULE>
|
|
47
|
+
static void ForwardMessage(const MODULE& module_, const Core::JSON::String& event, const Core::JSON::String& callsign, const Core::JSON::String& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
48
|
+
{
|
|
49
|
+
JsonData::Events::ForwardMessageParamsData params_;
|
|
50
|
+
params_.Event = event;
|
|
51
|
+
params_.Callsign = callsign;
|
|
52
|
+
params_.Params = params;
|
|
53
|
+
|
|
54
|
+
ForwardMessage(module_, params_, sendIfMethod_);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
// Event: 'all' - Notifies all events forwarded by the framework
|
|
58
|
+
template<typename MODULE>
|
|
59
|
+
static void ForwardMessage(const MODULE& module_, const string& event, const Core::OptionalType<string>& callsign, const Core::OptionalType<string>& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
60
|
+
{
|
|
61
|
+
JsonData::Events::ForwardMessageParamsData params_;
|
|
62
|
+
params_.Event = event;
|
|
63
|
+
|
|
64
|
+
if (callsign.IsSet() == true) {
|
|
65
|
+
params_.Callsign = callsign.Value();
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
if (params.IsSet() == true) {
|
|
69
|
+
params_.Params = params.Value();
|
|
70
|
+
params_.Params.SetQuoted(false);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
ForwardMessage(module_, params_, sendIfMethod_);
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
} // namespace Event
|
|
77
|
+
|
|
78
|
+
POP_WARNING()
|
|
79
|
+
POP_WARNING()
|
|
80
|
+
POP_WARNING()
|
|
81
|
+
|
|
82
|
+
} // namespace JEvents
|
|
83
|
+
|
|
84
|
+
} // namespace Controller
|
|
85
|
+
|
|
86
|
+
} // namespace Exchange
|
|
87
|
+
|
|
88
|
+
} // namespace Thunder
|
|
89
|
+
|
|
@@ -0,0 +1,559 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JLifeTime {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
struct IHandler {
|
|
22
|
+
virtual ~IHandler() = default;
|
|
23
|
+
virtual void OnStateChangeEventRegistration(const string& client, const Core::OptionalType<string>& index, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
24
|
+
virtual void OnStateControlStateChangeEventRegistration(const string& client, const Core::OptionalType<string>& index, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
28
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
29
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
30
|
+
|
|
31
|
+
template<typename MODULE>
|
|
32
|
+
static void Register(MODULE& _module__, ILifeTime* _implementation__, IHandler* _handler_)
|
|
33
|
+
{
|
|
34
|
+
ASSERT(_implementation__ != nullptr);
|
|
35
|
+
ASSERT(_handler_ != nullptr);
|
|
36
|
+
|
|
37
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JLifeTime"), Version::Major, Version::Minor, Version::Patch);
|
|
38
|
+
|
|
39
|
+
// Register methods and properties...
|
|
40
|
+
|
|
41
|
+
// Method: 'activate' - Activates a plugin
|
|
42
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("activate"),
|
|
43
|
+
[_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
|
|
44
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
45
|
+
|
|
46
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
47
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("activate")));
|
|
48
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
49
|
+
}
|
|
50
|
+
else {
|
|
51
|
+
const string _callsign_{params.Callsign};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->Activate(_callsign_);
|
|
54
|
+
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return (_errorCode__);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
// Method: 'deactivate' - Deactivates a plugin
|
|
61
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("deactivate"),
|
|
62
|
+
[_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
|
|
63
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
64
|
+
|
|
65
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
66
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("deactivate")));
|
|
67
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
68
|
+
}
|
|
69
|
+
else {
|
|
70
|
+
const string _callsign_{params.Callsign};
|
|
71
|
+
|
|
72
|
+
_errorCode__ = _implementation__->Deactivate(_callsign_);
|
|
73
|
+
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
return (_errorCode__);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
// Method: 'unavailable' - Makes a plugin unavailable for interaction
|
|
80
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("unavailable"),
|
|
81
|
+
[_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
|
|
82
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
83
|
+
|
|
84
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
85
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("unavailable")));
|
|
86
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
87
|
+
}
|
|
88
|
+
else {
|
|
89
|
+
const string _callsign_{params.Callsign};
|
|
90
|
+
|
|
91
|
+
_errorCode__ = _implementation__->Unavailable(_callsign_);
|
|
92
|
+
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
return (_errorCode__);
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
// Method: 'hibernate' - Hibernates a plugin
|
|
99
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::HibernateParamsData, void>(_T("hibernate"),
|
|
100
|
+
[_implementation__](const JsonData::LifeTime::HibernateParamsData& params) -> uint32_t {
|
|
101
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
102
|
+
|
|
103
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
104
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("hibernate")));
|
|
105
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
106
|
+
}
|
|
107
|
+
else {
|
|
108
|
+
const string _callsign_{params.Callsign};
|
|
109
|
+
const uint32_t _timeout_{params.Timeout};
|
|
110
|
+
|
|
111
|
+
_errorCode__ = _implementation__->Hibernate(_callsign_, _timeout_);
|
|
112
|
+
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
return (_errorCode__);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
// Method: 'suspend' - Suspends a plugin
|
|
119
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("suspend"),
|
|
120
|
+
[_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
|
|
121
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
122
|
+
|
|
123
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
124
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("suspend")));
|
|
125
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
126
|
+
}
|
|
127
|
+
else {
|
|
128
|
+
const string _callsign_{params.Callsign};
|
|
129
|
+
|
|
130
|
+
_errorCode__ = _implementation__->Suspend(_callsign_);
|
|
131
|
+
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
return (_errorCode__);
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
// Method: 'resume' - Resumes a plugin
|
|
138
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("resume"),
|
|
139
|
+
[_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
|
|
140
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
141
|
+
|
|
142
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
143
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("resume")));
|
|
144
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
145
|
+
}
|
|
146
|
+
else {
|
|
147
|
+
const string _callsign_{params.Callsign};
|
|
148
|
+
|
|
149
|
+
_errorCode__ = _implementation__->Resume(_callsign_);
|
|
150
|
+
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
return (_errorCode__);
|
|
154
|
+
});
|
|
155
|
+
|
|
156
|
+
// Register event status listeners...
|
|
157
|
+
|
|
158
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("statechange"),
|
|
159
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string& index_, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
160
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
161
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
162
|
+
|
|
163
|
+
if (index_.empty() == true) {
|
|
164
|
+
// no error, optional
|
|
165
|
+
}
|
|
166
|
+
else {
|
|
167
|
+
_indexOpt__ = index_;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
171
|
+
_handler_->OnStateChangeEventRegistration(client_, _indexOpt__, status_);
|
|
172
|
+
}
|
|
173
|
+
});
|
|
174
|
+
|
|
175
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("statecontrolstatechange"),
|
|
176
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string& index_, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
177
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
178
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
179
|
+
|
|
180
|
+
if (index_.empty() == true) {
|
|
181
|
+
// no error, optional
|
|
182
|
+
}
|
|
183
|
+
else {
|
|
184
|
+
_indexOpt__ = index_;
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
188
|
+
_handler_->OnStateControlStateChangeEventRegistration(client_, _indexOpt__, status_);
|
|
189
|
+
}
|
|
190
|
+
});
|
|
191
|
+
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
template<typename MODULE>
|
|
195
|
+
static void Unregister(MODULE& _module__)
|
|
196
|
+
{
|
|
197
|
+
// Unregister methods and properties...
|
|
198
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("activate"));
|
|
199
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deactivate"));
|
|
200
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unavailable"));
|
|
201
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("hibernate"));
|
|
202
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("suspend"));
|
|
203
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("resume"));
|
|
204
|
+
|
|
205
|
+
// Unregister event status listeners...
|
|
206
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("statechange"));
|
|
207
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("statecontrolstatechange"));
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
namespace Event {
|
|
211
|
+
|
|
212
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
213
|
+
template<typename MODULE>
|
|
214
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateChangeParamsData& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
215
|
+
{
|
|
216
|
+
if (sendIfMethod_ == nullptr) {
|
|
217
|
+
module_.Notify(_T("statechange"), params, [&id_](const string&, const string& index_) -> bool {
|
|
218
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
219
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
220
|
+
|
|
221
|
+
if (index_.empty() == true) {
|
|
222
|
+
// no error, optional
|
|
223
|
+
}
|
|
224
|
+
else {
|
|
225
|
+
_indexOpt__ = index_;
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)));
|
|
229
|
+
});
|
|
230
|
+
}
|
|
231
|
+
else {
|
|
232
|
+
module_.Notify(_T("statechange"), params, sendIfMethod_);
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
237
|
+
template<typename MODULE>
|
|
238
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateChangeParamsData& params, const string& client_)
|
|
239
|
+
{
|
|
240
|
+
module_.Notify(_T("statechange"), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
241
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
242
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
243
|
+
|
|
244
|
+
if (index_.empty() == true) {
|
|
245
|
+
// no error, optional
|
|
246
|
+
}
|
|
247
|
+
else {
|
|
248
|
+
_indexOpt__ = index_;
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)) && (client_ == designator_));
|
|
252
|
+
});
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
256
|
+
template<typename MODULE>
|
|
257
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateChangeParamsData& params, const bool, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
258
|
+
{
|
|
259
|
+
if (sendIfMethod_ == nullptr) {
|
|
260
|
+
module_.Notify(_T("statechange"), params, [&id_](const string&, const string& index_) -> bool {
|
|
261
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
262
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
263
|
+
|
|
264
|
+
if (index_.empty() == true) {
|
|
265
|
+
// no error, optional
|
|
266
|
+
}
|
|
267
|
+
else {
|
|
268
|
+
_indexOpt__ = index_;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__));
|
|
272
|
+
});
|
|
273
|
+
}
|
|
274
|
+
else {
|
|
275
|
+
module_.Notify(_T("statechange"), params, sendIfMethod_);
|
|
276
|
+
}
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
280
|
+
template<typename MODULE>
|
|
281
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateChangeParamsData& params, const bool, const string& client_)
|
|
282
|
+
{
|
|
283
|
+
module_.Notify(_T("statechange"), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
284
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
285
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
286
|
+
|
|
287
|
+
if (index_.empty() == true) {
|
|
288
|
+
// no error, optional
|
|
289
|
+
}
|
|
290
|
+
else {
|
|
291
|
+
_indexOpt__ = index_;
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__) && (client_ == designator_));
|
|
295
|
+
});
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
299
|
+
template<typename MODULE>
|
|
300
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::JSON::String& callsign, const Core::JSON::EnumType<PluginHost::IShell::state>& state, const Core::JSON::EnumType<PluginHost::IShell::reason>& reason, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
301
|
+
{
|
|
302
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
303
|
+
params_.Callsign = callsign;
|
|
304
|
+
params_.State = state;
|
|
305
|
+
params_.Reason = reason;
|
|
306
|
+
|
|
307
|
+
StateChange(module_, id_, params_, sendIfMethod_);
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
311
|
+
template<typename MODULE>
|
|
312
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::JSON::String& callsign, const Core::JSON::EnumType<PluginHost::IShell::state>& state, const Core::JSON::EnumType<PluginHost::IShell::reason>& reason, const string& client_)
|
|
313
|
+
{
|
|
314
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
315
|
+
params_.Callsign = callsign;
|
|
316
|
+
params_.State = state;
|
|
317
|
+
params_.Reason = reason;
|
|
318
|
+
|
|
319
|
+
StateChange(module_, id_, params_, client_);
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
323
|
+
template<typename MODULE>
|
|
324
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& callsign, const PluginHost::IShell::state& state, const PluginHost::IShell::reason& reason, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
325
|
+
{
|
|
326
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
327
|
+
|
|
328
|
+
if (callsign.IsSet() == true) {
|
|
329
|
+
params_.Callsign = callsign.Value();
|
|
330
|
+
}
|
|
331
|
+
params_.State = state;
|
|
332
|
+
params_.Reason = reason;
|
|
333
|
+
|
|
334
|
+
StateChange(module_, callsign.Value(), params_, sendIfMethod_);
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
338
|
+
template<typename MODULE>
|
|
339
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& callsign, const PluginHost::IShell::state& state, const PluginHost::IShell::reason& reason, const string& client_)
|
|
340
|
+
{
|
|
341
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
342
|
+
|
|
343
|
+
if (callsign.IsSet() == true) {
|
|
344
|
+
params_.Callsign = callsign.Value();
|
|
345
|
+
}
|
|
346
|
+
params_.State = state;
|
|
347
|
+
params_.Reason = reason;
|
|
348
|
+
|
|
349
|
+
StateChange(module_, callsign.Value(), params_, client_);
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
353
|
+
template<typename MODULE>
|
|
354
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::OptionalType<string>& callsign, const PluginHost::IShell::state& state, const PluginHost::IShell::reason& reason, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
355
|
+
{
|
|
356
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
357
|
+
|
|
358
|
+
if (callsign.IsSet() == true) {
|
|
359
|
+
params_.Callsign = callsign.Value();
|
|
360
|
+
}
|
|
361
|
+
params_.State = state;
|
|
362
|
+
params_.Reason = reason;
|
|
363
|
+
|
|
364
|
+
StateChange(module_, id_, params_, true, sendIfMethod_);
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
// Event: 'statechange' - Notifies of a plugin state change
|
|
368
|
+
template<typename MODULE>
|
|
369
|
+
static void StateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::OptionalType<string>& callsign, const PluginHost::IShell::state& state, const PluginHost::IShell::reason& reason, const string& client_)
|
|
370
|
+
{
|
|
371
|
+
JsonData::LifeTime::StateChangeParamsData params_;
|
|
372
|
+
|
|
373
|
+
if (callsign.IsSet() == true) {
|
|
374
|
+
params_.Callsign = callsign.Value();
|
|
375
|
+
}
|
|
376
|
+
params_.State = state;
|
|
377
|
+
params_.Reason = reason;
|
|
378
|
+
|
|
379
|
+
StateChange(module_, id_, params_, true, client_);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
383
|
+
template<typename MODULE>
|
|
384
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateControlStateChangeParamsData& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
385
|
+
{
|
|
386
|
+
if (sendIfMethod_ == nullptr) {
|
|
387
|
+
module_.Notify(_T("statecontrolstatechange"), params, [&id_](const string&, const string& index_) -> bool {
|
|
388
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
389
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
390
|
+
|
|
391
|
+
if (index_.empty() == true) {
|
|
392
|
+
// no error, optional
|
|
393
|
+
}
|
|
394
|
+
else {
|
|
395
|
+
_indexOpt__ = index_;
|
|
396
|
+
}
|
|
397
|
+
|
|
398
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)));
|
|
399
|
+
});
|
|
400
|
+
}
|
|
401
|
+
else {
|
|
402
|
+
module_.Notify(_T("statecontrolstatechange"), params, sendIfMethod_);
|
|
403
|
+
}
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
407
|
+
template<typename MODULE>
|
|
408
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateControlStateChangeParamsData& params, const string& client_)
|
|
409
|
+
{
|
|
410
|
+
module_.Notify(_T("statecontrolstatechange"), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
411
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
412
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
413
|
+
|
|
414
|
+
if (index_.empty() == true) {
|
|
415
|
+
// no error, optional
|
|
416
|
+
}
|
|
417
|
+
else {
|
|
418
|
+
_indexOpt__ = index_;
|
|
419
|
+
}
|
|
420
|
+
|
|
421
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)) && (client_ == designator_));
|
|
422
|
+
});
|
|
423
|
+
}
|
|
424
|
+
|
|
425
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
426
|
+
template<typename MODULE>
|
|
427
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateControlStateChangeParamsData& params, const bool, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
428
|
+
{
|
|
429
|
+
if (sendIfMethod_ == nullptr) {
|
|
430
|
+
module_.Notify(_T("statecontrolstatechange"), params, [&id_](const string&, const string& index_) -> bool {
|
|
431
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
432
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
433
|
+
|
|
434
|
+
if (index_.empty() == true) {
|
|
435
|
+
// no error, optional
|
|
436
|
+
}
|
|
437
|
+
else {
|
|
438
|
+
_indexOpt__ = index_;
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__));
|
|
442
|
+
});
|
|
443
|
+
}
|
|
444
|
+
else {
|
|
445
|
+
module_.Notify(_T("statecontrolstatechange"), params, sendIfMethod_);
|
|
446
|
+
}
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
450
|
+
template<typename MODULE>
|
|
451
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const JsonData::LifeTime::StateControlStateChangeParamsData& params, const bool, const string& client_)
|
|
452
|
+
{
|
|
453
|
+
module_.Notify(_T("statecontrolstatechange"), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
454
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
455
|
+
Core::OptionalType<string> _indexOpt__{};
|
|
456
|
+
|
|
457
|
+
if (index_.empty() == true) {
|
|
458
|
+
// no error, optional
|
|
459
|
+
}
|
|
460
|
+
else {
|
|
461
|
+
_indexOpt__ = index_;
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__) && (client_ == designator_));
|
|
465
|
+
});
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
469
|
+
template<typename MODULE>
|
|
470
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::JSON::String& callsign, const Core::JSON::EnumType<Exchange::Controller::ILifeTime::state>& state, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
471
|
+
{
|
|
472
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
473
|
+
params_.Callsign = callsign;
|
|
474
|
+
params_.State = state;
|
|
475
|
+
|
|
476
|
+
StateControlStateChange(module_, id_, params_, sendIfMethod_);
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
480
|
+
template<typename MODULE>
|
|
481
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::JSON::String& callsign, const Core::JSON::EnumType<Exchange::Controller::ILifeTime::state>& state, const string& client_)
|
|
482
|
+
{
|
|
483
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
484
|
+
params_.Callsign = callsign;
|
|
485
|
+
params_.State = state;
|
|
486
|
+
|
|
487
|
+
StateControlStateChange(module_, id_, params_, client_);
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
491
|
+
template<typename MODULE>
|
|
492
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& callsign, const ILifeTime::state& state, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
493
|
+
{
|
|
494
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
495
|
+
|
|
496
|
+
if (callsign.IsSet() == true) {
|
|
497
|
+
params_.Callsign = callsign.Value();
|
|
498
|
+
}
|
|
499
|
+
params_.State = state;
|
|
500
|
+
|
|
501
|
+
StateControlStateChange(module_, callsign.Value(), params_, sendIfMethod_);
|
|
502
|
+
}
|
|
503
|
+
|
|
504
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
505
|
+
template<typename MODULE>
|
|
506
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& callsign, const ILifeTime::state& state, const string& client_)
|
|
507
|
+
{
|
|
508
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
509
|
+
|
|
510
|
+
if (callsign.IsSet() == true) {
|
|
511
|
+
params_.Callsign = callsign.Value();
|
|
512
|
+
}
|
|
513
|
+
params_.State = state;
|
|
514
|
+
|
|
515
|
+
StateControlStateChange(module_, callsign.Value(), params_, client_);
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
519
|
+
template<typename MODULE>
|
|
520
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::OptionalType<string>& callsign, const ILifeTime::state& state, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
521
|
+
{
|
|
522
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
523
|
+
|
|
524
|
+
if (callsign.IsSet() == true) {
|
|
525
|
+
params_.Callsign = callsign.Value();
|
|
526
|
+
}
|
|
527
|
+
params_.State = state;
|
|
528
|
+
|
|
529
|
+
StateControlStateChange(module_, id_, params_, true, sendIfMethod_);
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
// Event: 'statecontrolstatechange' - Notifies of a plugin state change controlled by IStateControl
|
|
533
|
+
template<typename MODULE>
|
|
534
|
+
static void StateControlStateChange(const MODULE& module_, const Core::OptionalType<string>& id_, const Core::OptionalType<string>& callsign, const ILifeTime::state& state, const string& client_)
|
|
535
|
+
{
|
|
536
|
+
JsonData::LifeTime::StateControlStateChangeParamsData params_;
|
|
537
|
+
|
|
538
|
+
if (callsign.IsSet() == true) {
|
|
539
|
+
params_.Callsign = callsign.Value();
|
|
540
|
+
}
|
|
541
|
+
params_.State = state;
|
|
542
|
+
|
|
543
|
+
StateControlStateChange(module_, id_, params_, true, client_);
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
} // namespace Event
|
|
547
|
+
|
|
548
|
+
POP_WARNING()
|
|
549
|
+
POP_WARNING()
|
|
550
|
+
POP_WARNING()
|
|
551
|
+
|
|
552
|
+
} // namespace JLifeTime
|
|
553
|
+
|
|
554
|
+
} // namespace Controller
|
|
555
|
+
|
|
556
|
+
} // namespace Exchange
|
|
557
|
+
|
|
558
|
+
} // namespace Thunder
|
|
559
|
+
|
|
@@ -0,0 +1,269 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JMetadata {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IMetadata* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMetadata"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Indexed Property: 'services' - Services metadata (r/o)
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Metadata::ServiceData>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::Metadata::ServiceData>&)>>(_T("services"),
|
|
36
|
+
[_implementation__](const string& callsign, Core::JSON::ArrayType<JsonData::Metadata::ServiceData>& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
Core::OptionalType<string> _callsignOpt__{};
|
|
40
|
+
|
|
41
|
+
if (callsign.empty() == true) {
|
|
42
|
+
// no error, optional
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
_callsignOpt__ = callsign;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
RPC::IIteratorType<Exchange::Controller::IMetadata::Data::Service, RPC::ID_CONTROLLER_METADATA_SERVICES_ITERATOR>* _result_{};
|
|
49
|
+
|
|
50
|
+
_errorCode__ = _implementation__->Services(_callsignOpt__, _result_);
|
|
51
|
+
|
|
52
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
53
|
+
result.Set(true);
|
|
54
|
+
|
|
55
|
+
if (_result_ != nullptr) {
|
|
56
|
+
Exchange::Controller::IMetadata::Data::Service _resultItem__{};
|
|
57
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
58
|
+
result.SetExtractOnSingle(true);
|
|
59
|
+
_result_->Release();
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
return (_errorCode__);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
_module__.PluginHost::JSONRPC::Register(_T("status"), _T("services"));
|
|
67
|
+
|
|
68
|
+
// Property: 'links' - Connections list of Thunder connections (r/o)
|
|
69
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Metadata::LinkData>>(_T("links"),
|
|
70
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::Metadata::LinkData>& result) -> uint32_t {
|
|
71
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
72
|
+
|
|
73
|
+
RPC::IIteratorType<Exchange::Controller::IMetadata::Data::Link, RPC::ID_CONTROLLER_METADATA_LINKS_ITERATOR>* _result_{};
|
|
74
|
+
|
|
75
|
+
_errorCode__ = _implementation__->Links(_result_);
|
|
76
|
+
|
|
77
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
78
|
+
result.Set(true);
|
|
79
|
+
|
|
80
|
+
if (_result_ != nullptr) {
|
|
81
|
+
Exchange::Controller::IMetadata::Data::Link _resultItem__{};
|
|
82
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
83
|
+
_result_->Release();
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
return (_errorCode__);
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
// Indexed Property: 'proxies' - Proxies list (r/o)
|
|
91
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Metadata::ProxyData>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::Metadata::ProxyData>&)>>(_T("proxies"),
|
|
92
|
+
[_implementation__](const string& linkID, Core::JSON::ArrayType<JsonData::Metadata::ProxyData>& result) -> uint32_t {
|
|
93
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
94
|
+
|
|
95
|
+
Core::OptionalType<string> _linkIDOpt__{};
|
|
96
|
+
|
|
97
|
+
if (linkID.empty() == true) {
|
|
98
|
+
// no error, optional
|
|
99
|
+
}
|
|
100
|
+
else {
|
|
101
|
+
_linkIDOpt__ = linkID;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
RPC::IIteratorType<Exchange::Controller::IMetadata::Data::Proxy, RPC::ID_CONTROLLER_METADATA_PROXIES_ITERATOR>* _result_{};
|
|
105
|
+
|
|
106
|
+
_errorCode__ = _implementation__->Proxies(_linkIDOpt__, _result_);
|
|
107
|
+
|
|
108
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
109
|
+
result.Set(true);
|
|
110
|
+
|
|
111
|
+
if (_result_ != nullptr) {
|
|
112
|
+
Exchange::Controller::IMetadata::Data::Proxy _resultItem__{};
|
|
113
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
114
|
+
_result_->Release();
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
return (_errorCode__);
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
// Property: 'framework' - Framework version (r/o)
|
|
122
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::Metadata::VersionInfo>(_T("framework"),
|
|
123
|
+
[_implementation__](JsonData::Metadata::VersionInfo& result) -> uint32_t {
|
|
124
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
125
|
+
|
|
126
|
+
Exchange::Controller::IMetadata::Data::Version _result_{};
|
|
127
|
+
|
|
128
|
+
_errorCode__ = _implementation__->Framework(_result_);
|
|
129
|
+
|
|
130
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
131
|
+
result.Set(true);
|
|
132
|
+
result = _result_;
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
return (_errorCode__);
|
|
136
|
+
});
|
|
137
|
+
|
|
138
|
+
_module__.PluginHost::JSONRPC::Register(_T("version"), _T("framework"));
|
|
139
|
+
|
|
140
|
+
// Property: 'threads' - Workerpool threads (r/o)
|
|
141
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Metadata::ThreadData>>(_T("threads"),
|
|
142
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::Metadata::ThreadData>& result) -> uint32_t {
|
|
143
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
144
|
+
|
|
145
|
+
RPC::IIteratorType<Exchange::Controller::IMetadata::Data::Thread, RPC::ID_CONTROLLER_METADATA_THREADS_ITERATOR>* _result_{};
|
|
146
|
+
|
|
147
|
+
_errorCode__ = _implementation__->Threads(_result_);
|
|
148
|
+
|
|
149
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
150
|
+
result.Set(true);
|
|
151
|
+
|
|
152
|
+
if (_result_ != nullptr) {
|
|
153
|
+
Exchange::Controller::IMetadata::Data::Thread _resultItem__{};
|
|
154
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
155
|
+
_result_->Release();
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
return (_errorCode__);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
// Property: 'pendingrequests' - Pending requests (r/o)
|
|
163
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("pendingrequests"),
|
|
164
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
165
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
166
|
+
|
|
167
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
168
|
+
|
|
169
|
+
_errorCode__ = _implementation__->PendingRequests(_result_);
|
|
170
|
+
|
|
171
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
172
|
+
result.Set(true);
|
|
173
|
+
|
|
174
|
+
if (_result_ != nullptr) {
|
|
175
|
+
string _resultItem__{};
|
|
176
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
177
|
+
_result_->Release();
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
return (_errorCode__);
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
// Indexed Property: 'callstack' - Thread callstack (r/o)
|
|
185
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Metadata::CallStackData>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::Metadata::CallStackData>&)>>(_T("callstack"),
|
|
186
|
+
[_implementation__](const string& thread, Core::JSON::ArrayType<JsonData::Metadata::CallStackData>& result) -> uint32_t {
|
|
187
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
188
|
+
|
|
189
|
+
uint8_t _threadConv__{};
|
|
190
|
+
|
|
191
|
+
if (thread.empty() == true) {
|
|
192
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JMetadata"), _T("callstack")));
|
|
193
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
194
|
+
}
|
|
195
|
+
else {
|
|
196
|
+
const bool _threadConvResult__ = Core::FromString(thread, _threadConv__);
|
|
197
|
+
|
|
198
|
+
if (_threadConvResult__ == false) {
|
|
199
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JMetadata"), _T("callstack")));
|
|
200
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
205
|
+
RPC::IIteratorType<Exchange::Controller::IMetadata::Data::CallStack, RPC::ID_CONTROLLER_METADATA_CALLSTACK_ITERATOR>* _result_{};
|
|
206
|
+
|
|
207
|
+
_errorCode__ = _implementation__->CallStack(_threadConv__, _result_);
|
|
208
|
+
|
|
209
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
210
|
+
result.Set(true);
|
|
211
|
+
|
|
212
|
+
if (_result_ != nullptr) {
|
|
213
|
+
Exchange::Controller::IMetadata::Data::CallStack _resultItem__{};
|
|
214
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
215
|
+
_result_->Release();
|
|
216
|
+
}
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
return (_errorCode__);
|
|
221
|
+
});
|
|
222
|
+
|
|
223
|
+
// Property: 'buildinfo' - Build information (r/o)
|
|
224
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::Metadata::BuildInfoData>(_T("buildinfo"),
|
|
225
|
+
[_implementation__](JsonData::Metadata::BuildInfoData& result) -> uint32_t {
|
|
226
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
227
|
+
|
|
228
|
+
Exchange::Controller::IMetadata::Data::BuildInfo _result_{};
|
|
229
|
+
|
|
230
|
+
_errorCode__ = _implementation__->BuildInfo(_result_);
|
|
231
|
+
|
|
232
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
233
|
+
result.Set(true);
|
|
234
|
+
result = _result_;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
return (_errorCode__);
|
|
238
|
+
});
|
|
239
|
+
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
template<typename MODULE>
|
|
243
|
+
static void Unregister(MODULE& _module__)
|
|
244
|
+
{
|
|
245
|
+
// Unregister methods and properties...
|
|
246
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("services"));
|
|
247
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("status"));
|
|
248
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("links"));
|
|
249
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("proxies"));
|
|
250
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("framework"));
|
|
251
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("version"));
|
|
252
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("threads"));
|
|
253
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("pendingrequests"));
|
|
254
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("callstack"));
|
|
255
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("buildinfo"));
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
POP_WARNING()
|
|
259
|
+
POP_WARNING()
|
|
260
|
+
POP_WARNING()
|
|
261
|
+
|
|
262
|
+
} // namespace JMetadata
|
|
263
|
+
|
|
264
|
+
} // namespace Controller
|
|
265
|
+
|
|
266
|
+
} // namespace Exchange
|
|
267
|
+
|
|
268
|
+
} // namespace Thunder
|
|
269
|
+
|
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
// Generated automatically from 'IStateController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace PluginHost {
|
|
8
|
+
|
|
9
|
+
namespace JStateController {
|
|
10
|
+
|
|
11
|
+
namespace Version {
|
|
12
|
+
|
|
13
|
+
constexpr uint8_t Major = 1;
|
|
14
|
+
constexpr uint8_t Minor = 0;
|
|
15
|
+
constexpr uint8_t Patch = 0;
|
|
16
|
+
|
|
17
|
+
} // namespace Version
|
|
18
|
+
|
|
19
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
20
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
22
|
+
|
|
23
|
+
template<typename MODULE>
|
|
24
|
+
static void Register(MODULE& _module__, IStateController* _implementation__)
|
|
25
|
+
{
|
|
26
|
+
ASSERT(_implementation__ != nullptr);
|
|
27
|
+
|
|
28
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JStateController"), Version::Major, Version::Minor, Version::Patch);
|
|
29
|
+
|
|
30
|
+
// Register methods and properties...
|
|
31
|
+
|
|
32
|
+
// Method: 'statecontrol::request' - Request a change to the specified state
|
|
33
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::StateController::RequestParamsData, void>(_T("statecontrol::request"),
|
|
34
|
+
[_implementation__](const JsonData::StateController::RequestParamsData& params) -> uint32_t {
|
|
35
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
36
|
+
|
|
37
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
38
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStateController"), _T("statecontrol::request")));
|
|
39
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
40
|
+
}
|
|
41
|
+
else {
|
|
42
|
+
const PluginHost::IStateController::command _state_{params.State};
|
|
43
|
+
|
|
44
|
+
_errorCode__ = _implementation__->Request(_state_);
|
|
45
|
+
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
return (_errorCode__);
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
// Property: 'statecontrol::state' - Running state of the service (r/o)
|
|
52
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<PluginHost::IStateController::state>>(_T("statecontrol::state"),
|
|
53
|
+
[_implementation__](Core::JSON::EnumType<PluginHost::IStateController::state>& result) -> uint32_t {
|
|
54
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
55
|
+
|
|
56
|
+
PluginHost::IStateController::state _result_{};
|
|
57
|
+
|
|
58
|
+
_errorCode__ = _implementation__->State(_result_);
|
|
59
|
+
|
|
60
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
61
|
+
result = _result_;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
return (_errorCode__);
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
template<typename MODULE>
|
|
70
|
+
static void Unregister(MODULE& _module__)
|
|
71
|
+
{
|
|
72
|
+
// Unregister methods and properties...
|
|
73
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("statecontrol::request"));
|
|
74
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("statecontrol::state"));
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
namespace Event {
|
|
78
|
+
|
|
79
|
+
// Event: 'statecontrol::statechanged' - Signals a state change of the service
|
|
80
|
+
template<typename MODULE>
|
|
81
|
+
static void StateChanged(const MODULE& module_, const JsonData::StateController::StateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
82
|
+
{
|
|
83
|
+
module_.Notify(_T("statecontrol::statechanged"), params, sendIfMethod_);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
// Event: 'statecontrol::statechanged' - Signals a state change of the service
|
|
87
|
+
template<typename MODULE>
|
|
88
|
+
static void StateChanged(const MODULE& module_, const Core::JSON::EnumType<PluginHost::IStateController::state>& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
89
|
+
{
|
|
90
|
+
JsonData::StateController::StateChangedParamsData params_;
|
|
91
|
+
params_.State = state;
|
|
92
|
+
|
|
93
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// Event: 'statecontrol::statechanged' - Signals a state change of the service
|
|
97
|
+
template<typename MODULE>
|
|
98
|
+
static void StateChanged(const MODULE& module_, const IStateController::state state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
99
|
+
{
|
|
100
|
+
JsonData::StateController::StateChangedParamsData params_;
|
|
101
|
+
params_.State = state;
|
|
102
|
+
|
|
103
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
} // namespace Event
|
|
107
|
+
|
|
108
|
+
POP_WARNING()
|
|
109
|
+
POP_WARNING()
|
|
110
|
+
POP_WARNING()
|
|
111
|
+
|
|
112
|
+
} // namespace JStateController
|
|
113
|
+
|
|
114
|
+
} // namespace PluginHost
|
|
115
|
+
|
|
116
|
+
} // namespace Thunder
|
|
117
|
+
|
|
@@ -0,0 +1,87 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JSubsystems {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, ISubsystems* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSubsystems"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Property: 'subsystems' - Subsystems status (r/o)
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Subsystems::SubsystemInfo>>(_T("subsystems"),
|
|
36
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::Subsystems::SubsystemInfo>& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
RPC::IIteratorType<Exchange::Controller::ISubsystems::Subsystem, RPC::ID_CONTROLLER_SUBSYSTEMS_ITERATOR>* _result_{};
|
|
40
|
+
|
|
41
|
+
_errorCode__ = _implementation__->Subsystems(_result_);
|
|
42
|
+
|
|
43
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
44
|
+
result.Set(true);
|
|
45
|
+
|
|
46
|
+
if (_result_ != nullptr) {
|
|
47
|
+
Exchange::Controller::ISubsystems::Subsystem _paramsItem__{};
|
|
48
|
+
while (_result_->Next(_paramsItem__) == true) { result.Add() = _paramsItem__; }
|
|
49
|
+
_result_->Release();
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
template<typename MODULE>
|
|
59
|
+
static void Unregister(MODULE& _module__)
|
|
60
|
+
{
|
|
61
|
+
// Unregister methods and properties...
|
|
62
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("subsystems"));
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
namespace Event {
|
|
66
|
+
|
|
67
|
+
// Event: 'subsystemchange' - Notifies a subsystem change
|
|
68
|
+
template<typename MODULE>
|
|
69
|
+
static void SubsystemChange(const MODULE& module_, const Core::JSON::ArrayType<JsonData::Subsystems::SubsystemInfo>& subsystems, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
70
|
+
{
|
|
71
|
+
module_.Notify(_T("subsystemchange"), subsystems, sendIfMethod_);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
} // namespace Event
|
|
75
|
+
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
POP_WARNING()
|
|
78
|
+
POP_WARNING()
|
|
79
|
+
|
|
80
|
+
} // namespace JSubsystems
|
|
81
|
+
|
|
82
|
+
} // namespace Controller
|
|
83
|
+
|
|
84
|
+
} // namespace Exchange
|
|
85
|
+
|
|
86
|
+
} // namespace Thunder
|
|
87
|
+
|
|
@@ -0,0 +1,156 @@
|
|
|
1
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
|
|
5
|
+
namespace Thunder {
|
|
6
|
+
|
|
7
|
+
namespace Exchange {
|
|
8
|
+
|
|
9
|
+
namespace Controller {
|
|
10
|
+
|
|
11
|
+
namespace JSystem {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, ISystem* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSystem"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Method: 'reboot' - Reboots the device
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("reboot"),
|
|
36
|
+
[_implementation__]() -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
_errorCode__ = _implementation__->Reboot();
|
|
40
|
+
|
|
41
|
+
return (_errorCode__);
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
_module__.PluginHost::JSONRPC::Register(_T("harakiri"), _T("reboot"));
|
|
45
|
+
|
|
46
|
+
// Method: 'delete' - Removes contents of a directory from the persistent storage
|
|
47
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::System::DeleteParamsData, void>(_T("delete"),
|
|
48
|
+
[_implementation__](const JsonData::System::DeleteParamsData& params) -> uint32_t {
|
|
49
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
50
|
+
|
|
51
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
52
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("delete")));
|
|
53
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
54
|
+
}
|
|
55
|
+
else {
|
|
56
|
+
const string _path_{params.Path};
|
|
57
|
+
|
|
58
|
+
_errorCode__ = _implementation__->Delete(_path_);
|
|
59
|
+
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
return (_errorCode__);
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
// Method: 'clone' - Creates a clone of given plugin with a new callsign
|
|
66
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::System::CloneParamsData, Core::JSON::String>(_T("clone"),
|
|
67
|
+
[_implementation__](const JsonData::System::CloneParamsData& params, Core::JSON::String& response) -> uint32_t {
|
|
68
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
69
|
+
|
|
70
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
71
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("clone")));
|
|
72
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
73
|
+
}
|
|
74
|
+
else {
|
|
75
|
+
const string _callsign_{params.Callsign};
|
|
76
|
+
const string _newcallsign_{params.Newcallsign};
|
|
77
|
+
string _response_{};
|
|
78
|
+
|
|
79
|
+
_errorCode__ = _implementation__->Clone(_callsign_, _newcallsign_, _response_);
|
|
80
|
+
|
|
81
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
82
|
+
response = _response_;
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
return (_errorCode__);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
// Method: 'destroy' - Destroy given plugin
|
|
90
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::System::DestroyParamsData, void>(_T("destroy"),
|
|
91
|
+
[_implementation__](const JsonData::System::DestroyParamsData& params) -> uint32_t {
|
|
92
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
93
|
+
|
|
94
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
95
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("destroy")));
|
|
96
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
97
|
+
}
|
|
98
|
+
else {
|
|
99
|
+
const string _callsign_{params.Callsign};
|
|
100
|
+
|
|
101
|
+
_errorCode__ = _implementation__->Destroy(_callsign_);
|
|
102
|
+
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
return (_errorCode__);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
// Indexed Property: 'environment' - Environment variable value (r/o)
|
|
109
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String, std::function<uint32_t(const string&, Core::JSON::String&)>>(_T("environment"),
|
|
110
|
+
[_implementation__](const string& variable, Core::JSON::String& result) -> uint32_t {
|
|
111
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
112
|
+
|
|
113
|
+
if (variable.empty() == true) {
|
|
114
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSystem"), _T("environment")));
|
|
115
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
119
|
+
string _result_{};
|
|
120
|
+
|
|
121
|
+
_errorCode__ = _implementation__->Environment(variable, _result_);
|
|
122
|
+
|
|
123
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
124
|
+
result = _result_;
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
return (_errorCode__);
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
template<typename MODULE>
|
|
134
|
+
static void Unregister(MODULE& _module__)
|
|
135
|
+
{
|
|
136
|
+
// Unregister methods and properties...
|
|
137
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("reboot"));
|
|
138
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("harakiri"));
|
|
139
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("delete"));
|
|
140
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("clone"));
|
|
141
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("destroy"));
|
|
142
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("environment"));
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
POP_WARNING()
|
|
146
|
+
POP_WARNING()
|
|
147
|
+
POP_WARNING()
|
|
148
|
+
|
|
149
|
+
} // namespace JSystem
|
|
150
|
+
|
|
151
|
+
} // namespace Controller
|
|
152
|
+
|
|
153
|
+
} // namespace Exchange
|
|
154
|
+
|
|
155
|
+
} // namespace Thunder
|
|
156
|
+
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
// C++ types for Configuration API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Configuration {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class PersistParamsInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
PersistParamsInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("callsign"), &Callsign);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
PersistParamsInfo(const PersistParamsInfo&) = delete;
|
|
30
|
+
PersistParamsInfo(PersistParamsInfo&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
PersistParamsInfo& operator=(const PersistParamsInfo&) = delete;
|
|
33
|
+
PersistParamsInfo& operator=(PersistParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~PersistParamsInfo() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Callsign; // Plugin callsign to persist (omit for all plugins, empty string for Controller only)
|
|
45
|
+
}; // class PersistParamsInfo
|
|
46
|
+
|
|
47
|
+
// Method params/result classes
|
|
48
|
+
//
|
|
49
|
+
|
|
50
|
+
} // namespace Configuration
|
|
51
|
+
|
|
52
|
+
POP_WARNING()
|
|
53
|
+
|
|
54
|
+
} // namespace JsonData
|
|
55
|
+
|
|
56
|
+
}
|
|
57
|
+
|
|
@@ -0,0 +1,161 @@
|
|
|
1
|
+
// C++ types for Discovery API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Discovery {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class DiscoveryResultData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
DiscoveryResultData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
_Init();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
DiscoveryResultData(const DiscoveryResultData& _other)
|
|
30
|
+
: Core::JSON::Container()
|
|
31
|
+
, Locator(_other.Locator)
|
|
32
|
+
, Latency(_other.Latency)
|
|
33
|
+
, Model(_other.Model)
|
|
34
|
+
, Secure(_other.Secure)
|
|
35
|
+
{
|
|
36
|
+
_Init();
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
DiscoveryResultData(DiscoveryResultData&& _other) noexcept
|
|
40
|
+
: Core::JSON::Container()
|
|
41
|
+
, Locator(std::move(_other.Locator))
|
|
42
|
+
, Latency(std::move(_other.Latency))
|
|
43
|
+
, Model(std::move(_other.Model))
|
|
44
|
+
, Secure(std::move(_other.Secure))
|
|
45
|
+
{
|
|
46
|
+
_Init();
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
DiscoveryResultData(const Exchange::Controller::IDiscovery::Data::DiscoveryResult& _other)
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
Locator = _other.Locator;
|
|
53
|
+
Latency = _other.Latency;
|
|
54
|
+
if (_other.Model.IsSet() == true) {
|
|
55
|
+
Model = _other.Model.Value();
|
|
56
|
+
}
|
|
57
|
+
Secure = _other.Secure;
|
|
58
|
+
_Init();
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
DiscoveryResultData& operator=(const DiscoveryResultData& _rhs)
|
|
62
|
+
{
|
|
63
|
+
Locator = _rhs.Locator;
|
|
64
|
+
Latency = _rhs.Latency;
|
|
65
|
+
if (_rhs.Model.IsSet() == true) {
|
|
66
|
+
Model = _rhs.Model;
|
|
67
|
+
}
|
|
68
|
+
Secure = _rhs.Secure;
|
|
69
|
+
return (*this);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
DiscoveryResultData& operator=(DiscoveryResultData&& _rhs) noexcept
|
|
73
|
+
{
|
|
74
|
+
Locator = std::move(_rhs.Locator);
|
|
75
|
+
Latency = std::move(_rhs.Latency);
|
|
76
|
+
Model = std::move(_rhs.Model);
|
|
77
|
+
Secure = std::move(_rhs.Secure);
|
|
78
|
+
return (*this);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
DiscoveryResultData& operator=(const Exchange::Controller::IDiscovery::Data::DiscoveryResult& _rhs)
|
|
82
|
+
{
|
|
83
|
+
Locator = _rhs.Locator;
|
|
84
|
+
Latency = _rhs.Latency;
|
|
85
|
+
if (_rhs.Model.IsSet() == true) {
|
|
86
|
+
Model = _rhs.Model.Value();
|
|
87
|
+
}
|
|
88
|
+
Secure = _rhs.Secure;
|
|
89
|
+
return (*this);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
operator Exchange::Controller::IDiscovery::Data::DiscoveryResult() const
|
|
93
|
+
{
|
|
94
|
+
Exchange::Controller::IDiscovery::Data::DiscoveryResult _value{};
|
|
95
|
+
_value.Locator = Locator;
|
|
96
|
+
_value.Latency = Latency;
|
|
97
|
+
if (Model.IsSet() == true) {
|
|
98
|
+
_value.Model = Model;
|
|
99
|
+
}
|
|
100
|
+
_value.Secure = Secure;
|
|
101
|
+
return (_value);
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
~DiscoveryResultData() = default;
|
|
105
|
+
|
|
106
|
+
public:
|
|
107
|
+
bool IsDataValid() const
|
|
108
|
+
{
|
|
109
|
+
return ((Locator.IsSet() == true) && (Latency.IsSet() == true) && (Secure.IsSet() == true));
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
private:
|
|
113
|
+
void _Init()
|
|
114
|
+
{
|
|
115
|
+
Add(_T("locator"), &Locator);
|
|
116
|
+
Add(_T("latency"), &Latency);
|
|
117
|
+
Add(_T("model"), &Model);
|
|
118
|
+
Add(_T("secure"), &Secure);
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
public:
|
|
122
|
+
Core::JSON::String Locator; // Locator for the discovery
|
|
123
|
+
Core::JSON::DecUInt32 Latency; // Latency for the discovery
|
|
124
|
+
Core::JSON::String Model; // Model
|
|
125
|
+
Core::JSON::Boolean Secure; // Secure or not
|
|
126
|
+
}; // class DiscoveryResultData
|
|
127
|
+
|
|
128
|
+
class StartDiscoveryParamsData : public Core::JSON::Container {
|
|
129
|
+
public:
|
|
130
|
+
StartDiscoveryParamsData()
|
|
131
|
+
: Core::JSON::Container()
|
|
132
|
+
{
|
|
133
|
+
Add(_T("ttl"), &Ttl);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
StartDiscoveryParamsData(const StartDiscoveryParamsData&) = delete;
|
|
137
|
+
StartDiscoveryParamsData(StartDiscoveryParamsData&&) noexcept = delete;
|
|
138
|
+
|
|
139
|
+
StartDiscoveryParamsData& operator=(const StartDiscoveryParamsData&) = delete;
|
|
140
|
+
StartDiscoveryParamsData& operator=(StartDiscoveryParamsData&&) noexcept = delete;
|
|
141
|
+
|
|
142
|
+
~StartDiscoveryParamsData() = default;
|
|
143
|
+
|
|
144
|
+
public:
|
|
145
|
+
bool IsDataValid() const
|
|
146
|
+
{
|
|
147
|
+
return ((Ttl.IsSet() == false) || (Ttl.Value() >= 1 && Ttl.Value() <= 255));
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
public:
|
|
151
|
+
Core::JSON::DecUInt8 Ttl; // Time to live, parameter for SSDP discovery
|
|
152
|
+
}; // class StartDiscoveryParamsData
|
|
153
|
+
|
|
154
|
+
} // namespace Discovery
|
|
155
|
+
|
|
156
|
+
POP_WARNING()
|
|
157
|
+
|
|
158
|
+
} // namespace JsonData
|
|
159
|
+
|
|
160
|
+
}
|
|
161
|
+
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
// C++ types for Events API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Events {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class ForwardMessageParamsData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
ForwardMessageParamsData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("event"), &Event);
|
|
27
|
+
Add(_T("callsign"), &Callsign);
|
|
28
|
+
Add(_T("params"), &Params);
|
|
29
|
+
Params.SetQuoted(false);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
ForwardMessageParamsData(const ForwardMessageParamsData&) = delete;
|
|
33
|
+
ForwardMessageParamsData(ForwardMessageParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
ForwardMessageParamsData& operator=(const ForwardMessageParamsData&) = delete;
|
|
36
|
+
ForwardMessageParamsData& operator=(ForwardMessageParamsData&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~ForwardMessageParamsData() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return (Event.IsSet() == true);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::String Event; // Name of the message
|
|
48
|
+
Core::JSON::String Callsign; // Origin of the message
|
|
49
|
+
Core::JSON::String Params; // Contents of the message
|
|
50
|
+
}; // class ForwardMessageParamsData
|
|
51
|
+
|
|
52
|
+
} // namespace Events
|
|
53
|
+
|
|
54
|
+
POP_WARNING()
|
|
55
|
+
|
|
56
|
+
} // namespace JsonData
|
|
57
|
+
|
|
58
|
+
// Enum conversion handlers
|
|
59
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::state)
|
|
60
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::reason)
|
|
61
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::ILifeTime::state)
|
|
62
|
+
ENUM_CONVERSION_HANDLER(PluginHost::ISubSystem::subsystem)
|
|
63
|
+
|
|
64
|
+
}
|
|
65
|
+
|
|
@@ -0,0 +1,148 @@
|
|
|
1
|
+
// C++ types for LifeTime API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace LifeTime {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class ActivateParamsInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
ActivateParamsInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("callsign"), &Callsign);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
ActivateParamsInfo(const ActivateParamsInfo&) = delete;
|
|
30
|
+
ActivateParamsInfo(ActivateParamsInfo&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
ActivateParamsInfo& operator=(const ActivateParamsInfo&) = delete;
|
|
33
|
+
ActivateParamsInfo& operator=(ActivateParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~ActivateParamsInfo() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (Callsign.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Callsign; // Callsign of plugin to be activated
|
|
45
|
+
}; // class ActivateParamsInfo
|
|
46
|
+
|
|
47
|
+
// Method params/result classes
|
|
48
|
+
//
|
|
49
|
+
|
|
50
|
+
class HibernateParamsData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
HibernateParamsData()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("callsign"), &Callsign);
|
|
56
|
+
Add(_T("timeout"), &Timeout);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
HibernateParamsData(const HibernateParamsData&) = delete;
|
|
60
|
+
HibernateParamsData(HibernateParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
HibernateParamsData& operator=(const HibernateParamsData&) = delete;
|
|
63
|
+
HibernateParamsData& operator=(HibernateParamsData&&) noexcept = delete;
|
|
64
|
+
|
|
65
|
+
~HibernateParamsData() = default;
|
|
66
|
+
|
|
67
|
+
public:
|
|
68
|
+
bool IsDataValid() const
|
|
69
|
+
{
|
|
70
|
+
return ((Callsign.IsSet() == true) && (Timeout.IsSet() == true));
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
Core::JSON::String Callsign; // Callsign of plugin to be hibernated
|
|
75
|
+
Core::JSON::DecUInt32 Timeout; // Allowed time
|
|
76
|
+
}; // class HibernateParamsData
|
|
77
|
+
|
|
78
|
+
class StateChangeParamsData : public Core::JSON::Container {
|
|
79
|
+
public:
|
|
80
|
+
StateChangeParamsData()
|
|
81
|
+
: Core::JSON::Container()
|
|
82
|
+
{
|
|
83
|
+
Add(_T("callsign"), &Callsign);
|
|
84
|
+
Add(_T("state"), &State);
|
|
85
|
+
Add(_T("reason"), &Reason);
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
StateChangeParamsData(const StateChangeParamsData&) = delete;
|
|
89
|
+
StateChangeParamsData(StateChangeParamsData&&) noexcept = delete;
|
|
90
|
+
|
|
91
|
+
StateChangeParamsData& operator=(const StateChangeParamsData&) = delete;
|
|
92
|
+
StateChangeParamsData& operator=(StateChangeParamsData&&) noexcept = delete;
|
|
93
|
+
|
|
94
|
+
~StateChangeParamsData() = default;
|
|
95
|
+
|
|
96
|
+
public:
|
|
97
|
+
bool IsDataValid() const
|
|
98
|
+
{
|
|
99
|
+
return ((State.IsSet() == true) && (Reason.IsSet() == true));
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
public:
|
|
103
|
+
Core::JSON::String Callsign; // Plugin callsign
|
|
104
|
+
Core::JSON::EnumType<PluginHost::IShell::state> State; // New state of the plugin
|
|
105
|
+
Core::JSON::EnumType<PluginHost::IShell::reason> Reason; // Reason for state change
|
|
106
|
+
}; // class StateChangeParamsData
|
|
107
|
+
|
|
108
|
+
class StateControlStateChangeParamsData : public Core::JSON::Container {
|
|
109
|
+
public:
|
|
110
|
+
StateControlStateChangeParamsData()
|
|
111
|
+
: Core::JSON::Container()
|
|
112
|
+
{
|
|
113
|
+
Add(_T("callsign"), &Callsign);
|
|
114
|
+
Add(_T("state"), &State);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
StateControlStateChangeParamsData(const StateControlStateChangeParamsData&) = delete;
|
|
118
|
+
StateControlStateChangeParamsData(StateControlStateChangeParamsData&&) noexcept = delete;
|
|
119
|
+
|
|
120
|
+
StateControlStateChangeParamsData& operator=(const StateControlStateChangeParamsData&) = delete;
|
|
121
|
+
StateControlStateChangeParamsData& operator=(StateControlStateChangeParamsData&&) noexcept = delete;
|
|
122
|
+
|
|
123
|
+
~StateControlStateChangeParamsData() = default;
|
|
124
|
+
|
|
125
|
+
public:
|
|
126
|
+
bool IsDataValid() const
|
|
127
|
+
{
|
|
128
|
+
return (State.IsSet() == true);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
public:
|
|
132
|
+
Core::JSON::String Callsign; // Plugin callsign
|
|
133
|
+
Core::JSON::EnumType<Exchange::Controller::ILifeTime::state> State; // New state of the plugin
|
|
134
|
+
}; // class StateControlStateChangeParamsData
|
|
135
|
+
|
|
136
|
+
} // namespace LifeTime
|
|
137
|
+
|
|
138
|
+
POP_WARNING()
|
|
139
|
+
|
|
140
|
+
} // namespace JsonData
|
|
141
|
+
|
|
142
|
+
// Enum conversion handlers
|
|
143
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::state)
|
|
144
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::reason)
|
|
145
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::ILifeTime::state)
|
|
146
|
+
|
|
147
|
+
}
|
|
148
|
+
|
|
@@ -0,0 +1,1077 @@
|
|
|
1
|
+
// C++ types for Metadata API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Metadata {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class VersionInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
VersionInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
_Init();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
VersionInfo(const VersionInfo& _other)
|
|
30
|
+
: Core::JSON::Container()
|
|
31
|
+
, Hash(_other.Hash)
|
|
32
|
+
, Major(_other.Major)
|
|
33
|
+
, Minor(_other.Minor)
|
|
34
|
+
, Patch(_other.Patch)
|
|
35
|
+
{
|
|
36
|
+
_Init();
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
VersionInfo(VersionInfo&& _other) noexcept
|
|
40
|
+
: Core::JSON::Container()
|
|
41
|
+
, Hash(std::move(_other.Hash))
|
|
42
|
+
, Major(std::move(_other.Major))
|
|
43
|
+
, Minor(std::move(_other.Minor))
|
|
44
|
+
, Patch(std::move(_other.Patch))
|
|
45
|
+
{
|
|
46
|
+
_Init();
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
VersionInfo(const Exchange::Controller::IMetadata::Data::Version& _other)
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
Hash = _other.Hash;
|
|
53
|
+
Major = _other.Major;
|
|
54
|
+
Minor = _other.Minor;
|
|
55
|
+
Patch = _other.Patch;
|
|
56
|
+
_Init();
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
VersionInfo& operator=(const VersionInfo& _rhs)
|
|
60
|
+
{
|
|
61
|
+
Hash = _rhs.Hash;
|
|
62
|
+
Major = _rhs.Major;
|
|
63
|
+
Minor = _rhs.Minor;
|
|
64
|
+
Patch = _rhs.Patch;
|
|
65
|
+
return (*this);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
VersionInfo& operator=(VersionInfo&& _rhs) noexcept
|
|
69
|
+
{
|
|
70
|
+
Hash = std::move(_rhs.Hash);
|
|
71
|
+
Major = std::move(_rhs.Major);
|
|
72
|
+
Minor = std::move(_rhs.Minor);
|
|
73
|
+
Patch = std::move(_rhs.Patch);
|
|
74
|
+
return (*this);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
VersionInfo& operator=(const Exchange::Controller::IMetadata::Data::Version& _rhs)
|
|
78
|
+
{
|
|
79
|
+
Hash = _rhs.Hash;
|
|
80
|
+
Major = _rhs.Major;
|
|
81
|
+
Minor = _rhs.Minor;
|
|
82
|
+
Patch = _rhs.Patch;
|
|
83
|
+
return (*this);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
operator Exchange::Controller::IMetadata::Data::Version() const
|
|
87
|
+
{
|
|
88
|
+
Exchange::Controller::IMetadata::Data::Version _value{};
|
|
89
|
+
_value.Hash = Hash;
|
|
90
|
+
_value.Major = Major;
|
|
91
|
+
_value.Minor = Minor;
|
|
92
|
+
_value.Patch = Patch;
|
|
93
|
+
return (_value);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
~VersionInfo() = default;
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
bool IsDataValid() const
|
|
100
|
+
{
|
|
101
|
+
return ((((Hash.IsSet() == true) && (Hash.Value().size() >= 64 && Hash.Value().size() <= 64))) && (Major.IsSet() == true) && (Minor.IsSet() == true) && (Patch.IsSet() == true));
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
private:
|
|
105
|
+
void _Init()
|
|
106
|
+
{
|
|
107
|
+
Add(_T("hash"), &Hash);
|
|
108
|
+
Add(_T("major"), &Major);
|
|
109
|
+
Add(_T("minor"), &Minor);
|
|
110
|
+
Add(_T("patch"), &Patch);
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
public:
|
|
114
|
+
Core::JSON::String Hash; // SHA256 hash identifying the source code
|
|
115
|
+
Core::JSON::DecUInt8 Major; // Major number
|
|
116
|
+
Core::JSON::DecUInt8 Minor; // Minor number
|
|
117
|
+
Core::JSON::DecUInt8 Patch; // Patch number
|
|
118
|
+
}; // class VersionInfo
|
|
119
|
+
|
|
120
|
+
// Method params/result classes
|
|
121
|
+
//
|
|
122
|
+
|
|
123
|
+
class BuildInfoData : public Core::JSON::Container {
|
|
124
|
+
public:
|
|
125
|
+
BuildInfoData()
|
|
126
|
+
: Core::JSON::Container()
|
|
127
|
+
{
|
|
128
|
+
_Init();
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
BuildInfoData(const BuildInfoData& _other)
|
|
132
|
+
: Core::JSON::Container()
|
|
133
|
+
, SystemType(_other.SystemType)
|
|
134
|
+
, BuildType(_other.BuildType)
|
|
135
|
+
, Extensions(_other.Extensions)
|
|
136
|
+
, Messaging(_other.Messaging)
|
|
137
|
+
, ExceptionCatching(_other.ExceptionCatching)
|
|
138
|
+
, DeadlockDetection(_other.DeadlockDetection)
|
|
139
|
+
, WCharSupport(_other.WCharSupport)
|
|
140
|
+
, InstanceIDBits(_other.InstanceIDBits)
|
|
141
|
+
, TraceLevel(_other.TraceLevel)
|
|
142
|
+
, ThreadPoolCount(_other.ThreadPoolCount)
|
|
143
|
+
, COMRPCTimeOut(_other.COMRPCTimeOut)
|
|
144
|
+
{
|
|
145
|
+
_Init();
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
BuildInfoData(BuildInfoData&& _other) noexcept
|
|
149
|
+
: Core::JSON::Container()
|
|
150
|
+
, SystemType(std::move(_other.SystemType))
|
|
151
|
+
, BuildType(std::move(_other.BuildType))
|
|
152
|
+
, Extensions(std::move(_other.Extensions))
|
|
153
|
+
, Messaging(std::move(_other.Messaging))
|
|
154
|
+
, ExceptionCatching(std::move(_other.ExceptionCatching))
|
|
155
|
+
, DeadlockDetection(std::move(_other.DeadlockDetection))
|
|
156
|
+
, WCharSupport(std::move(_other.WCharSupport))
|
|
157
|
+
, InstanceIDBits(std::move(_other.InstanceIDBits))
|
|
158
|
+
, TraceLevel(std::move(_other.TraceLevel))
|
|
159
|
+
, ThreadPoolCount(std::move(_other.ThreadPoolCount))
|
|
160
|
+
, COMRPCTimeOut(std::move(_other.COMRPCTimeOut))
|
|
161
|
+
{
|
|
162
|
+
_Init();
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
BuildInfoData(const Exchange::Controller::IMetadata::Data::BuildInfo& _other)
|
|
166
|
+
: Core::JSON::Container()
|
|
167
|
+
{
|
|
168
|
+
SystemType = _other.SystemType;
|
|
169
|
+
BuildType = _other.BuildType;
|
|
170
|
+
if (_other.Extensions.IsSet() == true) {
|
|
171
|
+
Extensions.Set(true);
|
|
172
|
+
Extensions = _other.Extensions.Value();
|
|
173
|
+
}
|
|
174
|
+
Messaging = _other.Messaging;
|
|
175
|
+
ExceptionCatching = _other.ExceptionCatching;
|
|
176
|
+
DeadlockDetection = _other.DeadlockDetection;
|
|
177
|
+
WCharSupport = _other.WCharSupport;
|
|
178
|
+
InstanceIDBits = _other.InstanceIDBits;
|
|
179
|
+
if (_other.TraceLevel.IsSet() == true) {
|
|
180
|
+
TraceLevel = _other.TraceLevel.Value();
|
|
181
|
+
}
|
|
182
|
+
ThreadPoolCount = _other.ThreadPoolCount;
|
|
183
|
+
COMRPCTimeOut = _other.COMRPCTimeOut;
|
|
184
|
+
_Init();
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
BuildInfoData& operator=(const BuildInfoData& _rhs)
|
|
188
|
+
{
|
|
189
|
+
SystemType = _rhs.SystemType;
|
|
190
|
+
BuildType = _rhs.BuildType;
|
|
191
|
+
if (_rhs.Extensions.IsSet() == true) {
|
|
192
|
+
Extensions = _rhs.Extensions;
|
|
193
|
+
}
|
|
194
|
+
Messaging = _rhs.Messaging;
|
|
195
|
+
ExceptionCatching = _rhs.ExceptionCatching;
|
|
196
|
+
DeadlockDetection = _rhs.DeadlockDetection;
|
|
197
|
+
WCharSupport = _rhs.WCharSupport;
|
|
198
|
+
InstanceIDBits = _rhs.InstanceIDBits;
|
|
199
|
+
if (_rhs.TraceLevel.IsSet() == true) {
|
|
200
|
+
TraceLevel = _rhs.TraceLevel;
|
|
201
|
+
}
|
|
202
|
+
ThreadPoolCount = _rhs.ThreadPoolCount;
|
|
203
|
+
COMRPCTimeOut = _rhs.COMRPCTimeOut;
|
|
204
|
+
return (*this);
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
BuildInfoData& operator=(BuildInfoData&& _rhs) noexcept
|
|
208
|
+
{
|
|
209
|
+
SystemType = std::move(_rhs.SystemType);
|
|
210
|
+
BuildType = std::move(_rhs.BuildType);
|
|
211
|
+
Extensions = std::move(_rhs.Extensions);
|
|
212
|
+
Messaging = std::move(_rhs.Messaging);
|
|
213
|
+
ExceptionCatching = std::move(_rhs.ExceptionCatching);
|
|
214
|
+
DeadlockDetection = std::move(_rhs.DeadlockDetection);
|
|
215
|
+
WCharSupport = std::move(_rhs.WCharSupport);
|
|
216
|
+
InstanceIDBits = std::move(_rhs.InstanceIDBits);
|
|
217
|
+
TraceLevel = std::move(_rhs.TraceLevel);
|
|
218
|
+
ThreadPoolCount = std::move(_rhs.ThreadPoolCount);
|
|
219
|
+
COMRPCTimeOut = std::move(_rhs.COMRPCTimeOut);
|
|
220
|
+
return (*this);
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
BuildInfoData& operator=(const Exchange::Controller::IMetadata::Data::BuildInfo& _rhs)
|
|
224
|
+
{
|
|
225
|
+
SystemType = _rhs.SystemType;
|
|
226
|
+
BuildType = _rhs.BuildType;
|
|
227
|
+
if (_rhs.Extensions.IsSet() == true) {
|
|
228
|
+
Extensions.Set(true);
|
|
229
|
+
Extensions = _rhs.Extensions.Value();
|
|
230
|
+
}
|
|
231
|
+
Messaging = _rhs.Messaging;
|
|
232
|
+
ExceptionCatching = _rhs.ExceptionCatching;
|
|
233
|
+
DeadlockDetection = _rhs.DeadlockDetection;
|
|
234
|
+
WCharSupport = _rhs.WCharSupport;
|
|
235
|
+
InstanceIDBits = _rhs.InstanceIDBits;
|
|
236
|
+
if (_rhs.TraceLevel.IsSet() == true) {
|
|
237
|
+
TraceLevel = _rhs.TraceLevel.Value();
|
|
238
|
+
}
|
|
239
|
+
ThreadPoolCount = _rhs.ThreadPoolCount;
|
|
240
|
+
COMRPCTimeOut = _rhs.COMRPCTimeOut;
|
|
241
|
+
return (*this);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
operator Exchange::Controller::IMetadata::Data::BuildInfo() const
|
|
245
|
+
{
|
|
246
|
+
Exchange::Controller::IMetadata::Data::BuildInfo _value{};
|
|
247
|
+
_value.SystemType = SystemType;
|
|
248
|
+
_value.BuildType = BuildType;
|
|
249
|
+
if (Extensions.IsSet() == true) {
|
|
250
|
+
_value.Extensions = Extensions;
|
|
251
|
+
}
|
|
252
|
+
_value.Messaging = Messaging;
|
|
253
|
+
_value.ExceptionCatching = ExceptionCatching;
|
|
254
|
+
_value.DeadlockDetection = DeadlockDetection;
|
|
255
|
+
_value.WCharSupport = WCharSupport;
|
|
256
|
+
_value.InstanceIDBits = InstanceIDBits;
|
|
257
|
+
if (TraceLevel.IsSet() == true) {
|
|
258
|
+
_value.TraceLevel = TraceLevel;
|
|
259
|
+
}
|
|
260
|
+
_value.ThreadPoolCount = ThreadPoolCount;
|
|
261
|
+
_value.COMRPCTimeOut = COMRPCTimeOut;
|
|
262
|
+
return (_value);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
~BuildInfoData() = default;
|
|
266
|
+
|
|
267
|
+
public:
|
|
268
|
+
bool IsDataValid() const
|
|
269
|
+
{
|
|
270
|
+
return ((SystemType.IsSet() == true) && (BuildType.IsSet() == true) && (Messaging.IsSet() == true) && (ExceptionCatching.IsSet() == true) && (DeadlockDetection.IsSet() == true) && (WCharSupport.IsSet() == true) && (InstanceIDBits.IsSet() == true) && (ThreadPoolCount.IsSet() == true) && (COMRPCTimeOut.IsSet() == true));
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
private:
|
|
274
|
+
void _Init()
|
|
275
|
+
{
|
|
276
|
+
Add(_T("systemtype"), &SystemType);
|
|
277
|
+
Add(_T("buildtype"), &BuildType);
|
|
278
|
+
Add(_T("extensions"), &Extensions);
|
|
279
|
+
Add(_T("messaging"), &Messaging);
|
|
280
|
+
Add(_T("exceptioncatching"), &ExceptionCatching);
|
|
281
|
+
Add(_T("deadlockdetection"), &DeadlockDetection);
|
|
282
|
+
Add(_T("wcharsupport"), &WCharSupport);
|
|
283
|
+
Add(_T("instanceidbits"), &InstanceIDBits);
|
|
284
|
+
Add(_T("tracelevel"), &TraceLevel);
|
|
285
|
+
Add(_T("threadpoolcount"), &ThreadPoolCount);
|
|
286
|
+
Add(_T("comrpctimeout"), &COMRPCTimeOut);
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
public:
|
|
290
|
+
Core::JSON::EnumType<Exchange::Controller::IMetadata::Data::BuildInfo::systemtype> SystemType; // System type
|
|
291
|
+
Core::JSON::EnumType<Exchange::Controller::IMetadata::Data::BuildInfo::buildtype> BuildType; // Build type
|
|
292
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype>> Extensions; // Build information
|
|
293
|
+
Core::JSON::Boolean Messaging; // Denotes whether Messaging is enabled
|
|
294
|
+
Core::JSON::Boolean ExceptionCatching; // Denotes whether there is an exception
|
|
295
|
+
Core::JSON::Boolean DeadlockDetection; // Denotes whether deadlock detection is enabled
|
|
296
|
+
Core::JSON::Boolean WCharSupport; // Build information
|
|
297
|
+
Core::JSON::DecUInt8 InstanceIDBits; // Core instance bits
|
|
298
|
+
Core::JSON::DecUInt8 TraceLevel; // Trace level
|
|
299
|
+
Core::JSON::DecUInt8 ThreadPoolCount; // Build information
|
|
300
|
+
Core::JSON::DecUInt32 COMRPCTimeOut; // Build information
|
|
301
|
+
}; // class BuildInfoData
|
|
302
|
+
|
|
303
|
+
class CallStackData : public Core::JSON::Container {
|
|
304
|
+
public:
|
|
305
|
+
CallStackData()
|
|
306
|
+
: Core::JSON::Container()
|
|
307
|
+
{
|
|
308
|
+
_Init();
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
CallStackData(const CallStackData& _other)
|
|
312
|
+
: Core::JSON::Container()
|
|
313
|
+
, Address(_other.Address)
|
|
314
|
+
, Module(_other.Module)
|
|
315
|
+
, Function(_other.Function)
|
|
316
|
+
, Line(_other.Line)
|
|
317
|
+
{
|
|
318
|
+
_Init();
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
CallStackData(CallStackData&& _other) noexcept
|
|
322
|
+
: Core::JSON::Container()
|
|
323
|
+
, Address(std::move(_other.Address))
|
|
324
|
+
, Module(std::move(_other.Module))
|
|
325
|
+
, Function(std::move(_other.Function))
|
|
326
|
+
, Line(std::move(_other.Line))
|
|
327
|
+
{
|
|
328
|
+
_Init();
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
CallStackData(const Exchange::Controller::IMetadata::Data::CallStack& _other)
|
|
332
|
+
: Core::JSON::Container()
|
|
333
|
+
{
|
|
334
|
+
Address = _other.Address;
|
|
335
|
+
Module = _other.Module;
|
|
336
|
+
if (_other.Function.IsSet() == true) {
|
|
337
|
+
Function = _other.Function.Value();
|
|
338
|
+
}
|
|
339
|
+
if (_other.Line.IsSet() == true) {
|
|
340
|
+
Line = _other.Line.Value();
|
|
341
|
+
}
|
|
342
|
+
_Init();
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
CallStackData& operator=(const CallStackData& _rhs)
|
|
346
|
+
{
|
|
347
|
+
Address = _rhs.Address;
|
|
348
|
+
Module = _rhs.Module;
|
|
349
|
+
if (_rhs.Function.IsSet() == true) {
|
|
350
|
+
Function = _rhs.Function;
|
|
351
|
+
}
|
|
352
|
+
if (_rhs.Line.IsSet() == true) {
|
|
353
|
+
Line = _rhs.Line;
|
|
354
|
+
}
|
|
355
|
+
return (*this);
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
CallStackData& operator=(CallStackData&& _rhs) noexcept
|
|
359
|
+
{
|
|
360
|
+
Address = std::move(_rhs.Address);
|
|
361
|
+
Module = std::move(_rhs.Module);
|
|
362
|
+
Function = std::move(_rhs.Function);
|
|
363
|
+
Line = std::move(_rhs.Line);
|
|
364
|
+
return (*this);
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
CallStackData& operator=(const Exchange::Controller::IMetadata::Data::CallStack& _rhs)
|
|
368
|
+
{
|
|
369
|
+
Address = _rhs.Address;
|
|
370
|
+
Module = _rhs.Module;
|
|
371
|
+
if (_rhs.Function.IsSet() == true) {
|
|
372
|
+
Function = _rhs.Function.Value();
|
|
373
|
+
}
|
|
374
|
+
if (_rhs.Line.IsSet() == true) {
|
|
375
|
+
Line = _rhs.Line.Value();
|
|
376
|
+
}
|
|
377
|
+
return (*this);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
operator Exchange::Controller::IMetadata::Data::CallStack() const
|
|
381
|
+
{
|
|
382
|
+
Exchange::Controller::IMetadata::Data::CallStack _value{};
|
|
383
|
+
_value.Address = Address;
|
|
384
|
+
_value.Module = Module;
|
|
385
|
+
if (Function.IsSet() == true) {
|
|
386
|
+
_value.Function = Function;
|
|
387
|
+
}
|
|
388
|
+
if (Line.IsSet() == true) {
|
|
389
|
+
_value.Line = Line;
|
|
390
|
+
}
|
|
391
|
+
return (_value);
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
~CallStackData() = default;
|
|
395
|
+
|
|
396
|
+
public:
|
|
397
|
+
bool IsDataValid() const
|
|
398
|
+
{
|
|
399
|
+
return ((Address.IsSet() == true) && (Module.IsSet() == true));
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
private:
|
|
403
|
+
void _Init()
|
|
404
|
+
{
|
|
405
|
+
Add(_T("address"), &Address);
|
|
406
|
+
Add(_T("module"), &Module);
|
|
407
|
+
Add(_T("function"), &Function);
|
|
408
|
+
Add(_T("line"), &Line);
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
public:
|
|
412
|
+
Core::JSON::InstanceId Address; // Memory address
|
|
413
|
+
Core::JSON::String Module; // Module name
|
|
414
|
+
Core::JSON::String Function; // Function name
|
|
415
|
+
Core::JSON::DecUInt32 Line; // Line number
|
|
416
|
+
}; // class CallStackData
|
|
417
|
+
|
|
418
|
+
class LinkData : public Core::JSON::Container {
|
|
419
|
+
public:
|
|
420
|
+
LinkData()
|
|
421
|
+
: Core::JSON::Container()
|
|
422
|
+
{
|
|
423
|
+
_Init();
|
|
424
|
+
}
|
|
425
|
+
|
|
426
|
+
LinkData(const LinkData& _other)
|
|
427
|
+
: Core::JSON::Container()
|
|
428
|
+
, Remote(_other.Remote)
|
|
429
|
+
, State(_other.State)
|
|
430
|
+
, Id(_other.Id)
|
|
431
|
+
, Activity(_other.Activity)
|
|
432
|
+
, Name(_other.Name)
|
|
433
|
+
{
|
|
434
|
+
_Init();
|
|
435
|
+
}
|
|
436
|
+
|
|
437
|
+
LinkData(LinkData&& _other) noexcept
|
|
438
|
+
: Core::JSON::Container()
|
|
439
|
+
, Remote(std::move(_other.Remote))
|
|
440
|
+
, State(std::move(_other.State))
|
|
441
|
+
, Id(std::move(_other.Id))
|
|
442
|
+
, Activity(std::move(_other.Activity))
|
|
443
|
+
, Name(std::move(_other.Name))
|
|
444
|
+
{
|
|
445
|
+
_Init();
|
|
446
|
+
}
|
|
447
|
+
|
|
448
|
+
LinkData(const Exchange::Controller::IMetadata::Data::Link& _other)
|
|
449
|
+
: Core::JSON::Container()
|
|
450
|
+
{
|
|
451
|
+
Remote = _other.Remote;
|
|
452
|
+
State = _other.State;
|
|
453
|
+
Id = _other.Id;
|
|
454
|
+
Activity = _other.Activity;
|
|
455
|
+
if (_other.Name.IsSet() == true) {
|
|
456
|
+
Name = _other.Name.Value();
|
|
457
|
+
}
|
|
458
|
+
_Init();
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
LinkData& operator=(const LinkData& _rhs)
|
|
462
|
+
{
|
|
463
|
+
Remote = _rhs.Remote;
|
|
464
|
+
State = _rhs.State;
|
|
465
|
+
Id = _rhs.Id;
|
|
466
|
+
Activity = _rhs.Activity;
|
|
467
|
+
if (_rhs.Name.IsSet() == true) {
|
|
468
|
+
Name = _rhs.Name;
|
|
469
|
+
}
|
|
470
|
+
return (*this);
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
LinkData& operator=(LinkData&& _rhs) noexcept
|
|
474
|
+
{
|
|
475
|
+
Remote = std::move(_rhs.Remote);
|
|
476
|
+
State = std::move(_rhs.State);
|
|
477
|
+
Id = std::move(_rhs.Id);
|
|
478
|
+
Activity = std::move(_rhs.Activity);
|
|
479
|
+
Name = std::move(_rhs.Name);
|
|
480
|
+
return (*this);
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
LinkData& operator=(const Exchange::Controller::IMetadata::Data::Link& _rhs)
|
|
484
|
+
{
|
|
485
|
+
Remote = _rhs.Remote;
|
|
486
|
+
State = _rhs.State;
|
|
487
|
+
Id = _rhs.Id;
|
|
488
|
+
Activity = _rhs.Activity;
|
|
489
|
+
if (_rhs.Name.IsSet() == true) {
|
|
490
|
+
Name = _rhs.Name.Value();
|
|
491
|
+
}
|
|
492
|
+
return (*this);
|
|
493
|
+
}
|
|
494
|
+
|
|
495
|
+
operator Exchange::Controller::IMetadata::Data::Link() const
|
|
496
|
+
{
|
|
497
|
+
Exchange::Controller::IMetadata::Data::Link _value{};
|
|
498
|
+
_value.Remote = Remote;
|
|
499
|
+
_value.State = State;
|
|
500
|
+
_value.Id = Id;
|
|
501
|
+
_value.Activity = Activity;
|
|
502
|
+
if (Name.IsSet() == true) {
|
|
503
|
+
_value.Name = Name;
|
|
504
|
+
}
|
|
505
|
+
return (_value);
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
~LinkData() = default;
|
|
509
|
+
|
|
510
|
+
public:
|
|
511
|
+
bool IsDataValid() const
|
|
512
|
+
{
|
|
513
|
+
return ((Remote.IsSet() == true) && (State.IsSet() == true) && (Id.IsSet() == true) && (Activity.IsSet() == true));
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
private:
|
|
517
|
+
void _Init()
|
|
518
|
+
{
|
|
519
|
+
Add(_T("remote"), &Remote);
|
|
520
|
+
Add(_T("state"), &State);
|
|
521
|
+
Add(_T("id"), &Id);
|
|
522
|
+
Add(_T("activity"), &Activity);
|
|
523
|
+
Add(_T("name"), &Name);
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
public:
|
|
527
|
+
Core::JSON::String Remote; // IP address (or FQDN) of the other side of the connection
|
|
528
|
+
Core::JSON::EnumType<Exchange::Controller::IMetadata::Data::Link::state> State; // State of the link
|
|
529
|
+
Core::JSON::DecUInt32 Id; // A unique number identifying the connection
|
|
530
|
+
Core::JSON::Boolean Activity; // Denotes if there was any activity on this connection
|
|
531
|
+
Core::JSON::String Name; // Name of the connection
|
|
532
|
+
}; // class LinkData
|
|
533
|
+
|
|
534
|
+
class ProxyData : public Core::JSON::Container {
|
|
535
|
+
public:
|
|
536
|
+
ProxyData()
|
|
537
|
+
: Core::JSON::Container()
|
|
538
|
+
{
|
|
539
|
+
_Init();
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
ProxyData(const ProxyData& _other)
|
|
543
|
+
: Core::JSON::Container()
|
|
544
|
+
, Interface(_other.Interface)
|
|
545
|
+
, Name(_other.Name)
|
|
546
|
+
, Instance(_other.Instance)
|
|
547
|
+
, Count(_other.Count)
|
|
548
|
+
, Origin(_other.Origin)
|
|
549
|
+
{
|
|
550
|
+
_Init();
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
ProxyData(ProxyData&& _other) noexcept
|
|
554
|
+
: Core::JSON::Container()
|
|
555
|
+
, Interface(std::move(_other.Interface))
|
|
556
|
+
, Name(std::move(_other.Name))
|
|
557
|
+
, Instance(std::move(_other.Instance))
|
|
558
|
+
, Count(std::move(_other.Count))
|
|
559
|
+
, Origin(std::move(_other.Origin))
|
|
560
|
+
{
|
|
561
|
+
_Init();
|
|
562
|
+
}
|
|
563
|
+
|
|
564
|
+
ProxyData(const Exchange::Controller::IMetadata::Data::Proxy& _other)
|
|
565
|
+
: Core::JSON::Container()
|
|
566
|
+
{
|
|
567
|
+
Interface = _other.Interface;
|
|
568
|
+
Name = _other.Name;
|
|
569
|
+
Instance = _other.Instance;
|
|
570
|
+
Count = _other.Count;
|
|
571
|
+
if (_other.Origin.IsSet() == true) {
|
|
572
|
+
Origin = _other.Origin.Value();
|
|
573
|
+
}
|
|
574
|
+
_Init();
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
ProxyData& operator=(const ProxyData& _rhs)
|
|
578
|
+
{
|
|
579
|
+
Interface = _rhs.Interface;
|
|
580
|
+
Name = _rhs.Name;
|
|
581
|
+
Instance = _rhs.Instance;
|
|
582
|
+
Count = _rhs.Count;
|
|
583
|
+
if (_rhs.Origin.IsSet() == true) {
|
|
584
|
+
Origin = _rhs.Origin;
|
|
585
|
+
}
|
|
586
|
+
return (*this);
|
|
587
|
+
}
|
|
588
|
+
|
|
589
|
+
ProxyData& operator=(ProxyData&& _rhs) noexcept
|
|
590
|
+
{
|
|
591
|
+
Interface = std::move(_rhs.Interface);
|
|
592
|
+
Name = std::move(_rhs.Name);
|
|
593
|
+
Instance = std::move(_rhs.Instance);
|
|
594
|
+
Count = std::move(_rhs.Count);
|
|
595
|
+
Origin = std::move(_rhs.Origin);
|
|
596
|
+
return (*this);
|
|
597
|
+
}
|
|
598
|
+
|
|
599
|
+
ProxyData& operator=(const Exchange::Controller::IMetadata::Data::Proxy& _rhs)
|
|
600
|
+
{
|
|
601
|
+
Interface = _rhs.Interface;
|
|
602
|
+
Name = _rhs.Name;
|
|
603
|
+
Instance = _rhs.Instance;
|
|
604
|
+
Count = _rhs.Count;
|
|
605
|
+
if (_rhs.Origin.IsSet() == true) {
|
|
606
|
+
Origin = _rhs.Origin.Value();
|
|
607
|
+
}
|
|
608
|
+
return (*this);
|
|
609
|
+
}
|
|
610
|
+
|
|
611
|
+
operator Exchange::Controller::IMetadata::Data::Proxy() const
|
|
612
|
+
{
|
|
613
|
+
Exchange::Controller::IMetadata::Data::Proxy _value{};
|
|
614
|
+
_value.Interface = Interface;
|
|
615
|
+
_value.Name = Name;
|
|
616
|
+
_value.Instance = Instance;
|
|
617
|
+
_value.Count = Count;
|
|
618
|
+
if (Origin.IsSet() == true) {
|
|
619
|
+
_value.Origin = Origin;
|
|
620
|
+
}
|
|
621
|
+
return (_value);
|
|
622
|
+
}
|
|
623
|
+
|
|
624
|
+
~ProxyData() = default;
|
|
625
|
+
|
|
626
|
+
public:
|
|
627
|
+
bool IsDataValid() const
|
|
628
|
+
{
|
|
629
|
+
return ((Interface.IsSet() == true) && (Name.IsSet() == true) && (Instance.IsSet() == true) && (Count.IsSet() == true));
|
|
630
|
+
}
|
|
631
|
+
|
|
632
|
+
private:
|
|
633
|
+
void _Init()
|
|
634
|
+
{
|
|
635
|
+
Add(_T("interface"), &Interface);
|
|
636
|
+
Add(_T("name"), &Name);
|
|
637
|
+
Add(_T("instance"), &Instance);
|
|
638
|
+
Add(_T("count"), &Count);
|
|
639
|
+
Add(_T("origin"), &Origin);
|
|
640
|
+
}
|
|
641
|
+
|
|
642
|
+
public:
|
|
643
|
+
Core::JSON::DecUInt32 Interface; // Interface ID
|
|
644
|
+
Core::JSON::String Name; // The fully qualified name of the interface
|
|
645
|
+
Core::JSON::InstanceId Instance; // Instance ID
|
|
646
|
+
Core::JSON::DecUInt32 Count; // Reference count
|
|
647
|
+
Core::JSON::String Origin; // The Origin of the assocated connection
|
|
648
|
+
}; // class ProxyData
|
|
649
|
+
|
|
650
|
+
class ServiceData : public Core::JSON::Container {
|
|
651
|
+
public:
|
|
652
|
+
ServiceData()
|
|
653
|
+
: Core::JSON::Container()
|
|
654
|
+
{
|
|
655
|
+
_Init();
|
|
656
|
+
}
|
|
657
|
+
|
|
658
|
+
ServiceData(const ServiceData& _other)
|
|
659
|
+
: Core::JSON::Container()
|
|
660
|
+
, Callsign(_other.Callsign)
|
|
661
|
+
, Locator(_other.Locator)
|
|
662
|
+
, ClassName(_other.ClassName)
|
|
663
|
+
, Module(_other.Module)
|
|
664
|
+
, State(_other.State)
|
|
665
|
+
, StartMode(_other.StartMode)
|
|
666
|
+
, Resumed(_other.Resumed)
|
|
667
|
+
, Version(_other.Version)
|
|
668
|
+
, Communicator(_other.Communicator)
|
|
669
|
+
, PersistentPathPostfix(_other.PersistentPathPostfix)
|
|
670
|
+
, VolatilePathPostfix(_other.VolatilePathPostfix)
|
|
671
|
+
, SystemRootPath(_other.SystemRootPath)
|
|
672
|
+
, Precondition(_other.Precondition)
|
|
673
|
+
, Termination(_other.Termination)
|
|
674
|
+
, Control(_other.Control)
|
|
675
|
+
, Configuration(_other.Configuration)
|
|
676
|
+
, Observers(_other.Observers)
|
|
677
|
+
, ProcessedRequests(_other.ProcessedRequests)
|
|
678
|
+
, ProcessedObjects(_other.ProcessedObjects)
|
|
679
|
+
{
|
|
680
|
+
_Init();
|
|
681
|
+
}
|
|
682
|
+
|
|
683
|
+
ServiceData(ServiceData&& _other) noexcept
|
|
684
|
+
: Core::JSON::Container()
|
|
685
|
+
, Callsign(std::move(_other.Callsign))
|
|
686
|
+
, Locator(std::move(_other.Locator))
|
|
687
|
+
, ClassName(std::move(_other.ClassName))
|
|
688
|
+
, Module(std::move(_other.Module))
|
|
689
|
+
, State(std::move(_other.State))
|
|
690
|
+
, StartMode(std::move(_other.StartMode))
|
|
691
|
+
, Resumed(std::move(_other.Resumed))
|
|
692
|
+
, Version(std::move(_other.Version))
|
|
693
|
+
, Communicator(std::move(_other.Communicator))
|
|
694
|
+
, PersistentPathPostfix(std::move(_other.PersistentPathPostfix))
|
|
695
|
+
, VolatilePathPostfix(std::move(_other.VolatilePathPostfix))
|
|
696
|
+
, SystemRootPath(std::move(_other.SystemRootPath))
|
|
697
|
+
, Precondition(std::move(_other.Precondition))
|
|
698
|
+
, Termination(std::move(_other.Termination))
|
|
699
|
+
, Control(std::move(_other.Control))
|
|
700
|
+
, Configuration(std::move(_other.Configuration))
|
|
701
|
+
, Observers(std::move(_other.Observers))
|
|
702
|
+
, ProcessedRequests(std::move(_other.ProcessedRequests))
|
|
703
|
+
, ProcessedObjects(std::move(_other.ProcessedObjects))
|
|
704
|
+
{
|
|
705
|
+
_Init();
|
|
706
|
+
}
|
|
707
|
+
|
|
708
|
+
ServiceData(const Exchange::Controller::IMetadata::Data::Service& _other)
|
|
709
|
+
: Core::JSON::Container()
|
|
710
|
+
{
|
|
711
|
+
Callsign = _other.Callsign;
|
|
712
|
+
Locator = _other.Locator;
|
|
713
|
+
ClassName = _other.ClassName;
|
|
714
|
+
Module = _other.Module;
|
|
715
|
+
State = _other.State;
|
|
716
|
+
StartMode = _other.StartMode;
|
|
717
|
+
Resumed = _other.Resumed;
|
|
718
|
+
Version.Set(true);
|
|
719
|
+
Version = _other.Version;
|
|
720
|
+
if (_other.Communicator.IsSet() == true) {
|
|
721
|
+
Communicator = _other.Communicator.Value();
|
|
722
|
+
}
|
|
723
|
+
if (_other.PersistentPathPostfix.IsSet() == true) {
|
|
724
|
+
PersistentPathPostfix = _other.PersistentPathPostfix.Value();
|
|
725
|
+
}
|
|
726
|
+
if (_other.VolatilePathPostfix.IsSet() == true) {
|
|
727
|
+
VolatilePathPostfix = _other.VolatilePathPostfix.Value();
|
|
728
|
+
}
|
|
729
|
+
if (_other.SystemRootPath.IsSet() == true) {
|
|
730
|
+
SystemRootPath = _other.SystemRootPath.Value();
|
|
731
|
+
}
|
|
732
|
+
if (_other.Precondition.IsSet() == true) {
|
|
733
|
+
Precondition = _other.Precondition.Value();
|
|
734
|
+
}
|
|
735
|
+
if (_other.Termination.IsSet() == true) {
|
|
736
|
+
Termination = _other.Termination.Value();
|
|
737
|
+
}
|
|
738
|
+
if (_other.Control.IsSet() == true) {
|
|
739
|
+
Control = _other.Control.Value();
|
|
740
|
+
}
|
|
741
|
+
if (_other.Configuration.empty() == false) {
|
|
742
|
+
Configuration = _other.Configuration;
|
|
743
|
+
}
|
|
744
|
+
Observers = _other.Observers;
|
|
745
|
+
if (_other.ProcessedRequests.IsSet() == true) {
|
|
746
|
+
ProcessedRequests = _other.ProcessedRequests.Value();
|
|
747
|
+
}
|
|
748
|
+
if (_other.ProcessedObjects.IsSet() == true) {
|
|
749
|
+
ProcessedObjects = _other.ProcessedObjects.Value();
|
|
750
|
+
}
|
|
751
|
+
_Init();
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
ServiceData& operator=(const ServiceData& _rhs)
|
|
755
|
+
{
|
|
756
|
+
Callsign = _rhs.Callsign;
|
|
757
|
+
Locator = _rhs.Locator;
|
|
758
|
+
ClassName = _rhs.ClassName;
|
|
759
|
+
Module = _rhs.Module;
|
|
760
|
+
State = _rhs.State;
|
|
761
|
+
StartMode = _rhs.StartMode;
|
|
762
|
+
Resumed = _rhs.Resumed;
|
|
763
|
+
Version = _rhs.Version;
|
|
764
|
+
if (_rhs.Communicator.IsSet() == true) {
|
|
765
|
+
Communicator = _rhs.Communicator;
|
|
766
|
+
}
|
|
767
|
+
if (_rhs.PersistentPathPostfix.IsSet() == true) {
|
|
768
|
+
PersistentPathPostfix = _rhs.PersistentPathPostfix;
|
|
769
|
+
}
|
|
770
|
+
if (_rhs.VolatilePathPostfix.IsSet() == true) {
|
|
771
|
+
VolatilePathPostfix = _rhs.VolatilePathPostfix;
|
|
772
|
+
}
|
|
773
|
+
if (_rhs.SystemRootPath.IsSet() == true) {
|
|
774
|
+
SystemRootPath = _rhs.SystemRootPath;
|
|
775
|
+
}
|
|
776
|
+
if (_rhs.Precondition.IsSet() == true) {
|
|
777
|
+
Precondition = _rhs.Precondition;
|
|
778
|
+
}
|
|
779
|
+
if (_rhs.Termination.IsSet() == true) {
|
|
780
|
+
Termination = _rhs.Termination;
|
|
781
|
+
}
|
|
782
|
+
if (_rhs.Control.IsSet() == true) {
|
|
783
|
+
Control = _rhs.Control;
|
|
784
|
+
}
|
|
785
|
+
if (_rhs.Configuration.Value().empty() == false) {
|
|
786
|
+
Configuration = _rhs.Configuration;
|
|
787
|
+
}
|
|
788
|
+
Observers = _rhs.Observers;
|
|
789
|
+
if (_rhs.ProcessedRequests.IsSet() == true) {
|
|
790
|
+
ProcessedRequests = _rhs.ProcessedRequests;
|
|
791
|
+
}
|
|
792
|
+
if (_rhs.ProcessedObjects.IsSet() == true) {
|
|
793
|
+
ProcessedObjects = _rhs.ProcessedObjects;
|
|
794
|
+
}
|
|
795
|
+
return (*this);
|
|
796
|
+
}
|
|
797
|
+
|
|
798
|
+
ServiceData& operator=(ServiceData&& _rhs) noexcept
|
|
799
|
+
{
|
|
800
|
+
Callsign = std::move(_rhs.Callsign);
|
|
801
|
+
Locator = std::move(_rhs.Locator);
|
|
802
|
+
ClassName = std::move(_rhs.ClassName);
|
|
803
|
+
Module = std::move(_rhs.Module);
|
|
804
|
+
State = std::move(_rhs.State);
|
|
805
|
+
StartMode = std::move(_rhs.StartMode);
|
|
806
|
+
Resumed = std::move(_rhs.Resumed);
|
|
807
|
+
Version = std::move(_rhs.Version);
|
|
808
|
+
Communicator = std::move(_rhs.Communicator);
|
|
809
|
+
PersistentPathPostfix = std::move(_rhs.PersistentPathPostfix);
|
|
810
|
+
VolatilePathPostfix = std::move(_rhs.VolatilePathPostfix);
|
|
811
|
+
SystemRootPath = std::move(_rhs.SystemRootPath);
|
|
812
|
+
Precondition = std::move(_rhs.Precondition);
|
|
813
|
+
Termination = std::move(_rhs.Termination);
|
|
814
|
+
Control = std::move(_rhs.Control);
|
|
815
|
+
Configuration = std::move(_rhs.Configuration);
|
|
816
|
+
Observers = std::move(_rhs.Observers);
|
|
817
|
+
ProcessedRequests = std::move(_rhs.ProcessedRequests);
|
|
818
|
+
ProcessedObjects = std::move(_rhs.ProcessedObjects);
|
|
819
|
+
return (*this);
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
ServiceData& operator=(const Exchange::Controller::IMetadata::Data::Service& _rhs)
|
|
823
|
+
{
|
|
824
|
+
Callsign = _rhs.Callsign;
|
|
825
|
+
Locator = _rhs.Locator;
|
|
826
|
+
ClassName = _rhs.ClassName;
|
|
827
|
+
Module = _rhs.Module;
|
|
828
|
+
State = _rhs.State;
|
|
829
|
+
StartMode = _rhs.StartMode;
|
|
830
|
+
Resumed = _rhs.Resumed;
|
|
831
|
+
Version.Set(true);
|
|
832
|
+
Version = _rhs.Version;
|
|
833
|
+
if (_rhs.Communicator.IsSet() == true) {
|
|
834
|
+
Communicator = _rhs.Communicator.Value();
|
|
835
|
+
}
|
|
836
|
+
if (_rhs.PersistentPathPostfix.IsSet() == true) {
|
|
837
|
+
PersistentPathPostfix = _rhs.PersistentPathPostfix.Value();
|
|
838
|
+
}
|
|
839
|
+
if (_rhs.VolatilePathPostfix.IsSet() == true) {
|
|
840
|
+
VolatilePathPostfix = _rhs.VolatilePathPostfix.Value();
|
|
841
|
+
}
|
|
842
|
+
if (_rhs.SystemRootPath.IsSet() == true) {
|
|
843
|
+
SystemRootPath = _rhs.SystemRootPath.Value();
|
|
844
|
+
}
|
|
845
|
+
if (_rhs.Precondition.IsSet() == true) {
|
|
846
|
+
Precondition = _rhs.Precondition.Value();
|
|
847
|
+
}
|
|
848
|
+
if (_rhs.Termination.IsSet() == true) {
|
|
849
|
+
Termination = _rhs.Termination.Value();
|
|
850
|
+
}
|
|
851
|
+
if (_rhs.Control.IsSet() == true) {
|
|
852
|
+
Control = _rhs.Control.Value();
|
|
853
|
+
}
|
|
854
|
+
if (_rhs.Configuration.empty() == false) {
|
|
855
|
+
Configuration = _rhs.Configuration;
|
|
856
|
+
}
|
|
857
|
+
Observers = _rhs.Observers;
|
|
858
|
+
if (_rhs.ProcessedRequests.IsSet() == true) {
|
|
859
|
+
ProcessedRequests = _rhs.ProcessedRequests.Value();
|
|
860
|
+
}
|
|
861
|
+
if (_rhs.ProcessedObjects.IsSet() == true) {
|
|
862
|
+
ProcessedObjects = _rhs.ProcessedObjects.Value();
|
|
863
|
+
}
|
|
864
|
+
return (*this);
|
|
865
|
+
}
|
|
866
|
+
|
|
867
|
+
operator Exchange::Controller::IMetadata::Data::Service() const
|
|
868
|
+
{
|
|
869
|
+
Exchange::Controller::IMetadata::Data::Service _value{};
|
|
870
|
+
_value.Callsign = Callsign;
|
|
871
|
+
_value.Locator = Locator;
|
|
872
|
+
_value.ClassName = ClassName;
|
|
873
|
+
_value.Module = Module;
|
|
874
|
+
_value.State = State;
|
|
875
|
+
_value.StartMode = StartMode;
|
|
876
|
+
_value.Resumed = Resumed;
|
|
877
|
+
_value.Version = Version;
|
|
878
|
+
if (Communicator.IsSet() == true) {
|
|
879
|
+
_value.Communicator = Communicator;
|
|
880
|
+
}
|
|
881
|
+
if (PersistentPathPostfix.IsSet() == true) {
|
|
882
|
+
_value.PersistentPathPostfix = PersistentPathPostfix;
|
|
883
|
+
}
|
|
884
|
+
if (VolatilePathPostfix.IsSet() == true) {
|
|
885
|
+
_value.VolatilePathPostfix = VolatilePathPostfix;
|
|
886
|
+
}
|
|
887
|
+
if (SystemRootPath.IsSet() == true) {
|
|
888
|
+
_value.SystemRootPath = SystemRootPath;
|
|
889
|
+
}
|
|
890
|
+
if (Precondition.IsSet() == true) {
|
|
891
|
+
_value.Precondition = Precondition;
|
|
892
|
+
}
|
|
893
|
+
if (Termination.IsSet() == true) {
|
|
894
|
+
_value.Termination = Termination;
|
|
895
|
+
}
|
|
896
|
+
if (Control.IsSet() == true) {
|
|
897
|
+
_value.Control = Control;
|
|
898
|
+
}
|
|
899
|
+
_value.Configuration = Configuration;
|
|
900
|
+
_value.Observers = Observers;
|
|
901
|
+
if (ProcessedRequests.IsSet() == true) {
|
|
902
|
+
_value.ProcessedRequests = ProcessedRequests;
|
|
903
|
+
}
|
|
904
|
+
if (ProcessedObjects.IsSet() == true) {
|
|
905
|
+
_value.ProcessedObjects = ProcessedObjects;
|
|
906
|
+
}
|
|
907
|
+
return (_value);
|
|
908
|
+
}
|
|
909
|
+
|
|
910
|
+
~ServiceData() = default;
|
|
911
|
+
|
|
912
|
+
public:
|
|
913
|
+
bool IsDataValid() const
|
|
914
|
+
{
|
|
915
|
+
return ((Callsign.IsSet() == true) && (Locator.IsSet() == true) && (ClassName.IsSet() == true) && (Module.IsSet() == true) && (State.IsSet() == true) && (StartMode.IsSet() == true) && (Resumed.IsSet() == true) && ((Version.IsSet() == true) && (Version.IsDataValid() == true)) && (Observers.IsSet() == true));
|
|
916
|
+
}
|
|
917
|
+
|
|
918
|
+
private:
|
|
919
|
+
void _Init()
|
|
920
|
+
{
|
|
921
|
+
Add(_T("callsign"), &Callsign);
|
|
922
|
+
Add(_T("locator"), &Locator);
|
|
923
|
+
Add(_T("classname"), &ClassName);
|
|
924
|
+
Add(_T("module"), &Module);
|
|
925
|
+
Add(_T("state"), &State);
|
|
926
|
+
Add(_T("startmode"), &StartMode);
|
|
927
|
+
Add(_T("resumed"), &Resumed);
|
|
928
|
+
Add(_T("version"), &Version);
|
|
929
|
+
Add(_T("communicator"), &Communicator);
|
|
930
|
+
Add(_T("persistentpathpostfix"), &PersistentPathPostfix);
|
|
931
|
+
Add(_T("volatilepathpostfix"), &VolatilePathPostfix);
|
|
932
|
+
Add(_T("systemrootpath"), &SystemRootPath);
|
|
933
|
+
Add(_T("precondition"), &Precondition);
|
|
934
|
+
Precondition.SetQuoted(false);
|
|
935
|
+
Add(_T("termination"), &Termination);
|
|
936
|
+
Termination.SetQuoted(false);
|
|
937
|
+
Add(_T("control"), &Control);
|
|
938
|
+
Control.SetQuoted(false);
|
|
939
|
+
Add(_T("configuration"), &Configuration);
|
|
940
|
+
Configuration.SetQuoted(false);
|
|
941
|
+
Add(_T("observers"), &Observers);
|
|
942
|
+
Add(_T("processedrequests"), &ProcessedRequests);
|
|
943
|
+
Add(_T("processedobjects"), &ProcessedObjects);
|
|
944
|
+
}
|
|
945
|
+
|
|
946
|
+
public:
|
|
947
|
+
Core::JSON::String Callsign; // Plugin callsign
|
|
948
|
+
Core::JSON::String Locator; // Shared library path
|
|
949
|
+
Core::JSON::String ClassName; // Plugin class name
|
|
950
|
+
Core::JSON::String Module; // Module name
|
|
951
|
+
Core::JSON::EnumType<Exchange::Controller::IMetadata::Data::Service::state> State; // Current state
|
|
952
|
+
Core::JSON::EnumType<PluginHost::IShell::startmode> StartMode; // Startup mode
|
|
953
|
+
Core::JSON::Boolean Resumed; // Determines if the plugin is to be activated in resumed or suspended mode
|
|
954
|
+
VersionInfo Version; // Version
|
|
955
|
+
Core::JSON::String Communicator; // Communicator
|
|
956
|
+
Core::JSON::String PersistentPathPostfix; // Postfix of persistent path
|
|
957
|
+
Core::JSON::String VolatilePathPostfix; // Postfix of volatile path
|
|
958
|
+
Core::JSON::String SystemRootPath; // Path of system root
|
|
959
|
+
Core::JSON::String Precondition; // Activation conditons
|
|
960
|
+
Core::JSON::String Termination; // Deactivation conditions
|
|
961
|
+
Core::JSON::String Control; // Conditions controlled by this service
|
|
962
|
+
Core::JSON::String Configuration; // Plugin configuration
|
|
963
|
+
Core::JSON::DecUInt16 Observers; // Number or observers
|
|
964
|
+
Core::JSON::DecUInt32 ProcessedRequests; // Number of API requests that have been processed by the plugin
|
|
965
|
+
Core::JSON::DecUInt32 ProcessedObjects; // Number of objects that have been processed by the plugin
|
|
966
|
+
}; // class ServiceData
|
|
967
|
+
|
|
968
|
+
class ThreadData : public Core::JSON::Container {
|
|
969
|
+
public:
|
|
970
|
+
ThreadData()
|
|
971
|
+
: Core::JSON::Container()
|
|
972
|
+
{
|
|
973
|
+
_Init();
|
|
974
|
+
}
|
|
975
|
+
|
|
976
|
+
ThreadData(const ThreadData& _other)
|
|
977
|
+
: Core::JSON::Container()
|
|
978
|
+
, Id(_other.Id)
|
|
979
|
+
, Job(_other.Job)
|
|
980
|
+
, Runs(_other.Runs)
|
|
981
|
+
{
|
|
982
|
+
_Init();
|
|
983
|
+
}
|
|
984
|
+
|
|
985
|
+
ThreadData(ThreadData&& _other) noexcept
|
|
986
|
+
: Core::JSON::Container()
|
|
987
|
+
, Id(std::move(_other.Id))
|
|
988
|
+
, Job(std::move(_other.Job))
|
|
989
|
+
, Runs(std::move(_other.Runs))
|
|
990
|
+
{
|
|
991
|
+
_Init();
|
|
992
|
+
}
|
|
993
|
+
|
|
994
|
+
ThreadData(const Exchange::Controller::IMetadata::Data::Thread& _other)
|
|
995
|
+
: Core::JSON::Container()
|
|
996
|
+
{
|
|
997
|
+
Id = _other.Id;
|
|
998
|
+
Job = _other.Job;
|
|
999
|
+
Runs = _other.Runs;
|
|
1000
|
+
_Init();
|
|
1001
|
+
}
|
|
1002
|
+
|
|
1003
|
+
ThreadData& operator=(const ThreadData& _rhs)
|
|
1004
|
+
{
|
|
1005
|
+
Id = _rhs.Id;
|
|
1006
|
+
Job = _rhs.Job;
|
|
1007
|
+
Runs = _rhs.Runs;
|
|
1008
|
+
return (*this);
|
|
1009
|
+
}
|
|
1010
|
+
|
|
1011
|
+
ThreadData& operator=(ThreadData&& _rhs) noexcept
|
|
1012
|
+
{
|
|
1013
|
+
Id = std::move(_rhs.Id);
|
|
1014
|
+
Job = std::move(_rhs.Job);
|
|
1015
|
+
Runs = std::move(_rhs.Runs);
|
|
1016
|
+
return (*this);
|
|
1017
|
+
}
|
|
1018
|
+
|
|
1019
|
+
ThreadData& operator=(const Exchange::Controller::IMetadata::Data::Thread& _rhs)
|
|
1020
|
+
{
|
|
1021
|
+
Id = _rhs.Id;
|
|
1022
|
+
Job = _rhs.Job;
|
|
1023
|
+
Runs = _rhs.Runs;
|
|
1024
|
+
return (*this);
|
|
1025
|
+
}
|
|
1026
|
+
|
|
1027
|
+
operator Exchange::Controller::IMetadata::Data::Thread() const
|
|
1028
|
+
{
|
|
1029
|
+
Exchange::Controller::IMetadata::Data::Thread _value{};
|
|
1030
|
+
_value.Id = Id;
|
|
1031
|
+
_value.Job = Job;
|
|
1032
|
+
_value.Runs = Runs;
|
|
1033
|
+
return (_value);
|
|
1034
|
+
}
|
|
1035
|
+
|
|
1036
|
+
~ThreadData() = default;
|
|
1037
|
+
|
|
1038
|
+
public:
|
|
1039
|
+
bool IsDataValid() const
|
|
1040
|
+
{
|
|
1041
|
+
return ((Id.IsSet() == true) && (Job.IsSet() == true) && (Runs.IsSet() == true));
|
|
1042
|
+
}
|
|
1043
|
+
|
|
1044
|
+
private:
|
|
1045
|
+
void _Init()
|
|
1046
|
+
{
|
|
1047
|
+
Add(_T("id"), &Id);
|
|
1048
|
+
Add(_T("job"), &Job);
|
|
1049
|
+
Add(_T("runs"), &Runs);
|
|
1050
|
+
}
|
|
1051
|
+
|
|
1052
|
+
public:
|
|
1053
|
+
Core::JSON::InstanceId Id; // Thread ID
|
|
1054
|
+
Core::JSON::String Job; // Job name
|
|
1055
|
+
Core::JSON::DecUInt32 Runs; // Number of runs
|
|
1056
|
+
}; // class ThreadData
|
|
1057
|
+
|
|
1058
|
+
} // namespace Metadata
|
|
1059
|
+
|
|
1060
|
+
POP_WARNING()
|
|
1061
|
+
|
|
1062
|
+
} // namespace JsonData
|
|
1063
|
+
|
|
1064
|
+
// Enum conversion handlers
|
|
1065
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::state)
|
|
1066
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::reason)
|
|
1067
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::ILifeTime::state)
|
|
1068
|
+
ENUM_CONVERSION_HANDLER(PluginHost::ISubSystem::subsystem)
|
|
1069
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::IMetadata::Data::Service::state)
|
|
1070
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::startmode)
|
|
1071
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::IMetadata::Data::Link::state)
|
|
1072
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::IMetadata::Data::BuildInfo::systemtype)
|
|
1073
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::IMetadata::Data::BuildInfo::buildtype)
|
|
1074
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype)
|
|
1075
|
+
|
|
1076
|
+
}
|
|
1077
|
+
|
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
// C++ types for StateController API.
|
|
2
|
+
// Generated automatically from 'IStateController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace StateController {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class RequestParamsData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
RequestParamsData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("state"), &State);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
RequestParamsData(const RequestParamsData&) = delete;
|
|
30
|
+
RequestParamsData(RequestParamsData&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
RequestParamsData& operator=(const RequestParamsData&) = delete;
|
|
33
|
+
RequestParamsData& operator=(RequestParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~RequestParamsData() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (State.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::EnumType<PluginHost::IStateController::command> State; // State to which it is requested to change
|
|
45
|
+
}; // class RequestParamsData
|
|
46
|
+
|
|
47
|
+
class StateChangedParamsData : public Core::JSON::Container {
|
|
48
|
+
public:
|
|
49
|
+
StateChangedParamsData()
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
Add(_T("state"), &State);
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
StateChangedParamsData(const StateChangedParamsData&) = delete;
|
|
56
|
+
StateChangedParamsData(StateChangedParamsData&&) noexcept = delete;
|
|
57
|
+
|
|
58
|
+
StateChangedParamsData& operator=(const StateChangedParamsData&) = delete;
|
|
59
|
+
StateChangedParamsData& operator=(StateChangedParamsData&&) noexcept = delete;
|
|
60
|
+
|
|
61
|
+
~StateChangedParamsData() = default;
|
|
62
|
+
|
|
63
|
+
public:
|
|
64
|
+
bool IsDataValid() const
|
|
65
|
+
{
|
|
66
|
+
return (State.IsSet() == true);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
public:
|
|
70
|
+
Core::JSON::EnumType<PluginHost::IStateController::state> State; // Current state of the service
|
|
71
|
+
}; // class StateChangedParamsData
|
|
72
|
+
|
|
73
|
+
} // namespace StateController
|
|
74
|
+
|
|
75
|
+
POP_WARNING()
|
|
76
|
+
|
|
77
|
+
} // namespace JsonData
|
|
78
|
+
|
|
79
|
+
// Enum conversion handlers
|
|
80
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IStateController::command)
|
|
81
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IStateController::state)
|
|
82
|
+
|
|
83
|
+
}
|
|
84
|
+
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
// C++ types for Subsystems API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Subsystems {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class SubsystemInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
SubsystemInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
_Init();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
SubsystemInfo(const SubsystemInfo& _other)
|
|
30
|
+
: Core::JSON::Container()
|
|
31
|
+
, Subsystem(_other.Subsystem)
|
|
32
|
+
, Active(_other.Active)
|
|
33
|
+
{
|
|
34
|
+
_Init();
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
SubsystemInfo(SubsystemInfo&& _other) noexcept
|
|
38
|
+
: Core::JSON::Container()
|
|
39
|
+
, Subsystem(std::move(_other.Subsystem))
|
|
40
|
+
, Active(std::move(_other.Active))
|
|
41
|
+
{
|
|
42
|
+
_Init();
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
SubsystemInfo(const Exchange::Controller::ISubsystems::Subsystem& _other)
|
|
46
|
+
: Core::JSON::Container()
|
|
47
|
+
{
|
|
48
|
+
Subsystem = _other.Subsystem;
|
|
49
|
+
Active = _other.Active;
|
|
50
|
+
_Init();
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
SubsystemInfo& operator=(const SubsystemInfo& _rhs)
|
|
54
|
+
{
|
|
55
|
+
Subsystem = _rhs.Subsystem;
|
|
56
|
+
Active = _rhs.Active;
|
|
57
|
+
return (*this);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
SubsystemInfo& operator=(SubsystemInfo&& _rhs) noexcept
|
|
61
|
+
{
|
|
62
|
+
Subsystem = std::move(_rhs.Subsystem);
|
|
63
|
+
Active = std::move(_rhs.Active);
|
|
64
|
+
return (*this);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
SubsystemInfo& operator=(const Exchange::Controller::ISubsystems::Subsystem& _rhs)
|
|
68
|
+
{
|
|
69
|
+
Subsystem = _rhs.Subsystem;
|
|
70
|
+
Active = _rhs.Active;
|
|
71
|
+
return (*this);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
operator Exchange::Controller::ISubsystems::Subsystem() const
|
|
75
|
+
{
|
|
76
|
+
Exchange::Controller::ISubsystems::Subsystem _value{};
|
|
77
|
+
_value.Subsystem = Subsystem;
|
|
78
|
+
_value.Active = Active;
|
|
79
|
+
return (_value);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
~SubsystemInfo() = default;
|
|
83
|
+
|
|
84
|
+
public:
|
|
85
|
+
bool IsDataValid() const
|
|
86
|
+
{
|
|
87
|
+
return ((Subsystem.IsSet() == true) && (Active.IsSet() == true));
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
private:
|
|
91
|
+
void _Init()
|
|
92
|
+
{
|
|
93
|
+
Add(_T("subsystem"), &Subsystem);
|
|
94
|
+
Add(_T("active"), &Active);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
public:
|
|
98
|
+
Core::JSON::EnumType<PluginHost::ISubSystem::subsystem> Subsystem; // Name of the subsystem
|
|
99
|
+
Core::JSON::Boolean Active; // Denotes if the subsystem is currently active
|
|
100
|
+
}; // class SubsystemInfo
|
|
101
|
+
|
|
102
|
+
// Method params/result classes
|
|
103
|
+
//
|
|
104
|
+
|
|
105
|
+
} // namespace Subsystems
|
|
106
|
+
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
|
|
109
|
+
} // namespace JsonData
|
|
110
|
+
|
|
111
|
+
// Enum conversion handlers
|
|
112
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::state)
|
|
113
|
+
ENUM_CONVERSION_HANDLER(PluginHost::IShell::reason)
|
|
114
|
+
ENUM_CONVERSION_HANDLER(Exchange::Controller::ILifeTime::state)
|
|
115
|
+
ENUM_CONVERSION_HANDLER(PluginHost::ISubSystem::subsystem)
|
|
116
|
+
|
|
117
|
+
}
|
|
118
|
+
|
|
@@ -0,0 +1,108 @@
|
|
|
1
|
+
// C++ types for System API.
|
|
2
|
+
// Generated automatically from 'IController.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace System {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class CloneParamsData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
CloneParamsData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("callsign"), &Callsign);
|
|
27
|
+
Add(_T("newcallsign"), &Newcallsign);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
CloneParamsData(const CloneParamsData&) = delete;
|
|
31
|
+
CloneParamsData(CloneParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
CloneParamsData& operator=(const CloneParamsData&) = delete;
|
|
34
|
+
CloneParamsData& operator=(CloneParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~CloneParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return ((Callsign.IsSet() == true) && (Newcallsign.IsSet() == true));
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Callsign; // Callsign of the plugin
|
|
46
|
+
Core::JSON::String Newcallsign; // Callsign for the cloned plugin
|
|
47
|
+
}; // class CloneParamsData
|
|
48
|
+
|
|
49
|
+
class DeleteParamsData : public Core::JSON::Container {
|
|
50
|
+
public:
|
|
51
|
+
DeleteParamsData()
|
|
52
|
+
: Core::JSON::Container()
|
|
53
|
+
{
|
|
54
|
+
Add(_T("path"), &Path);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
DeleteParamsData(const DeleteParamsData&) = delete;
|
|
58
|
+
DeleteParamsData(DeleteParamsData&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
DeleteParamsData& operator=(const DeleteParamsData&) = delete;
|
|
61
|
+
DeleteParamsData& operator=(DeleteParamsData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~DeleteParamsData() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return (Path.IsSet() == true);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::String Path; // Path to the directory within the persisent storage
|
|
73
|
+
}; // class DeleteParamsData
|
|
74
|
+
|
|
75
|
+
class DestroyParamsData : public Core::JSON::Container {
|
|
76
|
+
public:
|
|
77
|
+
DestroyParamsData()
|
|
78
|
+
: Core::JSON::Container()
|
|
79
|
+
{
|
|
80
|
+
Add(_T("callsign"), &Callsign);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
DestroyParamsData(const DestroyParamsData&) = delete;
|
|
84
|
+
DestroyParamsData(DestroyParamsData&&) noexcept = delete;
|
|
85
|
+
|
|
86
|
+
DestroyParamsData& operator=(const DestroyParamsData&) = delete;
|
|
87
|
+
DestroyParamsData& operator=(DestroyParamsData&&) noexcept = delete;
|
|
88
|
+
|
|
89
|
+
~DestroyParamsData() = default;
|
|
90
|
+
|
|
91
|
+
public:
|
|
92
|
+
bool IsDataValid() const
|
|
93
|
+
{
|
|
94
|
+
return (Callsign.IsSet() == true);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
public:
|
|
98
|
+
Core::JSON::String Callsign; // Callsign of the plugin
|
|
99
|
+
}; // class DestroyParamsData
|
|
100
|
+
|
|
101
|
+
} // namespace System
|
|
102
|
+
|
|
103
|
+
POP_WARNING()
|
|
104
|
+
|
|
105
|
+
} // namespace JsonData
|
|
106
|
+
|
|
107
|
+
}
|
|
108
|
+
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
// Enumeration code for LifeTime API.
|
|
2
|
+
// Generated automatically from 'IController.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_LifeTime.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(PluginHost::IShell::state)
|
|
12
|
+
{ PluginHost::IShell::state::UNAVAILABLE, _TXT("Unavailable") },
|
|
13
|
+
{ PluginHost::IShell::state::DEACTIVATED, _TXT("Deactivated") },
|
|
14
|
+
{ PluginHost::IShell::state::ACTIVATED, _TXT("Activated") },
|
|
15
|
+
{ PluginHost::IShell::state::DEACTIVATION, _TXT("Deactivation") },
|
|
16
|
+
{ PluginHost::IShell::state::ACTIVATION, _TXT("Activation") },
|
|
17
|
+
{ PluginHost::IShell::state::PRECONDITION, _TXT("Precondition") },
|
|
18
|
+
{ PluginHost::IShell::state::HIBERNATED, _TXT("Hibernated") },
|
|
19
|
+
{ PluginHost::IShell::state::DESTROYED, _TXT("Destroyed") },
|
|
20
|
+
ENUM_CONVERSION_END(PluginHost::IShell::state)
|
|
21
|
+
|
|
22
|
+
ENUM_CONVERSION_BEGIN(PluginHost::IShell::reason)
|
|
23
|
+
{ PluginHost::IShell::reason::REQUESTED, _TXT("Requested") },
|
|
24
|
+
{ PluginHost::IShell::reason::AUTOMATIC, _TXT("Automatic") },
|
|
25
|
+
{ PluginHost::IShell::reason::FAILURE, _TXT("Failure") },
|
|
26
|
+
{ PluginHost::IShell::reason::MEMORY_EXCEEDED, _TXT("MemoryExceeded") },
|
|
27
|
+
{ PluginHost::IShell::reason::STARTUP, _TXT("Startup") },
|
|
28
|
+
{ PluginHost::IShell::reason::SHUTDOWN, _TXT("Shutdown") },
|
|
29
|
+
{ PluginHost::IShell::reason::CONDITIONS, _TXT("Conditions") },
|
|
30
|
+
{ PluginHost::IShell::reason::WATCHDOG_EXPIRED, _TXT("WatchdogExpired") },
|
|
31
|
+
{ PluginHost::IShell::reason::INITIALIZATION_FAILED, _TXT("InitializationFailed") },
|
|
32
|
+
{ PluginHost::IShell::reason::INSTANTIATION_FAILED, _TXT("InstantiationFailed") },
|
|
33
|
+
ENUM_CONVERSION_END(PluginHost::IShell::reason)
|
|
34
|
+
|
|
35
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::ILifeTime::state)
|
|
36
|
+
{ Exchange::Controller::ILifeTime::state::UNKNOWN, _TXT("Unknown") },
|
|
37
|
+
{ Exchange::Controller::ILifeTime::state::SUSPENDED, _TXT("Suspended") },
|
|
38
|
+
{ Exchange::Controller::ILifeTime::state::RESUMED, _TXT("Resumed") },
|
|
39
|
+
ENUM_CONVERSION_END(Exchange::Controller::ILifeTime::state)
|
|
40
|
+
|
|
41
|
+
}
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
// Enumeration code for Metadata API.
|
|
2
|
+
// Generated automatically from 'IController.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Metadata.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::IMetadata::Data::Service::state)
|
|
12
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::UNAVAILABLE, _TXT("Unavailable") },
|
|
13
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::DEACTIVATED, _TXT("Deactivated") },
|
|
14
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::DEACTIVATION, _TXT("Deactivation") },
|
|
15
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::ACTIVATED, _TXT("Activated") },
|
|
16
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::ACTIVATION, _TXT("Activation") },
|
|
17
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::DESTROYED, _TXT("Destroyed") },
|
|
18
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::PRECONDITION, _TXT("Precondition") },
|
|
19
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::HIBERNATED, _TXT("Hibernated") },
|
|
20
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::SUSPENDED, _TXT("Suspended") },
|
|
21
|
+
{ Exchange::Controller::IMetadata::Data::Service::state::RESUMED, _TXT("Resumed") },
|
|
22
|
+
ENUM_CONVERSION_END(Exchange::Controller::IMetadata::Data::Service::state)
|
|
23
|
+
|
|
24
|
+
ENUM_CONVERSION_BEGIN(PluginHost::IShell::startmode)
|
|
25
|
+
{ PluginHost::IShell::startmode::UNAVAILABLE, _TXT("Unavailable") },
|
|
26
|
+
{ PluginHost::IShell::startmode::DEACTIVATED, _TXT("Deactivated") },
|
|
27
|
+
{ PluginHost::IShell::startmode::ACTIVATED, _TXT("Activated") },
|
|
28
|
+
ENUM_CONVERSION_END(PluginHost::IShell::startmode)
|
|
29
|
+
|
|
30
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::IMetadata::Data::Link::state)
|
|
31
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::CLOSED, _TXT("Closed") },
|
|
32
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::WEBSERVER, _TXT("WebServer") },
|
|
33
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::WEBSOCKET, _TXT("WebSocket") },
|
|
34
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::RAWSOCKET, _TXT("RawSocket") },
|
|
35
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::COMRPC, _TXT("COMRPC") },
|
|
36
|
+
{ Exchange::Controller::IMetadata::Data::Link::state::SUSPENDED, _TXT("Suspended") },
|
|
37
|
+
ENUM_CONVERSION_END(Exchange::Controller::IMetadata::Data::Link::state)
|
|
38
|
+
|
|
39
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::IMetadata::Data::BuildInfo::systemtype)
|
|
40
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::systemtype::SYSTEM_WINDOWS, _TXT("Windows") },
|
|
41
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::systemtype::SYSTEM_LINUX, _TXT("Linux") },
|
|
42
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::systemtype::SYSTEM_MACOS, _TXT("MacOS") },
|
|
43
|
+
ENUM_CONVERSION_END(Exchange::Controller::IMetadata::Data::BuildInfo::systemtype)
|
|
44
|
+
|
|
45
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::IMetadata::Data::BuildInfo::buildtype)
|
|
46
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::buildtype::DEBUG, _TXT("Debug") },
|
|
47
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::buildtype::DEBUG_OPTIMIZED, _TXT("DebugOptimized") },
|
|
48
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::buildtype::RELEASE_WITH_DEBUG_INFO, _TXT("ReleaseWithDebugInfo") },
|
|
49
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::buildtype::RELEASE, _TXT("Release") },
|
|
50
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::buildtype::PRODUCTION, _TXT("Production") },
|
|
51
|
+
ENUM_CONVERSION_END(Exchange::Controller::IMetadata::Data::BuildInfo::buildtype)
|
|
52
|
+
|
|
53
|
+
ENUM_CONVERSION_BEGIN(Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype)
|
|
54
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype::WARNING_REPORTING, _TXT("WarningReporting") },
|
|
55
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype::BLUETOOTH, _TXT("Bluetooth") },
|
|
56
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype::HIBERNATE, _TXT("Hibernate") },
|
|
57
|
+
{ Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype::PROCESS_CONTAINERS, _TXT("ProcessContainers") },
|
|
58
|
+
ENUM_CONVERSION_END(Exchange::Controller::IMetadata::Data::BuildInfo::extensiontype)
|
|
59
|
+
|
|
60
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
// Enumeration code for StateController API.
|
|
2
|
+
// Generated automatically from 'IStateController.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_StateController.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(PluginHost::IStateController::command)
|
|
12
|
+
{ PluginHost::IStateController::command::SUSPEND, _TXT("Suspend") },
|
|
13
|
+
{ PluginHost::IStateController::command::RESUME, _TXT("Resume") },
|
|
14
|
+
ENUM_CONVERSION_END(PluginHost::IStateController::command)
|
|
15
|
+
|
|
16
|
+
ENUM_CONVERSION_BEGIN(PluginHost::IStateController::state)
|
|
17
|
+
{ PluginHost::IStateController::state::UNKNOWN, _TXT("Unknown") },
|
|
18
|
+
{ PluginHost::IStateController::state::SUSPENDED, _TXT("Suspended") },
|
|
19
|
+
{ PluginHost::IStateController::state::RESUMED, _TXT("Resumed") },
|
|
20
|
+
ENUM_CONVERSION_END(PluginHost::IStateController::state)
|
|
21
|
+
|
|
22
|
+
}
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
// Enumeration code for Subsystems API.
|
|
2
|
+
// Generated automatically from 'IController.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Subsystems.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(PluginHost::ISubSystem::subsystem)
|
|
12
|
+
{ PluginHost::ISubSystem::subsystem::PLATFORM, _TXT("Platform") },
|
|
13
|
+
{ PluginHost::ISubSystem::subsystem::SECURITY, _TXT("Security") },
|
|
14
|
+
{ PluginHost::ISubSystem::subsystem::NETWORK, _TXT("Network") },
|
|
15
|
+
{ PluginHost::ISubSystem::subsystem::IDENTIFIER, _TXT("Identifier") },
|
|
16
|
+
{ PluginHost::ISubSystem::subsystem::GRAPHICS, _TXT("Graphics") },
|
|
17
|
+
{ PluginHost::ISubSystem::subsystem::INTERNET, _TXT("Internet") },
|
|
18
|
+
{ PluginHost::ISubSystem::subsystem::LOCATION, _TXT("Location") },
|
|
19
|
+
{ PluginHost::ISubSystem::subsystem::TIME, _TXT("Time") },
|
|
20
|
+
{ PluginHost::ISubSystem::subsystem::PROVISIONING, _TXT("Provisioning") },
|
|
21
|
+
{ PluginHost::ISubSystem::subsystem::DECRYPTION, _TXT("Decryption") },
|
|
22
|
+
{ PluginHost::ISubSystem::subsystem::WEBSOURCE, _TXT("WebSource") },
|
|
23
|
+
{ PluginHost::ISubSystem::subsystem::STREAMING, _TXT("Streaming") },
|
|
24
|
+
{ PluginHost::ISubSystem::subsystem::BLUETOOTH, _TXT("Bluetooth") },
|
|
25
|
+
{ PluginHost::ISubSystem::subsystem::CRYPTOGRAPHY, _TXT("Cryptography") },
|
|
26
|
+
{ PluginHost::ISubSystem::subsystem::INSTALLATION, _TXT("Installation") },
|
|
27
|
+
{ PluginHost::ISubSystem::subsystem::END_LIST, _TXT("EndList") },
|
|
28
|
+
{ PluginHost::ISubSystem::subsystem::NEGATIVE_START, _TXT("NegativeStart") },
|
|
29
|
+
{ PluginHost::ISubSystem::subsystem::NOT_PLATFORM, _TXT("!Platform") },
|
|
30
|
+
{ PluginHost::ISubSystem::subsystem::NOT_SECURITY, _TXT("!Security") },
|
|
31
|
+
{ PluginHost::ISubSystem::subsystem::NOT_NETWORK, _TXT("!Network") },
|
|
32
|
+
{ PluginHost::ISubSystem::subsystem::NOT_IDENTIFIER, _TXT("!Identifier") },
|
|
33
|
+
{ PluginHost::ISubSystem::subsystem::NOT_GRAPHICS, _TXT("!Graphics") },
|
|
34
|
+
{ PluginHost::ISubSystem::subsystem::NOT_INTERNET, _TXT("!Internet") },
|
|
35
|
+
{ PluginHost::ISubSystem::subsystem::NOT_LOCATION, _TXT("!Location") },
|
|
36
|
+
{ PluginHost::ISubSystem::subsystem::NOT_TIME, _TXT("!Time") },
|
|
37
|
+
{ PluginHost::ISubSystem::subsystem::NOT_PROVISIONING, _TXT("!Provisioning") },
|
|
38
|
+
{ PluginHost::ISubSystem::subsystem::NOT_DECRYPTION, _TXT("!Decryption") },
|
|
39
|
+
{ PluginHost::ISubSystem::subsystem::NOT_WEBSOURCE, _TXT("!WebSource") },
|
|
40
|
+
{ PluginHost::ISubSystem::subsystem::NOT_STREAMING, _TXT("!Streaming") },
|
|
41
|
+
{ PluginHost::ISubSystem::subsystem::NOT_BLUETOOTH, _TXT("!Bluetooth") },
|
|
42
|
+
{ PluginHost::ISubSystem::subsystem::NOT_CRYPTOGRAPHY, _TXT("!Cryptography") },
|
|
43
|
+
{ PluginHost::ISubSystem::subsystem::NOT_INSTALLATION, _TXT("!Installation") },
|
|
44
|
+
ENUM_CONVERSION_END(PluginHost::ISubSystem::subsystem)
|
|
45
|
+
|
|
46
|
+
}
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
// IController API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_System.h"
|
|
7
|
+
#include "JsonData_Discovery.h"
|
|
8
|
+
#include "JsonData_Configuration.h"
|
|
9
|
+
#include "JsonData_LifeTime.h"
|
|
10
|
+
#include "JsonData_Subsystems.h"
|
|
11
|
+
#include "JsonData_Events.h"
|
|
12
|
+
#include "JsonData_Metadata.h"
|
|
13
|
+
#include "JSystem.h"
|
|
14
|
+
#include "JDiscovery.h"
|
|
15
|
+
#include "JConfiguration.h"
|
|
16
|
+
#include "JLifeTime.h"
|
|
17
|
+
#include "JSubsystems.h"
|
|
18
|
+
#include "JEvents.h"
|
|
19
|
+
#include "JMetadata.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IStateController API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_StateController.h"
|
|
7
|
+
#include "JStateController.h"
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
// Generated automatically from 'ICustomErrorCode.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_CustomErrorCode.h"
|
|
6
|
+
#include <example_interfaces/ICustomErrorCode.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Example {
|
|
11
|
+
|
|
12
|
+
namespace JCustomErrorCode {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ICustomErrorCode* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JCustomErrorCode"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'triggerCustomError'
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::CustomErrorCode::TriggerCustomErrorParamsData, void>(_T("triggerCustomError"),
|
|
37
|
+
[_implementation__](const JsonData::CustomErrorCode::TriggerCustomErrorParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCustomErrorCode"), _T("triggerCustomError")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const int32_t _errorcode_{params.Errorcode};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->TriggerCustomError(_errorcode_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Method: 'triggerNonCustomError'
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::CustomErrorCode::TriggerNonCustomErrorParamsData, void>(_T("triggerNonCustomError"),
|
|
56
|
+
[_implementation__](const JsonData::CustomErrorCode::TriggerNonCustomErrorParamsData& params) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
60
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCustomErrorCode"), _T("triggerNonCustomError")));
|
|
61
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
62
|
+
}
|
|
63
|
+
else {
|
|
64
|
+
const uint32_t _errorcode_{params.Errorcode};
|
|
65
|
+
|
|
66
|
+
_errorCode__ = _implementation__->TriggerNonCustomError(_errorcode_);
|
|
67
|
+
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
return (_errorCode__);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
template<typename MODULE>
|
|
76
|
+
static void Unregister(MODULE& _module__)
|
|
77
|
+
{
|
|
78
|
+
// Unregister methods and properties...
|
|
79
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("triggerCustomError"));
|
|
80
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("triggerNonCustomError"));
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
POP_WARNING()
|
|
84
|
+
POP_WARNING()
|
|
85
|
+
POP_WARNING()
|
|
86
|
+
|
|
87
|
+
} // namespace JCustomErrorCode
|
|
88
|
+
|
|
89
|
+
} // namespace Example
|
|
90
|
+
|
|
91
|
+
} // namespace Thunder
|
|
92
|
+
|
|
@@ -0,0 +1,809 @@
|
|
|
1
|
+
// Generated automatically from 'ISimpleAsync.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SimpleAsync.h"
|
|
6
|
+
#include <example_interfaces/ISimpleAsync.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Example {
|
|
11
|
+
|
|
12
|
+
namespace JSimpleAsync {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
namespace Async {
|
|
23
|
+
|
|
24
|
+
namespace Connect {
|
|
25
|
+
|
|
26
|
+
// Event: 'connect'
|
|
27
|
+
template<typename MODULE>
|
|
28
|
+
static void Complete(const MODULE& module_, const string& id_, const JsonData::SimpleAsync::CompleteParamsInfo& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
29
|
+
{
|
|
30
|
+
if (sendIfMethod_ == nullptr) {
|
|
31
|
+
module_.Notify(_T("connect"), params, [&id_](const string&, const string& index_) -> bool {
|
|
32
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
33
|
+
|
|
34
|
+
if (index_.empty() == true) {
|
|
35
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
36
|
+
}
|
|
37
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
|
|
38
|
+
});
|
|
39
|
+
}
|
|
40
|
+
else {
|
|
41
|
+
module_.Notify(_T("connect"), params, sendIfMethod_);
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
// Event: 'connect'
|
|
46
|
+
template<typename MODULE>
|
|
47
|
+
static void Complete(const MODULE& module_, const string& id_, const Core::JSON::String& address, const Core::JSON::EnumType<Example::ISimpleAsync::state>& state, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
48
|
+
{
|
|
49
|
+
JsonData::SimpleAsync::CompleteParamsInfo params_;
|
|
50
|
+
params_.Address = address;
|
|
51
|
+
params_.State = state;
|
|
52
|
+
|
|
53
|
+
Complete(module_, id_, params_, sendIfMethod_);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
// Event: 'connect'
|
|
57
|
+
template<typename MODULE>
|
|
58
|
+
static void Complete(const MODULE& module_, const string& id_, const Core::OptionalType<std::vector<uint8_t>>& address, const ISimpleAsync::state state, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
59
|
+
{
|
|
60
|
+
JsonData::SimpleAsync::CompleteParamsInfo params_;
|
|
61
|
+
|
|
62
|
+
if (address.IsSet() == true) {
|
|
63
|
+
string _addressEncoded__;
|
|
64
|
+
Core::ToHexString(address.Value(), _addressEncoded__, TCHAR(':'));
|
|
65
|
+
params_.Address = std::move(_addressEncoded__);
|
|
66
|
+
}
|
|
67
|
+
params_.State = state;
|
|
68
|
+
|
|
69
|
+
Complete(module_, id_, params_, sendIfMethod_);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
} // namespace Connect
|
|
73
|
+
|
|
74
|
+
} // namespace Async
|
|
75
|
+
|
|
76
|
+
class CallbackImplementation : public Example::ISimpleAsync::ICallback {
|
|
77
|
+
public:
|
|
78
|
+
CallbackImplementation() = delete;
|
|
79
|
+
CallbackImplementation(const CallbackImplementation&) = delete;
|
|
80
|
+
CallbackImplementation(CallbackImplementation&&) = delete;
|
|
81
|
+
CallbackImplementation& operator=(CallbackImplementation&&) = delete;
|
|
82
|
+
CallbackImplementation& operator=(const CallbackImplementation&) = delete;
|
|
83
|
+
|
|
84
|
+
CallbackImplementation(PluginHost::JSONRPC& module, const string& id)
|
|
85
|
+
: _module(module)
|
|
86
|
+
, _id(id)
|
|
87
|
+
{
|
|
88
|
+
}
|
|
89
|
+
~CallbackImplementation() override
|
|
90
|
+
{
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
void Complete(const Core::OptionalType<std::vector<uint8_t>>& address, const ISimpleAsync::state state) override
|
|
94
|
+
{
|
|
95
|
+
Async::Connect::Complete(_module, _id, address, state);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
BEGIN_INTERFACE_MAP(CallbackImplementation)
|
|
99
|
+
INTERFACE_ENTRY(Example::ISimpleAsync::ICallback)
|
|
100
|
+
END_INTERFACE_MAP
|
|
101
|
+
|
|
102
|
+
private:
|
|
103
|
+
PluginHost::JSONRPC& _module;
|
|
104
|
+
string _id;
|
|
105
|
+
};
|
|
106
|
+
|
|
107
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
108
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
109
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
110
|
+
|
|
111
|
+
template<typename MODULE>
|
|
112
|
+
static void Register(MODULE& _module__, ISimpleAsync* _implementation__)
|
|
113
|
+
{
|
|
114
|
+
ASSERT(_implementation__ != nullptr);
|
|
115
|
+
|
|
116
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSimpleAsync"), Version::Major, Version::Minor, Version::Patch);
|
|
117
|
+
|
|
118
|
+
// Register methods and properties...
|
|
119
|
+
|
|
120
|
+
// Method: 'connect' - Connects to a server
|
|
121
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::ConnectParamsData, void, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleAsync::ConnectParamsData&)>>(_T("connect"),
|
|
122
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleAsync::ConnectParamsData& params) -> uint32_t {
|
|
123
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
124
|
+
|
|
125
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
126
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("connect")));
|
|
127
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
128
|
+
}
|
|
129
|
+
else {
|
|
130
|
+
std::vector<uint8_t> _addressContainer_{};
|
|
131
|
+
Core::FromHexString(params.Address.Value(), _addressContainer_, 6, TCHAR(':'));
|
|
132
|
+
Core::OptionalType<std::vector<uint8_t>> _address_{};
|
|
133
|
+
_address_ = std::move(_addressContainer_);
|
|
134
|
+
const Core::OptionalType<uint16_t> _timeout_{params.Timeout};
|
|
135
|
+
const string _cb_asyncId_{params.Cb};
|
|
136
|
+
Example::ISimpleAsync::ICallback* _cb_ = Core::ServiceType<CallbackImplementation>::Create<Example::ISimpleAsync::ICallback>(_module__, _cb_asyncId_);
|
|
137
|
+
const uint32_t _subscribe_result__ = _module__.Subscribe(context_.ChannelId(), _T("connect"), _cb_asyncId_, _T(""), true /* one-off */);
|
|
138
|
+
ASSERT(_cb_ != nullptr);
|
|
139
|
+
|
|
140
|
+
if (_subscribe_result__ == Core::ERROR_NONE) {
|
|
141
|
+
_errorCode__ = _implementation__->Connect(_address_, _timeout_, _cb_);
|
|
142
|
+
|
|
143
|
+
if (_errorCode__ != Core::ERROR_NONE) {
|
|
144
|
+
_module__.Unsubscribe(context_.ChannelId(), _T("connect"), _cb_asyncId_, _T(""));
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
else {
|
|
148
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
if (_cb_ != nullptr) {
|
|
152
|
+
_cb_->Release();
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
return (_errorCode__);
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
// Method: 'abort' - Aborts connecting to a server
|
|
161
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("abort"),
|
|
162
|
+
[_implementation__]() -> uint32_t {
|
|
163
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
164
|
+
|
|
165
|
+
_errorCode__ = _implementation__->Abort();
|
|
166
|
+
|
|
167
|
+
return (_errorCode__);
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
// Method: 'disconnect' - Disconnects from the server
|
|
171
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("disconnect"),
|
|
172
|
+
[_implementation__]() -> uint32_t {
|
|
173
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
174
|
+
|
|
175
|
+
_errorCode__ = _implementation__->Disconnect();
|
|
176
|
+
|
|
177
|
+
return (_errorCode__);
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
// Method: 'link' - Links a device
|
|
181
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::LinkParamsInfo, void>(_T("link"),
|
|
182
|
+
[_implementation__](const JsonData::SimpleAsync::LinkParamsInfo& params) -> uint32_t {
|
|
183
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
184
|
+
|
|
185
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
186
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("link")));
|
|
187
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
188
|
+
}
|
|
189
|
+
else {
|
|
190
|
+
uint8_t _address_[6]{};
|
|
191
|
+
uint32_t _addressSize__(6);
|
|
192
|
+
Core::FromString(params.Address.Value(), _address_, _addressSize__);
|
|
193
|
+
|
|
194
|
+
_errorCode__ = _implementation__->Link(_address_);
|
|
195
|
+
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
return (_errorCode__);
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
// Method: 'unlink' - Unlinks a device
|
|
202
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::LinkParamsInfo, void>(_T("unlink"),
|
|
203
|
+
[_implementation__](const JsonData::SimpleAsync::LinkParamsInfo& params) -> uint32_t {
|
|
204
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
205
|
+
|
|
206
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
207
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("unlink")));
|
|
208
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
209
|
+
}
|
|
210
|
+
else {
|
|
211
|
+
uint8_t _address_[6]{};
|
|
212
|
+
uint32_t _addressSize__(6);
|
|
213
|
+
Core::FromString(params.Address.Value(), _address_, _addressSize__);
|
|
214
|
+
|
|
215
|
+
_errorCode__ = _implementation__->Unlink(_address_);
|
|
216
|
+
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
return (_errorCode__);
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
// Method: 'bind' - Binds a device
|
|
223
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::BindParamsInfo, void>(_T("bind"),
|
|
224
|
+
[_implementation__](const JsonData::SimpleAsync::BindParamsInfo& params) -> uint32_t {
|
|
225
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
226
|
+
|
|
227
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
228
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("bind")));
|
|
229
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
230
|
+
}
|
|
231
|
+
else {
|
|
232
|
+
const Core::MACAddress _address_{params.Address.Value().c_str()};
|
|
233
|
+
|
|
234
|
+
_errorCode__ = _implementation__->Bind(_address_);
|
|
235
|
+
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
return (_errorCode__);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
// Method: 'unbind' - Unlinks a device
|
|
242
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::BindParamsInfo, void>(_T("unbind"),
|
|
243
|
+
[_implementation__](const JsonData::SimpleAsync::BindParamsInfo& params) -> uint32_t {
|
|
244
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
245
|
+
|
|
246
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
247
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("unbind")));
|
|
248
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
249
|
+
}
|
|
250
|
+
else {
|
|
251
|
+
const Core::MACAddress _address_{params.Address.Value().c_str()};
|
|
252
|
+
|
|
253
|
+
_errorCode__ = _implementation__->Unbind(_address_);
|
|
254
|
+
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
return (_errorCode__);
|
|
258
|
+
});
|
|
259
|
+
|
|
260
|
+
// Method: 'tables'
|
|
261
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables"),
|
|
262
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
|
|
263
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
264
|
+
|
|
265
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
266
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables")));
|
|
267
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
268
|
+
}
|
|
269
|
+
else {
|
|
270
|
+
const bool _fill_{params.Fill};
|
|
271
|
+
std::vector<string> _stringTables_;
|
|
272
|
+
|
|
273
|
+
_errorCode__ = _implementation__->Tables(_fill_, _stringTables_);
|
|
274
|
+
|
|
275
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
276
|
+
stringTables.Set(true);
|
|
277
|
+
for (auto const& _elem__ : _stringTables_ ) { stringTables.Add() = _elem__; }
|
|
278
|
+
}
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
return (_errorCode__);
|
|
282
|
+
});
|
|
283
|
+
|
|
284
|
+
// Method: 'tables2'
|
|
285
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Tables2ResultData>(_T("tables2"),
|
|
286
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Tables2ResultData& result) -> uint32_t {
|
|
287
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
288
|
+
|
|
289
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
290
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables2")));
|
|
291
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
292
|
+
}
|
|
293
|
+
else {
|
|
294
|
+
const bool _fill_{params.Fill};
|
|
295
|
+
std::vector<string> _stringTables_;
|
|
296
|
+
std::vector<uint8_t> _intTables_;
|
|
297
|
+
|
|
298
|
+
_errorCode__ = _implementation__->Tables2(_fill_, _stringTables_, _intTables_);
|
|
299
|
+
|
|
300
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
301
|
+
result.StringTables.Set(true);
|
|
302
|
+
for (auto const& _elem__ : _stringTables_ ) { result.StringTables.Add() = _elem__; }
|
|
303
|
+
result.IntTables.Set(true);
|
|
304
|
+
for (auto const& _elem__ : _intTables_ ) { result.IntTables.Add() = _elem__; }
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
return (_errorCode__);
|
|
309
|
+
});
|
|
310
|
+
|
|
311
|
+
// Method: 'tables3'
|
|
312
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables3"),
|
|
313
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
|
|
314
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
315
|
+
|
|
316
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
317
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables3")));
|
|
318
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
319
|
+
}
|
|
320
|
+
else {
|
|
321
|
+
const bool _fill_{params.Fill};
|
|
322
|
+
Core::OptionalType<std::vector<string>> _stringTables_;
|
|
323
|
+
|
|
324
|
+
_errorCode__ = _implementation__->Tables3(_fill_, _stringTables_);
|
|
325
|
+
|
|
326
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
327
|
+
|
|
328
|
+
if (_stringTables_.IsSet() == true) {
|
|
329
|
+
for (auto const& _elem__ : _stringTables_.Value() ) { stringTables.Add() = _elem__; }
|
|
330
|
+
}
|
|
331
|
+
}
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
return (_errorCode__);
|
|
335
|
+
});
|
|
336
|
+
|
|
337
|
+
// Method: 'tables4'
|
|
338
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables4"),
|
|
339
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
|
|
340
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
341
|
+
|
|
342
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
343
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables4")));
|
|
344
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
345
|
+
}
|
|
346
|
+
else {
|
|
347
|
+
const bool _fill_{params.Fill};
|
|
348
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _stringTables_{};
|
|
349
|
+
|
|
350
|
+
_errorCode__ = _implementation__->Tables4(_fill_, _stringTables_);
|
|
351
|
+
|
|
352
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
353
|
+
stringTables.Set(true);
|
|
354
|
+
|
|
355
|
+
if (_stringTables_ != nullptr) {
|
|
356
|
+
string _resultItem__{};
|
|
357
|
+
while (_stringTables_->Next(_resultItem__) == true) { stringTables.Add() = _resultItem__; }
|
|
358
|
+
_stringTables_->Release();
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
return (_errorCode__);
|
|
364
|
+
});
|
|
365
|
+
|
|
366
|
+
// Method: 'tables5'
|
|
367
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Tables5ResultData>(_T("tables5"),
|
|
368
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Tables5ResultData& result) -> uint32_t {
|
|
369
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
370
|
+
|
|
371
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
372
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables5")));
|
|
373
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
374
|
+
}
|
|
375
|
+
else {
|
|
376
|
+
const bool _fill_{params.Fill};
|
|
377
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _stringTables_{};
|
|
378
|
+
RPC::IIteratorType<uint32_t, RPC::ID_VALUEITERATOR>* _intTables_{};
|
|
379
|
+
|
|
380
|
+
_errorCode__ = _implementation__->Tables5(_fill_, _stringTables_, _intTables_);
|
|
381
|
+
|
|
382
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
383
|
+
result.StringTables.Set(true);
|
|
384
|
+
|
|
385
|
+
if (_stringTables_ != nullptr) {
|
|
386
|
+
string _stringTablesItem__{};
|
|
387
|
+
while (_stringTables_->Next(_stringTablesItem__) == true) { result.StringTables.Add() = _stringTablesItem__; }
|
|
388
|
+
_stringTables_->Release();
|
|
389
|
+
}
|
|
390
|
+
result.IntTables.Set(true);
|
|
391
|
+
|
|
392
|
+
if (_intTables_ != nullptr) {
|
|
393
|
+
uint32_t _intTablesItem__{};
|
|
394
|
+
while (_intTables_->Next(_intTablesItem__) == true) { result.IntTables.Add() = _intTablesItem__; }
|
|
395
|
+
_intTables_->Release();
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
}
|
|
399
|
+
|
|
400
|
+
return (_errorCode__);
|
|
401
|
+
});
|
|
402
|
+
|
|
403
|
+
// Method: 'tables6'
|
|
404
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::RecordInfo>(_T("tables6"),
|
|
405
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::RecordInfo& pod) -> uint32_t {
|
|
406
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
407
|
+
|
|
408
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
409
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables6")));
|
|
410
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
411
|
+
}
|
|
412
|
+
else {
|
|
413
|
+
const bool _fill_{params.Fill};
|
|
414
|
+
Example::ISimpleAsync::Record _pod_{};
|
|
415
|
+
|
|
416
|
+
_errorCode__ = _implementation__->Tables6(_fill_, _pod_);
|
|
417
|
+
|
|
418
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
419
|
+
pod.Set(true);
|
|
420
|
+
pod = _pod_;
|
|
421
|
+
}
|
|
422
|
+
}
|
|
423
|
+
|
|
424
|
+
return (_errorCode__);
|
|
425
|
+
});
|
|
426
|
+
|
|
427
|
+
// Method: 'tables7'
|
|
428
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::RecordInfo>(_T("tables7"),
|
|
429
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::RecordInfo& pod) -> uint32_t {
|
|
430
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
431
|
+
|
|
432
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
433
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables7")));
|
|
434
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
435
|
+
}
|
|
436
|
+
else {
|
|
437
|
+
const bool _fill_{params.Fill};
|
|
438
|
+
Core::OptionalType<Example::ISimpleAsync::Record> _pod_{};
|
|
439
|
+
|
|
440
|
+
_errorCode__ = _implementation__->Tables7(_fill_, _pod_);
|
|
441
|
+
|
|
442
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
443
|
+
pod = _pod_;
|
|
444
|
+
}
|
|
445
|
+
}
|
|
446
|
+
|
|
447
|
+
return (_errorCode__);
|
|
448
|
+
});
|
|
449
|
+
|
|
450
|
+
// Method: 'tables8'
|
|
451
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Record2Info>(_T("tables8"),
|
|
452
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Record2Info& pod) -> uint32_t {
|
|
453
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
454
|
+
|
|
455
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
456
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables8")));
|
|
457
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
458
|
+
}
|
|
459
|
+
else {
|
|
460
|
+
const bool _fill_{params.Fill};
|
|
461
|
+
Core::OptionalType<Example::ISimpleAsync::Record2> _pod_{};
|
|
462
|
+
|
|
463
|
+
_errorCode__ = _implementation__->Tables8(_fill_, _pod_);
|
|
464
|
+
|
|
465
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
466
|
+
pod = _pod_;
|
|
467
|
+
}
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
return (_errorCode__);
|
|
471
|
+
});
|
|
472
|
+
|
|
473
|
+
// Method: 'tables9'
|
|
474
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Record2Info>(_T("tables9"),
|
|
475
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Record2Info& pod) -> uint32_t {
|
|
476
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
477
|
+
|
|
478
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
479
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables9")));
|
|
480
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
481
|
+
}
|
|
482
|
+
else {
|
|
483
|
+
const bool _fill_{params.Fill};
|
|
484
|
+
Example::ISimpleAsync::Record2 _pod_{};
|
|
485
|
+
|
|
486
|
+
_errorCode__ = _implementation__->Tables9(_fill_, _pod_);
|
|
487
|
+
|
|
488
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
489
|
+
pod = _pod_;
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
return (_errorCode__);
|
|
494
|
+
});
|
|
495
|
+
|
|
496
|
+
// Method: 'optionalResult'
|
|
497
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::String>(_T("optionalResult"),
|
|
498
|
+
[_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::String& result) -> uint32_t {
|
|
499
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
500
|
+
|
|
501
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
502
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("optionalResult")));
|
|
503
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
504
|
+
}
|
|
505
|
+
else {
|
|
506
|
+
const bool _fill_{params.Fill};
|
|
507
|
+
Core::OptionalType<string> _result_{};
|
|
508
|
+
|
|
509
|
+
_errorCode__ = _implementation__->OptionalResult(_fill_, _result_);
|
|
510
|
+
|
|
511
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
512
|
+
result = _result_;
|
|
513
|
+
}
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
return (_errorCode__);
|
|
517
|
+
});
|
|
518
|
+
|
|
519
|
+
// Indexed Property: 'connected' - Connection status (r/o)
|
|
520
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::Boolean, std::function<uint32_t(const string&, Core::JSON::Boolean&)>>(_T("connected"),
|
|
521
|
+
[_implementation__](const string& address, Core::JSON::Boolean& result) -> uint32_t {
|
|
522
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
523
|
+
|
|
524
|
+
std::vector<uint8_t> _addressConv__{};
|
|
525
|
+
|
|
526
|
+
if (address.empty() == true) {
|
|
527
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("connected")));
|
|
528
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
529
|
+
}
|
|
530
|
+
else {
|
|
531
|
+
const bool _addressConvResult__ = (Core::FromHexString(address, _addressConv__, 6, TCHAR(':')) != 0);
|
|
532
|
+
|
|
533
|
+
if ((_addressConvResult__ == false) || (_addressConv__.size() < 6) || (_addressConv__.size() > 6)) {
|
|
534
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("connected")));
|
|
535
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
536
|
+
}
|
|
537
|
+
}
|
|
538
|
+
|
|
539
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
540
|
+
bool _result_{};
|
|
541
|
+
|
|
542
|
+
_errorCode__ = _implementation__->Connected(_addressConv__, _result_);
|
|
543
|
+
|
|
544
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
545
|
+
result = _result_;
|
|
546
|
+
}
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
return (_errorCode__);
|
|
550
|
+
});
|
|
551
|
+
|
|
552
|
+
// Property: 'linkedDevice' - Linked device (r/o)
|
|
553
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("linkedDevice"),
|
|
554
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
555
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
556
|
+
|
|
557
|
+
uint8_t _result_[6]{};
|
|
558
|
+
|
|
559
|
+
_errorCode__ = _implementation__->LinkedDevice(_result_);
|
|
560
|
+
|
|
561
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
562
|
+
{
|
|
563
|
+
string _resultEncoded__;
|
|
564
|
+
Core::ToString(_result_, 6, true, _resultEncoded__);
|
|
565
|
+
result = std::move(_resultEncoded__);
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
|
|
569
|
+
return (_errorCode__);
|
|
570
|
+
});
|
|
571
|
+
|
|
572
|
+
// Indexed Property: 'metadata' - Device metadata
|
|
573
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::MetadataInfo, Core::JSON::String, std::function<uint32_t(const string&, const JsonData::SimpleAsync::MetadataInfo&, Core::JSON::String&)>>(_T("metadata"),
|
|
574
|
+
[_implementation__](const string& address, const JsonData::SimpleAsync::MetadataInfo& params, Core::JSON::String& result) -> uint32_t {
|
|
575
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
576
|
+
|
|
577
|
+
uint8_t _addressConv__[6];
|
|
578
|
+
|
|
579
|
+
if (address.empty() == true) {
|
|
580
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("metadata")));
|
|
581
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
582
|
+
}
|
|
583
|
+
else {
|
|
584
|
+
uint16_t _addressConvLength__(sizeof(_addressConv__));
|
|
585
|
+
Core::FromString(address, _addressConv__, _addressConvLength__);
|
|
586
|
+
const bool _addressConvResult__ = (_addressConvLength__ != 0);
|
|
587
|
+
|
|
588
|
+
if (_addressConvResult__ == false) {
|
|
589
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("metadata")));
|
|
590
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
|
|
594
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
595
|
+
|
|
596
|
+
if (params.IsSet() == false) {
|
|
597
|
+
string _result_{};
|
|
598
|
+
|
|
599
|
+
_errorCode__ = (static_cast<const ISimpleAsync*>(_implementation__))->Metadata(_addressConv__, _result_);
|
|
600
|
+
|
|
601
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
602
|
+
result = _result_;
|
|
603
|
+
}
|
|
604
|
+
}
|
|
605
|
+
else {
|
|
606
|
+
|
|
607
|
+
if (params.IsDataValid() == false) {
|
|
608
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("metadata")));
|
|
609
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
610
|
+
}
|
|
611
|
+
else {
|
|
612
|
+
const string _value_{params.Value};
|
|
613
|
+
|
|
614
|
+
_errorCode__ = _implementation__->Metadata(_addressConv__, _value_);
|
|
615
|
+
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
result.Null(true);
|
|
619
|
+
}
|
|
620
|
+
}
|
|
621
|
+
|
|
622
|
+
return (_errorCode__);
|
|
623
|
+
});
|
|
624
|
+
|
|
625
|
+
// Property: 'boundDevice' (r/o)
|
|
626
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("boundDevice"),
|
|
627
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
628
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
629
|
+
|
|
630
|
+
Core::MACAddress _result_{};
|
|
631
|
+
|
|
632
|
+
_errorCode__ = _implementation__->BoundDevice(_result_);
|
|
633
|
+
|
|
634
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
635
|
+
result = _result_.ToString();
|
|
636
|
+
}
|
|
637
|
+
|
|
638
|
+
return (_errorCode__);
|
|
639
|
+
});
|
|
640
|
+
|
|
641
|
+
// Indexed Property: 'type' - Device metadata
|
|
642
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::MetadataInfo, Core::JSON::String, std::function<uint32_t(const string&, const JsonData::SimpleAsync::MetadataInfo&, Core::JSON::String&)>>(_T("type"),
|
|
643
|
+
[_implementation__](const string& address, const JsonData::SimpleAsync::MetadataInfo& params, Core::JSON::String& result) -> uint32_t {
|
|
644
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
645
|
+
|
|
646
|
+
Core::MACAddress _addressConv__{address.c_str()};
|
|
647
|
+
|
|
648
|
+
if (address.empty() == true) {
|
|
649
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("type")));
|
|
650
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
651
|
+
}
|
|
652
|
+
else {
|
|
653
|
+
const bool _addressConvResult__ = _addressConv__.IsValid();
|
|
654
|
+
|
|
655
|
+
if (_addressConvResult__ == false) {
|
|
656
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("type")));
|
|
657
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
658
|
+
}
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
662
|
+
|
|
663
|
+
if (params.IsSet() == false) {
|
|
664
|
+
string _result_{};
|
|
665
|
+
|
|
666
|
+
_errorCode__ = (static_cast<const ISimpleAsync*>(_implementation__))->Type(_addressConv__, _result_);
|
|
667
|
+
|
|
668
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
669
|
+
result = _result_;
|
|
670
|
+
}
|
|
671
|
+
}
|
|
672
|
+
else {
|
|
673
|
+
|
|
674
|
+
if (params.IsDataValid() == false) {
|
|
675
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("type")));
|
|
676
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
677
|
+
}
|
|
678
|
+
else {
|
|
679
|
+
const string _value_{params.Value};
|
|
680
|
+
|
|
681
|
+
_errorCode__ = _implementation__->Type(_addressConv__, _value_);
|
|
682
|
+
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
result.Null(true);
|
|
686
|
+
}
|
|
687
|
+
}
|
|
688
|
+
|
|
689
|
+
return (_errorCode__);
|
|
690
|
+
});
|
|
691
|
+
|
|
692
|
+
}
|
|
693
|
+
|
|
694
|
+
template<typename MODULE>
|
|
695
|
+
static void Unregister(MODULE& _module__)
|
|
696
|
+
{
|
|
697
|
+
// Unregister methods and properties...
|
|
698
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("connect"));
|
|
699
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("abort"));
|
|
700
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("disconnect"));
|
|
701
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("link"));
|
|
702
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unlink"));
|
|
703
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("bind"));
|
|
704
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unbind"));
|
|
705
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables"));
|
|
706
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables2"));
|
|
707
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables3"));
|
|
708
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables4"));
|
|
709
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables5"));
|
|
710
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables6"));
|
|
711
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables7"));
|
|
712
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables8"));
|
|
713
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tables9"));
|
|
714
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("optionalResult"));
|
|
715
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("connected"));
|
|
716
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("linkedDevice"));
|
|
717
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("metadata"));
|
|
718
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("boundDevice"));
|
|
719
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("type"));
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
namespace Event {
|
|
723
|
+
|
|
724
|
+
// Event: 'statusChanged' - Signals completion of the Connect method
|
|
725
|
+
template<typename MODULE>
|
|
726
|
+
static void StatusChanged(const MODULE& module_, const JsonData::SimpleAsync::StatusChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
727
|
+
{
|
|
728
|
+
module_.Notify(_T("statusChanged"), params, sendIfMethod_);
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
// Event: 'statusChanged' - Signals completion of the Connect method
|
|
732
|
+
template<typename MODULE>
|
|
733
|
+
static void StatusChanged(const MODULE& module_, const Core::JSON::ArrayType<Core::JSON::DecUInt8>& address, const Core::JSON::Boolean& linked, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
734
|
+
{
|
|
735
|
+
JsonData::SimpleAsync::StatusChangedParamsData params_;
|
|
736
|
+
params_.Address = address;
|
|
737
|
+
params_.Linked = linked;
|
|
738
|
+
|
|
739
|
+
StatusChanged(module_, params_, sendIfMethod_);
|
|
740
|
+
}
|
|
741
|
+
|
|
742
|
+
// Event: 'statusChanged' - Signals completion of the Connect method
|
|
743
|
+
template<typename MODULE>
|
|
744
|
+
static void StatusChanged(const MODULE& module_, const uint8_t address[6], const bool linked, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
745
|
+
{
|
|
746
|
+
JsonData::SimpleAsync::StatusChangedParamsData params_;
|
|
747
|
+
ASSERT(address != nullptr);
|
|
748
|
+
for (uint16_t _i__ = 0; _i__ < 6; _i__++) { params_.Address.Add() = address[_i__]; }
|
|
749
|
+
params_.Linked = linked;
|
|
750
|
+
|
|
751
|
+
StatusChanged(module_, params_, sendIfMethod_);
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
// Event: 'bindingChanged' - Signals completion of the Connect method
|
|
755
|
+
template<typename MODULE>
|
|
756
|
+
static void BindingChanged(const MODULE& module_, const Core::MACAddress& id_, const JsonData::SimpleAsync::BindingChangedParamsData& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
757
|
+
{
|
|
758
|
+
if (sendIfMethod_ == nullptr) {
|
|
759
|
+
module_.Notify(_T("bindingChanged"), params, [&id_](const string&, const string& index_) -> bool {
|
|
760
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
761
|
+
Core::MACAddress _indexConv__{index_.c_str()};
|
|
762
|
+
|
|
763
|
+
if (index_.empty() == true) {
|
|
764
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
765
|
+
}
|
|
766
|
+
else {
|
|
767
|
+
const bool _indexConvResult__ = _indexConv__.IsValid();
|
|
768
|
+
}
|
|
769
|
+
|
|
770
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexConv__));
|
|
771
|
+
});
|
|
772
|
+
}
|
|
773
|
+
else {
|
|
774
|
+
module_.Notify(_T("bindingChanged"), params, sendIfMethod_);
|
|
775
|
+
}
|
|
776
|
+
}
|
|
777
|
+
|
|
778
|
+
// Event: 'bindingChanged' - Signals completion of the Connect method
|
|
779
|
+
template<typename MODULE>
|
|
780
|
+
static void BindingChanged(const MODULE& module_, const Core::MACAddress& id_, const Core::JSON::Boolean& bound, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
781
|
+
{
|
|
782
|
+
JsonData::SimpleAsync::BindingChangedParamsData params_;
|
|
783
|
+
params_.Bound = bound;
|
|
784
|
+
|
|
785
|
+
BindingChanged(module_, id_, params_, sendIfMethod_);
|
|
786
|
+
}
|
|
787
|
+
|
|
788
|
+
// Event: 'bindingChanged' - Signals completion of the Connect method
|
|
789
|
+
template<typename MODULE>
|
|
790
|
+
static void BindingChanged(const MODULE& module_, const Core::MACAddress& id_, const bool bound, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
791
|
+
{
|
|
792
|
+
JsonData::SimpleAsync::BindingChangedParamsData params_;
|
|
793
|
+
params_.Bound = bound;
|
|
794
|
+
|
|
795
|
+
BindingChanged(module_, id_, params_, sendIfMethod_);
|
|
796
|
+
}
|
|
797
|
+
|
|
798
|
+
} // namespace Event
|
|
799
|
+
|
|
800
|
+
POP_WARNING()
|
|
801
|
+
POP_WARNING()
|
|
802
|
+
POP_WARNING()
|
|
803
|
+
|
|
804
|
+
} // namespace JSimpleAsync
|
|
805
|
+
|
|
806
|
+
} // namespace Example
|
|
807
|
+
|
|
808
|
+
} // namespace Thunder
|
|
809
|
+
|
|
@@ -0,0 +1,379 @@
|
|
|
1
|
+
// Generated automatically from 'ISimpleCustomObjects.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SimpleCustomObjects.h"
|
|
6
|
+
#include <example_interfaces/ISimpleCustomObjects.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Example {
|
|
11
|
+
|
|
12
|
+
namespace JSimpleCustomObjects {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
struct IHandler {
|
|
23
|
+
virtual ~IHandler() = default;
|
|
24
|
+
virtual void OnAddedEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
25
|
+
virtual void OnNameChangedEventRegistration(ISimpleCustomObjects::IAccessory* object, const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
29
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
30
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
31
|
+
|
|
32
|
+
template<typename MODULE>
|
|
33
|
+
static void Register(MODULE& _module__, ISimpleCustomObjects* _implementation__, IHandler* _handler_)
|
|
34
|
+
{
|
|
35
|
+
ASSERT(_implementation__ != nullptr);
|
|
36
|
+
ASSERT(_handler_ != nullptr);
|
|
37
|
+
|
|
38
|
+
ASSERT(_module__.template Exists<ISimpleCustomObjects::IAccessory>() == true);
|
|
39
|
+
|
|
40
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSimpleCustomObjects"), Version::Major, Version::Minor, Version::Patch);
|
|
41
|
+
|
|
42
|
+
// Register methods and properties...
|
|
43
|
+
|
|
44
|
+
// Indexed Property: 'accessory' - Accessory by name (r/o)
|
|
45
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const string&, Core::JSON::String&)>>(_T("accessory"),
|
|
46
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const string& name, Core::JSON::String& result) -> uint32_t {
|
|
47
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
48
|
+
|
|
49
|
+
if (name.empty() == true) {
|
|
50
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory")));
|
|
51
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
55
|
+
string _result_{};
|
|
56
|
+
Example::ISimpleCustomObjects::IAccessory* _real_result_{};
|
|
57
|
+
|
|
58
|
+
_errorCode__ = _implementation__->Accessory(name, _real_result_);
|
|
59
|
+
|
|
60
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
61
|
+
_result_ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Example::ISimpleCustomObjects::IAccessory>(_real_result_, context_);
|
|
62
|
+
_real_result_->Release();
|
|
63
|
+
result = std::move(_result_);
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
return (_errorCode__);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
// Property: 'accessory::name' - Name of the accessory
|
|
71
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleCustomObjects::NameData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, const JsonData::SimpleCustomObjects::NameData&, Core::JSON::String&)>>(_T("accessory::name"),
|
|
72
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, const JsonData::SimpleCustomObjects::NameData& params, Core::JSON::String& result) -> uint32_t {
|
|
73
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
74
|
+
|
|
75
|
+
if (params.IsSet() == false) {
|
|
76
|
+
const ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
|
|
77
|
+
|
|
78
|
+
if (_implementation__ != nullptr) {
|
|
79
|
+
string _result_{};
|
|
80
|
+
|
|
81
|
+
_errorCode__ = (static_cast<const ISimpleCustomObjects::IAccessory*>(_implementation__))->Name(_result_);
|
|
82
|
+
_implementation__->Release();
|
|
83
|
+
|
|
84
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
85
|
+
result = _result_;
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
else {
|
|
89
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
else {
|
|
93
|
+
|
|
94
|
+
if (params.IsDataValid() == false) {
|
|
95
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::name")));
|
|
96
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
97
|
+
}
|
|
98
|
+
else {
|
|
99
|
+
ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
|
|
100
|
+
|
|
101
|
+
if (_implementation__ != nullptr) {
|
|
102
|
+
const string _value_{params.Value};
|
|
103
|
+
|
|
104
|
+
_errorCode__ = _implementation__->Name(_value_);
|
|
105
|
+
_implementation__->Release();
|
|
106
|
+
|
|
107
|
+
}
|
|
108
|
+
else {
|
|
109
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
result.Null(true);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
return (_errorCode__);
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
// Indexed Property: 'accessory::pin' - Pin state
|
|
120
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleCustomObjects::PinData, Core::JSON::Boolean, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, const string&, const JsonData::SimpleCustomObjects::PinData&, Core::JSON::Boolean&)>>(_T("accessory::pin"),
|
|
121
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, const string& pin, const JsonData::SimpleCustomObjects::PinData& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
122
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
123
|
+
|
|
124
|
+
uint8_t _pinConv__{};
|
|
125
|
+
|
|
126
|
+
if (pin.empty() == true) {
|
|
127
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::pin")));
|
|
128
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
129
|
+
}
|
|
130
|
+
else {
|
|
131
|
+
const bool _pinConvResult__ = Core::FromString(pin, _pinConv__);
|
|
132
|
+
|
|
133
|
+
if (_pinConvResult__ == false) {
|
|
134
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::pin")));
|
|
135
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
140
|
+
|
|
141
|
+
if (params.IsSet() == false) {
|
|
142
|
+
const ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
|
|
143
|
+
|
|
144
|
+
if (_implementation__ != nullptr) {
|
|
145
|
+
bool _result_{};
|
|
146
|
+
|
|
147
|
+
_errorCode__ = (static_cast<const ISimpleCustomObjects::IAccessory*>(_implementation__))->Pin(_pinConv__, _result_);
|
|
148
|
+
_implementation__->Release();
|
|
149
|
+
|
|
150
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
151
|
+
result = _result_;
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
else {
|
|
155
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
else {
|
|
159
|
+
|
|
160
|
+
if (params.IsDataValid() == false) {
|
|
161
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::pin")));
|
|
162
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
163
|
+
}
|
|
164
|
+
else {
|
|
165
|
+
ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
|
|
166
|
+
|
|
167
|
+
if (_implementation__ != nullptr) {
|
|
168
|
+
const bool _value_{params.Value};
|
|
169
|
+
|
|
170
|
+
_errorCode__ = _implementation__->Pin(_pinConv__, _value_);
|
|
171
|
+
_implementation__->Release();
|
|
172
|
+
|
|
173
|
+
}
|
|
174
|
+
else {
|
|
175
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
result.Null(true);
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
return (_errorCode__);
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
// Register event status listeners...
|
|
187
|
+
|
|
188
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("added"),
|
|
189
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
190
|
+
_handler_->OnAddedEventRegistration(client_, status_);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("accessory::nameChanged"),
|
|
194
|
+
[&_module__,_handler_](const uint32_t channelId_, const string& instanceId_, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
195
|
+
ISimpleCustomObjects::IAccessory* _object__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, Core::JSONRPC::Context(channelId_));
|
|
196
|
+
if (_object__ != nullptr) {
|
|
197
|
+
_handler_->OnNameChangedEventRegistration(_object__, client_, status_);
|
|
198
|
+
_object__->Release();
|
|
199
|
+
}
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
template<typename MODULE>
|
|
205
|
+
static void Unregister(MODULE& _module__)
|
|
206
|
+
{
|
|
207
|
+
// Unregister methods and properties...
|
|
208
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("accessory"));
|
|
209
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("accessory::name"));
|
|
210
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("accessory::pin"));
|
|
211
|
+
|
|
212
|
+
// Unregister event status listeners...
|
|
213
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("added"));
|
|
214
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("accessory::nameChanged"));
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
namespace Event {
|
|
218
|
+
|
|
219
|
+
// Event: 'added' - Signals addition of a accessory
|
|
220
|
+
template<typename MODULE>
|
|
221
|
+
static void Added(const MODULE& module_, const JsonData::SimpleCustomObjects::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
222
|
+
{
|
|
223
|
+
module_.Notify(_T("added"), params, sendIfMethod_);
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
// Event: 'added' - Signals addition of a accessory
|
|
227
|
+
template<typename MODULE>
|
|
228
|
+
static void Added(const MODULE& module_, const JsonData::SimpleCustomObjects::AddedParamsInfo& params, const string& client_)
|
|
229
|
+
{
|
|
230
|
+
module_.Notify(_T("added"), params, [&client_](const string& designator_) -> bool {
|
|
231
|
+
return ((client_ == designator_));
|
|
232
|
+
});
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
// Event: 'added' - Signals addition of a accessory
|
|
236
|
+
template<typename MODULE>
|
|
237
|
+
static void Added(const MODULE& module_, const Core::JSON::String& accessory, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
238
|
+
{
|
|
239
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
240
|
+
params_.Accessory = accessory;
|
|
241
|
+
|
|
242
|
+
Added(module_, params_, sendIfMethod_);
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
// Event: 'added' - Signals addition of a accessory
|
|
246
|
+
template<typename MODULE>
|
|
247
|
+
static void Added(const MODULE& module_, const Core::JSON::String& accessory, const string& client_)
|
|
248
|
+
{
|
|
249
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
250
|
+
params_.Accessory = accessory;
|
|
251
|
+
|
|
252
|
+
Added(module_, params_, client_);
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
// Event: 'added' - Signals addition of a accessory
|
|
256
|
+
template<typename MODULE>
|
|
257
|
+
static void Added(const MODULE& module_, ISimpleCustomObjects::IAccessory* const accessory, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
258
|
+
{
|
|
259
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
260
|
+
params_.Accessory = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Example::ISimpleCustomObjects::IAccessory>(accessory);
|
|
261
|
+
|
|
262
|
+
Added(module_, params_, sendIfMethod_);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
// Event: 'added' - Signals addition of a accessory
|
|
266
|
+
template<typename MODULE>
|
|
267
|
+
static void Added(const MODULE& module_, ISimpleCustomObjects::IAccessory* const accessory, const string& client_)
|
|
268
|
+
{
|
|
269
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
270
|
+
params_.Accessory = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Example::ISimpleCustomObjects::IAccessory>(accessory);
|
|
271
|
+
|
|
272
|
+
Added(module_, params_, client_);
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
// Event: 'removed' - Signals removal of a accessory
|
|
276
|
+
template<typename MODULE>
|
|
277
|
+
static void Removed(const MODULE& module_, const JsonData::SimpleCustomObjects::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
278
|
+
{
|
|
279
|
+
module_.Notify(_T("removed"), params, sendIfMethod_);
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
// Event: 'removed' - Signals removal of a accessory
|
|
283
|
+
template<typename MODULE>
|
|
284
|
+
static void Removed(const MODULE& module_, const Core::JSON::String& accessory, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
285
|
+
{
|
|
286
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
287
|
+
params_.Accessory = accessory;
|
|
288
|
+
|
|
289
|
+
Removed(module_, params_, sendIfMethod_);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// Event: 'removed' - Signals removal of a accessory
|
|
293
|
+
template<typename MODULE>
|
|
294
|
+
static void Removed(const MODULE& module_, ISimpleCustomObjects::IAccessory* const accessory, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
295
|
+
{
|
|
296
|
+
JsonData::SimpleCustomObjects::AddedParamsInfo params_;
|
|
297
|
+
params_.Accessory = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Example::ISimpleCustomObjects::IAccessory>(accessory);
|
|
298
|
+
|
|
299
|
+
Removed(module_, params_, sendIfMethod_);
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
303
|
+
template<typename MODULE>
|
|
304
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const JsonData::SimpleCustomObjects::NameChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
305
|
+
{
|
|
306
|
+
ASSERT(_obj != nullptr);
|
|
307
|
+
|
|
308
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleCustomObjects::IAccessory>(_obj);
|
|
309
|
+
if (_instanceId.empty() == false) {
|
|
310
|
+
module_.Notify(Core::Format(_T("accessory#%s::nameChanged"), _instanceId.c_str()), params, sendIfMethod_);
|
|
311
|
+
}
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
315
|
+
template<typename MODULE>
|
|
316
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const JsonData::SimpleCustomObjects::NameChangedParamsData& params, const string& client_)
|
|
317
|
+
{
|
|
318
|
+
ASSERT(_obj != nullptr);
|
|
319
|
+
|
|
320
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleCustomObjects::IAccessory>(_obj);
|
|
321
|
+
if (_instanceId.empty() == false) {
|
|
322
|
+
module_.Notify(Core::Format(_T("accessory#%s::nameChanged"), _instanceId.c_str()), params, [&client_](const string& designator_) -> bool {
|
|
323
|
+
return ((client_ == designator_));
|
|
324
|
+
});
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
329
|
+
template<typename MODULE>
|
|
330
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const Core::JSON::String& name, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
331
|
+
{
|
|
332
|
+
JsonData::SimpleCustomObjects::NameChangedParamsData params_;
|
|
333
|
+
params_.Name = name;
|
|
334
|
+
|
|
335
|
+
NameChanged(module_, _obj, params_, sendIfMethod_);
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
339
|
+
template<typename MODULE>
|
|
340
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const Core::JSON::String& name, const string& client_)
|
|
341
|
+
{
|
|
342
|
+
JsonData::SimpleCustomObjects::NameChangedParamsData params_;
|
|
343
|
+
params_.Name = name;
|
|
344
|
+
|
|
345
|
+
NameChanged(module_, _obj, params_, client_);
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
349
|
+
template<typename MODULE>
|
|
350
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const string& name, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
351
|
+
{
|
|
352
|
+
JsonData::SimpleCustomObjects::NameChangedParamsData params_;
|
|
353
|
+
params_.Name = name;
|
|
354
|
+
|
|
355
|
+
NameChanged(module_, _obj, params_, sendIfMethod_);
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
// Event: 'accessory#ID::nameChanged' - Signals addition of a accessory
|
|
359
|
+
template<typename MODULE>
|
|
360
|
+
static void NameChanged(const MODULE& module_, const ISimpleCustomObjects::IAccessory* const _obj, const string& name, const string& client_)
|
|
361
|
+
{
|
|
362
|
+
JsonData::SimpleCustomObjects::NameChangedParamsData params_;
|
|
363
|
+
params_.Name = name;
|
|
364
|
+
|
|
365
|
+
NameChanged(module_, _obj, params_, client_);
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
} // namespace Event
|
|
369
|
+
|
|
370
|
+
POP_WARNING()
|
|
371
|
+
POP_WARNING()
|
|
372
|
+
POP_WARNING()
|
|
373
|
+
|
|
374
|
+
} // namespace JSimpleCustomObjects
|
|
375
|
+
|
|
376
|
+
} // namespace Example
|
|
377
|
+
|
|
378
|
+
} // namespace Thunder
|
|
379
|
+
|
|
@@ -0,0 +1,632 @@
|
|
|
1
|
+
// Generated automatically from 'ISimpleInstanceObjects.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SimpleInstanceObjects.h"
|
|
6
|
+
#include <example_interfaces/ISimpleInstanceObjects.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Example {
|
|
11
|
+
|
|
12
|
+
namespace JSimpleInstanceObjects {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
struct IHandler {
|
|
23
|
+
virtual ~IHandler() = default;
|
|
24
|
+
virtual void OnStateChangedEventRegistration(ISimpleInstanceObjects::IDevice* object, const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
25
|
+
virtual void OnPinChangedEventRegistration(ISimpleInstanceObjects::IDevice* object, const string& client, const Core::OptionalType<uint8_t>& index, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
29
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
30
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
31
|
+
|
|
32
|
+
template<typename MODULE>
|
|
33
|
+
static void Register(MODULE& _module__, ISimpleInstanceObjects* _implementation__, IHandler* _handler_)
|
|
34
|
+
{
|
|
35
|
+
ASSERT(_implementation__ != nullptr);
|
|
36
|
+
ASSERT(_handler_ != nullptr);
|
|
37
|
+
|
|
38
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSimpleInstanceObjects"), Version::Major, Version::Minor, Version::Patch);
|
|
39
|
+
|
|
40
|
+
// Install lookup handlers
|
|
41
|
+
_module__.PluginHost::JSONRPCSupportsAutoObjectLookup::template InstallHandler<ISimpleInstanceObjects::IDevice>();
|
|
42
|
+
|
|
43
|
+
// Install subscription assessor
|
|
44
|
+
|
|
45
|
+
_module__.SetSubscribeAssessor([&_module__](const uint32_t channelId, const string& prefix, const string& instanceId, const string&, const string&) -> bool {
|
|
46
|
+
bool result = true;
|
|
47
|
+
|
|
48
|
+
if (instanceId.empty() == false) {
|
|
49
|
+
if (prefix == _T("device")) {
|
|
50
|
+
result = _module__.PluginHost::JSONRPCSupportsAutoObjectLookup::template Check<ISimpleInstanceObjects::IDevice>(instanceId, channelId);
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (result);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Register methods and properties...
|
|
58
|
+
|
|
59
|
+
// Method: 'acquire' - Acquires a device
|
|
60
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::AcquireParamsData, Core::JSON::DecUInt32, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleInstanceObjects::AcquireParamsData&, Core::JSON::DecUInt32&)>>(_T("acquire"),
|
|
61
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleInstanceObjects::AcquireParamsData& params, Core::JSON::DecUInt32& device) -> uint32_t {
|
|
62
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
63
|
+
|
|
64
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
65
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("acquire")));
|
|
66
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
67
|
+
}
|
|
68
|
+
else {
|
|
69
|
+
const string _name_{params.Name};
|
|
70
|
+
uint32_t _device_{};
|
|
71
|
+
Example::ISimpleInstanceObjects::IDevice* _real_device_{};
|
|
72
|
+
|
|
73
|
+
_errorCode__ = _implementation__->Acquire(_name_, _real_device_);
|
|
74
|
+
|
|
75
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
76
|
+
_device_ = _module__.PluginHost::JSONRPCSupportsAutoObjectLookup::template Store<Example::ISimpleInstanceObjects::IDevice>(_real_device_, context_);
|
|
77
|
+
_real_device_->Release();
|
|
78
|
+
device = std::move(_device_);
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
// Method: 'relinquish' - Relinquishes a device
|
|
86
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::RelinquishParamsData, void, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleInstanceObjects::RelinquishParamsData&)>>(_T("relinquish"),
|
|
87
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleInstanceObjects::RelinquishParamsData& params) -> uint32_t {
|
|
88
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
89
|
+
|
|
90
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
91
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("relinquish")));
|
|
92
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
93
|
+
}
|
|
94
|
+
else {
|
|
95
|
+
const uint32_t _device_{params.Device};
|
|
96
|
+
Example::ISimpleInstanceObjects::IDevice* _real_device_{};
|
|
97
|
+
_real_device_ = _module__.template Dispose<Example::ISimpleInstanceObjects::IDevice>(context_, _device_);
|
|
98
|
+
|
|
99
|
+
if (_real_device_ != nullptr) {
|
|
100
|
+
_errorCode__ = _implementation__->Relinquish(_real_device_);
|
|
101
|
+
}
|
|
102
|
+
else {
|
|
103
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
// Method: 'device::enable' - Enable the device
|
|
112
|
+
_module__.PluginHost::JSONRPC::template Register<void, void, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&)>>(_T("device::enable"),
|
|
113
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_) -> uint32_t {
|
|
114
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
115
|
+
|
|
116
|
+
ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
117
|
+
|
|
118
|
+
if (_implementation__ != nullptr) {
|
|
119
|
+
|
|
120
|
+
_errorCode__ = _implementation__->Enable();
|
|
121
|
+
_implementation__->Release();
|
|
122
|
+
|
|
123
|
+
}
|
|
124
|
+
else {
|
|
125
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
return (_errorCode__);
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
// Method: 'device::disable' - Disable the device
|
|
132
|
+
_module__.PluginHost::JSONRPC::template Register<void, void, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&)>>(_T("device::disable"),
|
|
133
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_) -> uint32_t {
|
|
134
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
135
|
+
|
|
136
|
+
ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
137
|
+
|
|
138
|
+
if (_implementation__ != nullptr) {
|
|
139
|
+
|
|
140
|
+
_errorCode__ = _implementation__->Disable();
|
|
141
|
+
_implementation__->Release();
|
|
142
|
+
|
|
143
|
+
}
|
|
144
|
+
else {
|
|
145
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
return (_errorCode__);
|
|
149
|
+
});
|
|
150
|
+
|
|
151
|
+
// Property: 'device::name' - Name of the device
|
|
152
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::NameData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, const JsonData::SimpleInstanceObjects::NameData&, Core::JSON::String&)>>(_T("device::name"),
|
|
153
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, const JsonData::SimpleInstanceObjects::NameData& params, Core::JSON::String& result) -> uint32_t {
|
|
154
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
155
|
+
|
|
156
|
+
if (params.IsSet() == false) {
|
|
157
|
+
const ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
158
|
+
|
|
159
|
+
if (_implementation__ != nullptr) {
|
|
160
|
+
string _result_{};
|
|
161
|
+
|
|
162
|
+
_errorCode__ = _implementation__->Name(_result_);
|
|
163
|
+
_implementation__->Release();
|
|
164
|
+
|
|
165
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
166
|
+
result = _result_;
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
else {
|
|
170
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
else {
|
|
174
|
+
|
|
175
|
+
if (params.IsDataValid() == false) {
|
|
176
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::name")));
|
|
177
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
178
|
+
}
|
|
179
|
+
else {
|
|
180
|
+
ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
181
|
+
|
|
182
|
+
if (_implementation__ != nullptr) {
|
|
183
|
+
const string _value_{params.Value};
|
|
184
|
+
|
|
185
|
+
_errorCode__ = _implementation__->Name(_value_);
|
|
186
|
+
_implementation__->Release();
|
|
187
|
+
|
|
188
|
+
}
|
|
189
|
+
else {
|
|
190
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
191
|
+
}
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
result.Null(true);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
return (_errorCode__);
|
|
198
|
+
});
|
|
199
|
+
|
|
200
|
+
// Indexed Property: 'device::pin' - A pin
|
|
201
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::PinData, Core::JSON::Boolean, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, const string&, const JsonData::SimpleInstanceObjects::PinData&, Core::JSON::Boolean&)>>(_T("device::pin"),
|
|
202
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, const string& pin, const JsonData::SimpleInstanceObjects::PinData& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
203
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
204
|
+
|
|
205
|
+
uint8_t _pinConv__{};
|
|
206
|
+
|
|
207
|
+
if (pin.empty() == true) {
|
|
208
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::pin")));
|
|
209
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
210
|
+
}
|
|
211
|
+
else {
|
|
212
|
+
const bool _pinConvResult__ = Core::FromString(pin, _pinConv__);
|
|
213
|
+
|
|
214
|
+
if (_pinConvResult__ == false) {
|
|
215
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::pin")));
|
|
216
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
221
|
+
|
|
222
|
+
if (params.IsSet() == false) {
|
|
223
|
+
const ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
224
|
+
|
|
225
|
+
if (_implementation__ != nullptr) {
|
|
226
|
+
bool _result_{};
|
|
227
|
+
|
|
228
|
+
_errorCode__ = _implementation__->Pin(_pinConv__, _result_);
|
|
229
|
+
_implementation__->Release();
|
|
230
|
+
|
|
231
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
232
|
+
result = _result_;
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
else {
|
|
236
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
else {
|
|
240
|
+
|
|
241
|
+
if (params.IsDataValid() == false) {
|
|
242
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::pin")));
|
|
243
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
244
|
+
}
|
|
245
|
+
else {
|
|
246
|
+
ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
|
|
247
|
+
|
|
248
|
+
if (_implementation__ != nullptr) {
|
|
249
|
+
const bool _value_{params.Value};
|
|
250
|
+
|
|
251
|
+
_errorCode__ = _implementation__->Pin(_pinConv__, _value_);
|
|
252
|
+
_implementation__->Release();
|
|
253
|
+
|
|
254
|
+
}
|
|
255
|
+
else {
|
|
256
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
257
|
+
}
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
result.Null(true);
|
|
261
|
+
}
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
return (_errorCode__);
|
|
265
|
+
});
|
|
266
|
+
|
|
267
|
+
// Register event status listeners...
|
|
268
|
+
|
|
269
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("device::stateChanged"),
|
|
270
|
+
[&_module__,_handler_](const uint32_t channelId_, const string& instanceId_, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
271
|
+
ISimpleInstanceObjects::IDevice* _object__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, Core::JSONRPC::Context(channelId_));
|
|
272
|
+
if (_object__ != nullptr) {
|
|
273
|
+
_handler_->OnStateChangedEventRegistration(_object__, client_, status_);
|
|
274
|
+
_object__->Release();
|
|
275
|
+
}
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("device::pinChanged"),
|
|
279
|
+
[&_module__,_handler_](const uint32_t channelId_, const string& instanceId_, const string& client_, const string& index_, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
280
|
+
ISimpleInstanceObjects::IDevice* _object__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, Core::JSONRPC::Context(channelId_));
|
|
281
|
+
if (_object__ != nullptr) {
|
|
282
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
283
|
+
Core::OptionalType<uint8_t> _indexOpt__{};
|
|
284
|
+
|
|
285
|
+
if (index_.empty() == true) {
|
|
286
|
+
// no error, optional
|
|
287
|
+
}
|
|
288
|
+
else {
|
|
289
|
+
uint8_t _indexConv__{};
|
|
290
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
291
|
+
|
|
292
|
+
if (_indexConvResult__ == false) {
|
|
293
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device#ID::pinChanged")));
|
|
294
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
295
|
+
}
|
|
296
|
+
else {
|
|
297
|
+
_indexOpt__ = _indexConv__;
|
|
298
|
+
}
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
302
|
+
_handler_->OnPinChangedEventRegistration(_object__, client_, _indexOpt__, status_);
|
|
303
|
+
}
|
|
304
|
+
_object__->Release();
|
|
305
|
+
}
|
|
306
|
+
});
|
|
307
|
+
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
template<typename MODULE>
|
|
311
|
+
static void Unregister(MODULE& _module__)
|
|
312
|
+
{
|
|
313
|
+
// Unregister methods and properties...
|
|
314
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("acquire"));
|
|
315
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("relinquish"));
|
|
316
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device::enable"));
|
|
317
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device::disable"));
|
|
318
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device::name"));
|
|
319
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device::pin"));
|
|
320
|
+
|
|
321
|
+
// Unregister event status listeners...
|
|
322
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("device::stateChanged"));
|
|
323
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("device::pinChanged"));
|
|
324
|
+
|
|
325
|
+
// Uninstall subscription assessor
|
|
326
|
+
_module__.SetSubscribeAssessor(nullptr);
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
namespace Event {
|
|
330
|
+
|
|
331
|
+
// Event: 'device#ID::nameChanged' - Signals device name changes
|
|
332
|
+
template<typename MODULE>
|
|
333
|
+
static void NameChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const JsonData::SimpleInstanceObjects::NameChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
334
|
+
{
|
|
335
|
+
ASSERT(_obj != nullptr);
|
|
336
|
+
|
|
337
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
338
|
+
if (_instanceId.empty() == false) {
|
|
339
|
+
module_.Notify(Core::Format(_T("device#%s::nameChanged"), _instanceId.c_str()), params, sendIfMethod_);
|
|
340
|
+
}
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
// Event: 'device#ID::nameChanged' - Signals device name changes
|
|
344
|
+
template<typename MODULE>
|
|
345
|
+
static void NameChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::JSON::String& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
346
|
+
{
|
|
347
|
+
JsonData::SimpleInstanceObjects::NameChangedParamsData params_;
|
|
348
|
+
params_.State = state;
|
|
349
|
+
|
|
350
|
+
NameChanged(module_, _obj, params_, sendIfMethod_);
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
// Event: 'device#ID::nameChanged' - Signals device name changes
|
|
354
|
+
template<typename MODULE>
|
|
355
|
+
static void NameChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const string& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
356
|
+
{
|
|
357
|
+
JsonData::SimpleInstanceObjects::NameChangedParamsData params_;
|
|
358
|
+
params_.State = state;
|
|
359
|
+
|
|
360
|
+
NameChanged(module_, _obj, params_, sendIfMethod_);
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
364
|
+
template<typename MODULE>
|
|
365
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const JsonData::SimpleInstanceObjects::StateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
366
|
+
{
|
|
367
|
+
ASSERT(_obj != nullptr);
|
|
368
|
+
|
|
369
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
370
|
+
if (_instanceId.empty() == false) {
|
|
371
|
+
module_.Notify(Core::Format(_T("device#%s::stateChanged"), _instanceId.c_str()), params, sendIfMethod_);
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
376
|
+
template<typename MODULE>
|
|
377
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const JsonData::SimpleInstanceObjects::StateChangedParamsData& params, const string& client_)
|
|
378
|
+
{
|
|
379
|
+
ASSERT(_obj != nullptr);
|
|
380
|
+
|
|
381
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
382
|
+
if (_instanceId.empty() == false) {
|
|
383
|
+
module_.Notify(Core::Format(_T("device#%s::stateChanged"), _instanceId.c_str()), params, [&client_](const string& designator_) -> bool {
|
|
384
|
+
return ((client_ == designator_));
|
|
385
|
+
});
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
390
|
+
template<typename MODULE>
|
|
391
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::JSON::EnumType<Example::ISimpleInstanceObjects::state>& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
392
|
+
{
|
|
393
|
+
JsonData::SimpleInstanceObjects::StateChangedParamsData params_;
|
|
394
|
+
params_.State = state;
|
|
395
|
+
|
|
396
|
+
StateChanged(module_, _obj, params_, sendIfMethod_);
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
400
|
+
template<typename MODULE>
|
|
401
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::JSON::EnumType<Example::ISimpleInstanceObjects::state>& state, const string& client_)
|
|
402
|
+
{
|
|
403
|
+
JsonData::SimpleInstanceObjects::StateChangedParamsData params_;
|
|
404
|
+
params_.State = state;
|
|
405
|
+
|
|
406
|
+
StateChanged(module_, _obj, params_, client_);
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
410
|
+
template<typename MODULE>
|
|
411
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const ISimpleInstanceObjects::state state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
412
|
+
{
|
|
413
|
+
JsonData::SimpleInstanceObjects::StateChangedParamsData params_;
|
|
414
|
+
params_.State = state;
|
|
415
|
+
|
|
416
|
+
StateChanged(module_, _obj, params_, sendIfMethod_);
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
// Event: 'device#ID::stateChanged' - Signals device state changes
|
|
420
|
+
template<typename MODULE>
|
|
421
|
+
static void StateChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const ISimpleInstanceObjects::state state, const string& client_)
|
|
422
|
+
{
|
|
423
|
+
JsonData::SimpleInstanceObjects::StateChangedParamsData params_;
|
|
424
|
+
params_.State = state;
|
|
425
|
+
|
|
426
|
+
StateChanged(module_, _obj, params_, client_);
|
|
427
|
+
}
|
|
428
|
+
|
|
429
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
430
|
+
template<typename MODULE>
|
|
431
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const JsonData::SimpleInstanceObjects::PinChangedParamsData& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
432
|
+
{
|
|
433
|
+
ASSERT(_obj != nullptr);
|
|
434
|
+
|
|
435
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
436
|
+
if (_instanceId.empty() == false) {
|
|
437
|
+
if (sendIfMethod_ == nullptr) {
|
|
438
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, [&id_](const string&, const string& index_) -> bool {
|
|
439
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
440
|
+
Core::OptionalType<uint8_t> _indexOpt__{};
|
|
441
|
+
|
|
442
|
+
if (index_.empty() == true) {
|
|
443
|
+
// no error, optional
|
|
444
|
+
}
|
|
445
|
+
else {
|
|
446
|
+
uint8_t _indexConv__{};
|
|
447
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
448
|
+
_indexOpt__ = _indexConv__;
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)));
|
|
452
|
+
});
|
|
453
|
+
}
|
|
454
|
+
else {
|
|
455
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, sendIfMethod_);
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
461
|
+
template<typename MODULE>
|
|
462
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const JsonData::SimpleInstanceObjects::PinChangedParamsData& params, const string& client_)
|
|
463
|
+
{
|
|
464
|
+
ASSERT(_obj != nullptr);
|
|
465
|
+
|
|
466
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
467
|
+
if (_instanceId.empty() == false) {
|
|
468
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
469
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
470
|
+
Core::OptionalType<uint8_t> _indexOpt__{};
|
|
471
|
+
|
|
472
|
+
if (index_.empty() == true) {
|
|
473
|
+
// no error, optional
|
|
474
|
+
}
|
|
475
|
+
else {
|
|
476
|
+
uint8_t _indexConv__{};
|
|
477
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
478
|
+
_indexOpt__ = _indexConv__;
|
|
479
|
+
}
|
|
480
|
+
|
|
481
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((_indexOpt__.IsSet() == false) || (id_ == _indexOpt__)) && (client_ == designator_));
|
|
482
|
+
});
|
|
483
|
+
}
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
487
|
+
template<typename MODULE>
|
|
488
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const JsonData::SimpleInstanceObjects::PinChangedParamsData& params, const bool, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
489
|
+
{
|
|
490
|
+
ASSERT(_obj != nullptr);
|
|
491
|
+
|
|
492
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
493
|
+
if (_instanceId.empty() == false) {
|
|
494
|
+
if (sendIfMethod_ == nullptr) {
|
|
495
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, [&id_](const string&, const string& index_) -> bool {
|
|
496
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
497
|
+
Core::OptionalType<uint8_t> _indexOpt__{};
|
|
498
|
+
|
|
499
|
+
if (index_.empty() == true) {
|
|
500
|
+
// no error, optional
|
|
501
|
+
}
|
|
502
|
+
else {
|
|
503
|
+
uint8_t _indexConv__{};
|
|
504
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
505
|
+
_indexOpt__ = _indexConv__;
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__));
|
|
509
|
+
});
|
|
510
|
+
}
|
|
511
|
+
else {
|
|
512
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, sendIfMethod_);
|
|
513
|
+
}
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
518
|
+
template<typename MODULE>
|
|
519
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const JsonData::SimpleInstanceObjects::PinChangedParamsData& params, const bool, const string& client_)
|
|
520
|
+
{
|
|
521
|
+
ASSERT(_obj != nullptr);
|
|
522
|
+
|
|
523
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<ISimpleInstanceObjects::IDevice>(_obj);
|
|
524
|
+
if (_instanceId.empty() == false) {
|
|
525
|
+
module_.Notify(Core::Format(_T("device#%s::pinChanged"), _instanceId.c_str()), params, [&id_, &client_](const string& designator_, const string& index_) -> bool {
|
|
526
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
527
|
+
Core::OptionalType<uint8_t> _indexOpt__{};
|
|
528
|
+
|
|
529
|
+
if (index_.empty() == true) {
|
|
530
|
+
// no error, optional
|
|
531
|
+
}
|
|
532
|
+
else {
|
|
533
|
+
uint8_t _indexConv__{};
|
|
534
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
535
|
+
_indexOpt__ = _indexConv__;
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexOpt__) && (client_ == designator_));
|
|
539
|
+
});
|
|
540
|
+
}
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
544
|
+
template<typename MODULE>
|
|
545
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const Core::JSON::DecUInt8& pin, const Core::JSON::Boolean& high, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
546
|
+
{
|
|
547
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
548
|
+
params_.Pin = pin;
|
|
549
|
+
params_.High = high;
|
|
550
|
+
|
|
551
|
+
PinChanged(module_, _obj, id_, params_, sendIfMethod_);
|
|
552
|
+
}
|
|
553
|
+
|
|
554
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
555
|
+
template<typename MODULE>
|
|
556
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const Core::JSON::DecUInt8& pin, const Core::JSON::Boolean& high, const string& client_)
|
|
557
|
+
{
|
|
558
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
559
|
+
params_.Pin = pin;
|
|
560
|
+
params_.High = high;
|
|
561
|
+
|
|
562
|
+
PinChanged(module_, _obj, id_, params_, client_);
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
566
|
+
template<typename MODULE>
|
|
567
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& pin, const bool high, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
568
|
+
{
|
|
569
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
570
|
+
|
|
571
|
+
if (pin.IsSet() == true) {
|
|
572
|
+
params_.Pin = pin.Value();
|
|
573
|
+
}
|
|
574
|
+
params_.High = high;
|
|
575
|
+
|
|
576
|
+
PinChanged(module_, _obj, pin.Value(), params_, sendIfMethod_);
|
|
577
|
+
}
|
|
578
|
+
|
|
579
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
580
|
+
template<typename MODULE>
|
|
581
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& pin, const bool high, const string& client_)
|
|
582
|
+
{
|
|
583
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
584
|
+
|
|
585
|
+
if (pin.IsSet() == true) {
|
|
586
|
+
params_.Pin = pin.Value();
|
|
587
|
+
}
|
|
588
|
+
params_.High = high;
|
|
589
|
+
|
|
590
|
+
PinChanged(module_, _obj, pin.Value(), params_, client_);
|
|
591
|
+
}
|
|
592
|
+
|
|
593
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
594
|
+
template<typename MODULE>
|
|
595
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const Core::OptionalType<uint8_t>& pin, const bool high, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
596
|
+
{
|
|
597
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
598
|
+
|
|
599
|
+
if (pin.IsSet() == true) {
|
|
600
|
+
params_.Pin = pin.Value();
|
|
601
|
+
}
|
|
602
|
+
params_.High = high;
|
|
603
|
+
|
|
604
|
+
PinChanged(module_, _obj, id_, params_, true, sendIfMethod_);
|
|
605
|
+
}
|
|
606
|
+
|
|
607
|
+
// Event: 'device#ID::pinChanged' - Signals pin state changes
|
|
608
|
+
template<typename MODULE>
|
|
609
|
+
static void PinChanged(const MODULE& module_, const ISimpleInstanceObjects::IDevice* const _obj, const Core::OptionalType<uint8_t>& id_, const Core::OptionalType<uint8_t>& pin, const bool high, const string& client_)
|
|
610
|
+
{
|
|
611
|
+
JsonData::SimpleInstanceObjects::PinChangedParamsData params_;
|
|
612
|
+
|
|
613
|
+
if (pin.IsSet() == true) {
|
|
614
|
+
params_.Pin = pin.Value();
|
|
615
|
+
}
|
|
616
|
+
params_.High = high;
|
|
617
|
+
|
|
618
|
+
PinChanged(module_, _obj, id_, params_, true, client_);
|
|
619
|
+
}
|
|
620
|
+
|
|
621
|
+
} // namespace Event
|
|
622
|
+
|
|
623
|
+
POP_WARNING()
|
|
624
|
+
POP_WARNING()
|
|
625
|
+
POP_WARNING()
|
|
626
|
+
|
|
627
|
+
} // namespace JSimpleInstanceObjects
|
|
628
|
+
|
|
629
|
+
} // namespace Example
|
|
630
|
+
|
|
631
|
+
} // namespace Thunder
|
|
632
|
+
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
// C++ types for CustomErrorCode API.
|
|
2
|
+
// Generated automatically from 'ICustomErrorCode.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <example_interfaces/ICustomErrorCode.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace CustomErrorCode {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class TriggerCustomErrorParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
TriggerCustomErrorParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("errorcode"), &Errorcode);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
TriggerCustomErrorParamsData(const TriggerCustomErrorParamsData&) = delete;
|
|
31
|
+
TriggerCustomErrorParamsData(TriggerCustomErrorParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
TriggerCustomErrorParamsData& operator=(const TriggerCustomErrorParamsData&) = delete;
|
|
34
|
+
TriggerCustomErrorParamsData& operator=(TriggerCustomErrorParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~TriggerCustomErrorParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Errorcode.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecSInt32 Errorcode;
|
|
46
|
+
}; // class TriggerCustomErrorParamsData
|
|
47
|
+
|
|
48
|
+
class TriggerNonCustomErrorParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
TriggerNonCustomErrorParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("errorcode"), &Errorcode);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
TriggerNonCustomErrorParamsData(const TriggerNonCustomErrorParamsData&) = delete;
|
|
57
|
+
TriggerNonCustomErrorParamsData(TriggerNonCustomErrorParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
TriggerNonCustomErrorParamsData& operator=(const TriggerNonCustomErrorParamsData&) = delete;
|
|
60
|
+
TriggerNonCustomErrorParamsData& operator=(TriggerNonCustomErrorParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~TriggerNonCustomErrorParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Errorcode.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::DecUInt32 Errorcode;
|
|
72
|
+
}; // class TriggerNonCustomErrorParamsData
|
|
73
|
+
|
|
74
|
+
} // namespace CustomErrorCode
|
|
75
|
+
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
|
|
78
|
+
} // namespace JsonData
|
|
79
|
+
|
|
80
|
+
}
|
|
81
|
+
|
|
@@ -0,0 +1,713 @@
|
|
|
1
|
+
// C++ types for SimpleAsync API.
|
|
2
|
+
// Generated automatically from 'ISimpleAsync.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <example_interfaces/ISimpleAsync.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SimpleAsync {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class BindParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
BindParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("address"), &Address);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
BindParamsInfo(const BindParamsInfo&) = delete;
|
|
31
|
+
BindParamsInfo(BindParamsInfo&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
BindParamsInfo& operator=(const BindParamsInfo&) = delete;
|
|
34
|
+
BindParamsInfo& operator=(BindParamsInfo&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~BindParamsInfo() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (((Address.IsSet() == true) && (Address.Value().size() >= 17 && Address.Value().size() <= 17)));
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Address; // Device address
|
|
46
|
+
}; // class BindParamsInfo
|
|
47
|
+
|
|
48
|
+
class CompleteParamsInfo : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
CompleteParamsInfo()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("address"), &Address);
|
|
54
|
+
Add(_T("state"), &State);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
CompleteParamsInfo(const CompleteParamsInfo&) = delete;
|
|
58
|
+
CompleteParamsInfo(CompleteParamsInfo&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
CompleteParamsInfo& operator=(const CompleteParamsInfo&) = delete;
|
|
61
|
+
CompleteParamsInfo& operator=(CompleteParamsInfo&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~CompleteParamsInfo() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return (((Address.IsSet() == false) || (Address.Value().size() >= 17 && Address.Value().size() <= 17)) && (State.IsSet() == true));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::String Address; // Device address
|
|
73
|
+
Core::JSON::EnumType<Example::ISimpleAsync::state> State; // Result of pairing operation
|
|
74
|
+
}; // class CompleteParamsInfo
|
|
75
|
+
|
|
76
|
+
class LinkParamsInfo : public Core::JSON::Container {
|
|
77
|
+
public:
|
|
78
|
+
LinkParamsInfo()
|
|
79
|
+
: Core::JSON::Container()
|
|
80
|
+
{
|
|
81
|
+
Add(_T("address"), &Address);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
LinkParamsInfo(const LinkParamsInfo&) = delete;
|
|
85
|
+
LinkParamsInfo(LinkParamsInfo&&) noexcept = delete;
|
|
86
|
+
|
|
87
|
+
LinkParamsInfo& operator=(const LinkParamsInfo&) = delete;
|
|
88
|
+
LinkParamsInfo& operator=(LinkParamsInfo&&) noexcept = delete;
|
|
89
|
+
|
|
90
|
+
~LinkParamsInfo() = default;
|
|
91
|
+
|
|
92
|
+
public:
|
|
93
|
+
bool IsDataValid() const
|
|
94
|
+
{
|
|
95
|
+
return (((Address.IsSet() == true) && (Address.Value().size() >= 8 && Address.Value().size() <= 8)));
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
Core::JSON::String Address; // Device address
|
|
100
|
+
}; // class LinkParamsInfo
|
|
101
|
+
|
|
102
|
+
class MetadataInfo : public Core::JSON::Container {
|
|
103
|
+
public:
|
|
104
|
+
MetadataInfo()
|
|
105
|
+
: Core::JSON::Container()
|
|
106
|
+
{
|
|
107
|
+
Add(_T("value"), &Value);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
MetadataInfo(const MetadataInfo&) = delete;
|
|
111
|
+
MetadataInfo(MetadataInfo&&) noexcept = delete;
|
|
112
|
+
|
|
113
|
+
MetadataInfo& operator=(const MetadataInfo&) = delete;
|
|
114
|
+
MetadataInfo& operator=(MetadataInfo&&) noexcept = delete;
|
|
115
|
+
|
|
116
|
+
~MetadataInfo() = default;
|
|
117
|
+
|
|
118
|
+
public:
|
|
119
|
+
bool IsDataValid() const
|
|
120
|
+
{
|
|
121
|
+
return (Value.IsSet() == true);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
public:
|
|
125
|
+
Core::JSON::String Value; // Device metadata
|
|
126
|
+
}; // class MetadataInfo
|
|
127
|
+
|
|
128
|
+
class Record2Info : public Core::JSON::Container {
|
|
129
|
+
public:
|
|
130
|
+
Record2Info()
|
|
131
|
+
: Core::JSON::Container()
|
|
132
|
+
{
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
Record2Info(const Record2Info& _other)
|
|
137
|
+
: Core::JSON::Container()
|
|
138
|
+
, Param3(_other.Param3)
|
|
139
|
+
, Param4(_other.Param4)
|
|
140
|
+
{
|
|
141
|
+
_Init();
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
Record2Info(Record2Info&& _other) noexcept
|
|
145
|
+
: Core::JSON::Container()
|
|
146
|
+
, Param3(std::move(_other.Param3))
|
|
147
|
+
, Param4(std::move(_other.Param4))
|
|
148
|
+
{
|
|
149
|
+
_Init();
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
Record2Info(const Example::ISimpleAsync::Record2& _other)
|
|
153
|
+
: Core::JSON::Container()
|
|
154
|
+
{
|
|
155
|
+
if (_other.param3.IsSet() == true) {
|
|
156
|
+
Param3.Clear();
|
|
157
|
+
Param3.Set(true);
|
|
158
|
+
for (auto const& _element : _other.param3.Value()) { Param3.Add() = _element; }
|
|
159
|
+
}
|
|
160
|
+
if (_other.param4.IsSet() == true) {
|
|
161
|
+
Param4.Clear();
|
|
162
|
+
Param4.Set(true);
|
|
163
|
+
for (auto const& _element : _other.param4.Value()) { Param4.Add() = _element; }
|
|
164
|
+
}
|
|
165
|
+
_Init();
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
Record2Info(const Core::OptionalType<Example::ISimpleAsync::Record2>& _other)
|
|
169
|
+
: Core::JSON::Container()
|
|
170
|
+
{
|
|
171
|
+
if (_other.IsSet() == true) {
|
|
172
|
+
if (_other.Value().param3.IsSet() == true) {
|
|
173
|
+
Param3.Clear();
|
|
174
|
+
for (auto const& _element : _other.Value().param3.Value()) { Param3.Add() = _element; }
|
|
175
|
+
}
|
|
176
|
+
if (_other.Value().param4.IsSet() == true) {
|
|
177
|
+
Param4.Clear();
|
|
178
|
+
for (auto const& _element : _other.Value().param4.Value()) { Param4.Add() = _element; }
|
|
179
|
+
}
|
|
180
|
+
}
|
|
181
|
+
_Init();
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
Record2Info& operator=(const Record2Info& _rhs)
|
|
185
|
+
{
|
|
186
|
+
if (_rhs.Param3.IsSet() == true) {
|
|
187
|
+
Param3 = _rhs.Param3;
|
|
188
|
+
}
|
|
189
|
+
if (_rhs.Param4.IsSet() == true) {
|
|
190
|
+
Param4 = _rhs.Param4;
|
|
191
|
+
}
|
|
192
|
+
return (*this);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
Record2Info& operator=(Record2Info&& _rhs) noexcept
|
|
196
|
+
{
|
|
197
|
+
Param3 = std::move(_rhs.Param3);
|
|
198
|
+
Param4 = std::move(_rhs.Param4);
|
|
199
|
+
return (*this);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
Record2Info& operator=(const Example::ISimpleAsync::Record2& _rhs)
|
|
203
|
+
{
|
|
204
|
+
if (_rhs.param3.IsSet() == true) {
|
|
205
|
+
Param3.Clear();
|
|
206
|
+
Param3.Set(true);
|
|
207
|
+
for (auto const& _element : _rhs.param3.Value()) { Param3.Add() = _element; }
|
|
208
|
+
}
|
|
209
|
+
if (_rhs.param4.IsSet() == true) {
|
|
210
|
+
Param4.Clear();
|
|
211
|
+
Param4.Set(true);
|
|
212
|
+
for (auto const& _element : _rhs.param4.Value()) { Param4.Add() = _element; }
|
|
213
|
+
}
|
|
214
|
+
return (*this);
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
Record2Info& operator=(const Core::OptionalType<Example::ISimpleAsync::Record2>& _rhs)
|
|
218
|
+
{
|
|
219
|
+
if (_rhs.IsSet() == true) {
|
|
220
|
+
if (_rhs.Value().param3.IsSet() == true) {
|
|
221
|
+
Param3.Clear();
|
|
222
|
+
for (auto const& _element : _rhs.Value().param3.Value()) { Param3.Add() = _element; }
|
|
223
|
+
}
|
|
224
|
+
if (_rhs.Value().param4.IsSet() == true) {
|
|
225
|
+
Param4.Clear();
|
|
226
|
+
for (auto const& _element : _rhs.Value().param4.Value()) { Param4.Add() = _element; }
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
return (*this);
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
operator Example::ISimpleAsync::Record2() const
|
|
233
|
+
{
|
|
234
|
+
Example::ISimpleAsync::Record2 _value{};
|
|
235
|
+
if (Param3.IsSet() == true) {
|
|
236
|
+
{
|
|
237
|
+
auto _it = Param3.Elements();
|
|
238
|
+
while (_it.Next() == true) { _value.param3.Value().push_back(_it.Current()); }
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
if (Param4.IsSet() == true) {
|
|
242
|
+
{
|
|
243
|
+
auto _it = Param4.Elements();
|
|
244
|
+
while (_it.Next() == true) { _value.param4.Value().push_back(_it.Current()); }
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
return (_value);
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
~Record2Info() = default;
|
|
251
|
+
|
|
252
|
+
public:
|
|
253
|
+
bool IsDataValid() const
|
|
254
|
+
{
|
|
255
|
+
return (((Param3.IsSet() == false) || (Param3.Length() <= 10)) && ((Param4.IsSet() == false) || (Param4.Length() <= 10)));
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
private:
|
|
259
|
+
void _Init()
|
|
260
|
+
{
|
|
261
|
+
Add(_T("param3"), &Param3);
|
|
262
|
+
Add(_T("param4"), &Param4);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
public:
|
|
266
|
+
Core::JSON::ArrayType<Core::JSON::String> Param3;
|
|
267
|
+
Core::JSON::ArrayType<Core::JSON::String> Param4;
|
|
268
|
+
}; // class Record2Info
|
|
269
|
+
|
|
270
|
+
class SmallRecordInfo : public Core::JSON::Container {
|
|
271
|
+
public:
|
|
272
|
+
SmallRecordInfo()
|
|
273
|
+
: Core::JSON::Container()
|
|
274
|
+
{
|
|
275
|
+
_Init();
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
SmallRecordInfo(const SmallRecordInfo& _other)
|
|
279
|
+
: Core::JSON::Container()
|
|
280
|
+
, Param0(_other.Param0)
|
|
281
|
+
, Param1(_other.Param1)
|
|
282
|
+
{
|
|
283
|
+
_Init();
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
SmallRecordInfo(SmallRecordInfo&& _other) noexcept
|
|
287
|
+
: Core::JSON::Container()
|
|
288
|
+
, Param0(std::move(_other.Param0))
|
|
289
|
+
, Param1(std::move(_other.Param1))
|
|
290
|
+
{
|
|
291
|
+
_Init();
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
SmallRecordInfo(const Example::ISimpleAsync::SmallRecord& _other)
|
|
295
|
+
: Core::JSON::Container()
|
|
296
|
+
{
|
|
297
|
+
Param0 = _other.param0;
|
|
298
|
+
Param1 = _other.param1;
|
|
299
|
+
_Init();
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
SmallRecordInfo& operator=(const SmallRecordInfo& _rhs)
|
|
303
|
+
{
|
|
304
|
+
Param0 = _rhs.Param0;
|
|
305
|
+
Param1 = _rhs.Param1;
|
|
306
|
+
return (*this);
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
SmallRecordInfo& operator=(SmallRecordInfo&& _rhs) noexcept
|
|
310
|
+
{
|
|
311
|
+
Param0 = std::move(_rhs.Param0);
|
|
312
|
+
Param1 = std::move(_rhs.Param1);
|
|
313
|
+
return (*this);
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
SmallRecordInfo& operator=(const Example::ISimpleAsync::SmallRecord& _rhs)
|
|
317
|
+
{
|
|
318
|
+
Param0 = _rhs.param0;
|
|
319
|
+
Param1 = _rhs.param1;
|
|
320
|
+
return (*this);
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
operator Example::ISimpleAsync::SmallRecord() const
|
|
324
|
+
{
|
|
325
|
+
Example::ISimpleAsync::SmallRecord _value{};
|
|
326
|
+
_value.param0 = Param0;
|
|
327
|
+
_value.param1 = Param1;
|
|
328
|
+
return (_value);
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
~SmallRecordInfo() = default;
|
|
332
|
+
|
|
333
|
+
public:
|
|
334
|
+
bool IsDataValid() const
|
|
335
|
+
{
|
|
336
|
+
return ((Param0.IsSet() == true) && (Param1.IsSet() == true));
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
private:
|
|
340
|
+
void _Init()
|
|
341
|
+
{
|
|
342
|
+
Add(_T("param0"), &Param0);
|
|
343
|
+
Add(_T("param1"), &Param1);
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
public:
|
|
347
|
+
Core::JSON::String Param0;
|
|
348
|
+
Core::JSON::Boolean Param1;
|
|
349
|
+
}; // class SmallRecordInfo
|
|
350
|
+
|
|
351
|
+
class RecordInfo : public Core::JSON::Container {
|
|
352
|
+
public:
|
|
353
|
+
RecordInfo()
|
|
354
|
+
: Core::JSON::Container()
|
|
355
|
+
{
|
|
356
|
+
_Init();
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
RecordInfo(const RecordInfo& _other)
|
|
360
|
+
: Core::JSON::Container()
|
|
361
|
+
, Param0(_other.Param0)
|
|
362
|
+
, Param1(_other.Param1)
|
|
363
|
+
, Param2(_other.Param2)
|
|
364
|
+
, Param3(_other.Param3)
|
|
365
|
+
, Param4(_other.Param4)
|
|
366
|
+
, Param5(_other.Param5)
|
|
367
|
+
, Param6(_other.Param6)
|
|
368
|
+
{
|
|
369
|
+
_Init();
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
RecordInfo(RecordInfo&& _other) noexcept
|
|
373
|
+
: Core::JSON::Container()
|
|
374
|
+
, Param0(std::move(_other.Param0))
|
|
375
|
+
, Param1(std::move(_other.Param1))
|
|
376
|
+
, Param2(std::move(_other.Param2))
|
|
377
|
+
, Param3(std::move(_other.Param3))
|
|
378
|
+
, Param4(std::move(_other.Param4))
|
|
379
|
+
, Param5(std::move(_other.Param5))
|
|
380
|
+
, Param6(std::move(_other.Param6))
|
|
381
|
+
{
|
|
382
|
+
_Init();
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
RecordInfo(const Example::ISimpleAsync::Record& _other)
|
|
386
|
+
: Core::JSON::Container()
|
|
387
|
+
{
|
|
388
|
+
Param0 = _other.param0;
|
|
389
|
+
Param1.Clear();
|
|
390
|
+
Param1.Set(true);
|
|
391
|
+
for (auto const& _element : _other.param1) { Param1.Add() = _element; }
|
|
392
|
+
Param2.Clear();
|
|
393
|
+
Param2.Set(true);
|
|
394
|
+
for (auto const& _element : _other.param2) { Param2.Add() = _element; }
|
|
395
|
+
if (_other.param3.IsSet() == true) {
|
|
396
|
+
Param3.Clear();
|
|
397
|
+
Param3.Set(true);
|
|
398
|
+
for (auto const& _element : _other.param3.Value()) { Param3.Add() = _element; }
|
|
399
|
+
}
|
|
400
|
+
if (_other.param4.IsSet() == true) {
|
|
401
|
+
Param4.Clear();
|
|
402
|
+
Param4.Set(true);
|
|
403
|
+
for (auto const& _element : _other.param4.Value()) { Param4.Add() = _element; }
|
|
404
|
+
}
|
|
405
|
+
Param5.Set(true);
|
|
406
|
+
Param5 = _other.param5;
|
|
407
|
+
if (_other.param6.IsSet() == true) {
|
|
408
|
+
Param6.Set(true);
|
|
409
|
+
Param6 = _other.param6.Value();
|
|
410
|
+
}
|
|
411
|
+
_Init();
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
RecordInfo& operator=(const RecordInfo& _rhs)
|
|
415
|
+
{
|
|
416
|
+
Param0 = _rhs.Param0;
|
|
417
|
+
Param1 = _rhs.Param1;
|
|
418
|
+
Param2 = _rhs.Param2;
|
|
419
|
+
if (_rhs.Param3.IsSet() == true) {
|
|
420
|
+
Param3 = _rhs.Param3;
|
|
421
|
+
}
|
|
422
|
+
if (_rhs.Param4.IsSet() == true) {
|
|
423
|
+
Param4 = _rhs.Param4;
|
|
424
|
+
}
|
|
425
|
+
Param5 = _rhs.Param5;
|
|
426
|
+
if (_rhs.Param6.IsSet() == true) {
|
|
427
|
+
Param6 = _rhs.Param6;
|
|
428
|
+
}
|
|
429
|
+
return (*this);
|
|
430
|
+
}
|
|
431
|
+
|
|
432
|
+
RecordInfo& operator=(RecordInfo&& _rhs) noexcept
|
|
433
|
+
{
|
|
434
|
+
Param0 = std::move(_rhs.Param0);
|
|
435
|
+
Param1 = std::move(_rhs.Param1);
|
|
436
|
+
Param2 = std::move(_rhs.Param2);
|
|
437
|
+
Param3 = std::move(_rhs.Param3);
|
|
438
|
+
Param4 = std::move(_rhs.Param4);
|
|
439
|
+
Param5 = std::move(_rhs.Param5);
|
|
440
|
+
Param6 = std::move(_rhs.Param6);
|
|
441
|
+
return (*this);
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
RecordInfo& operator=(const Example::ISimpleAsync::Record& _rhs)
|
|
445
|
+
{
|
|
446
|
+
Param0 = _rhs.param0;
|
|
447
|
+
Param1.Clear();
|
|
448
|
+
Param1.Set(true);
|
|
449
|
+
for (auto const& _element : _rhs.param1) { Param1.Add() = _element; }
|
|
450
|
+
Param2.Clear();
|
|
451
|
+
Param2.Set(true);
|
|
452
|
+
for (auto const& _element : _rhs.param2) { Param2.Add() = _element; }
|
|
453
|
+
if (_rhs.param3.IsSet() == true) {
|
|
454
|
+
Param3.Clear();
|
|
455
|
+
Param3.Set(true);
|
|
456
|
+
for (auto const& _element : _rhs.param3.Value()) { Param3.Add() = _element; }
|
|
457
|
+
}
|
|
458
|
+
if (_rhs.param4.IsSet() == true) {
|
|
459
|
+
Param4.Clear();
|
|
460
|
+
Param4.Set(true);
|
|
461
|
+
for (auto const& _element : _rhs.param4.Value()) { Param4.Add() = _element; }
|
|
462
|
+
}
|
|
463
|
+
Param5.Set(true);
|
|
464
|
+
Param5 = _rhs.param5;
|
|
465
|
+
if (_rhs.param6.IsSet() == true) {
|
|
466
|
+
Param6.Set(true);
|
|
467
|
+
Param6 = _rhs.param6.Value();
|
|
468
|
+
}
|
|
469
|
+
return (*this);
|
|
470
|
+
}
|
|
471
|
+
|
|
472
|
+
operator Example::ISimpleAsync::Record() const
|
|
473
|
+
{
|
|
474
|
+
Example::ISimpleAsync::Record _value{};
|
|
475
|
+
_value.param0 = Param0;
|
|
476
|
+
{
|
|
477
|
+
auto _it = Param1.Elements();
|
|
478
|
+
while (_it.Next() == true) { _value.param1.push_back(_it.Current()); }
|
|
479
|
+
}
|
|
480
|
+
{
|
|
481
|
+
auto _it = Param2.Elements();
|
|
482
|
+
while (_it.Next() == true) { _value.param2.push_back(_it.Current()); }
|
|
483
|
+
}
|
|
484
|
+
if (Param3.IsSet() == true) {
|
|
485
|
+
{
|
|
486
|
+
auto _it = Param3.Elements();
|
|
487
|
+
while (_it.Next() == true) { _value.param3.Value().push_back(_it.Current()); }
|
|
488
|
+
}
|
|
489
|
+
}
|
|
490
|
+
if (Param4.IsSet() == true) {
|
|
491
|
+
{
|
|
492
|
+
auto _it = Param4.Elements();
|
|
493
|
+
while (_it.Next() == true) { _value.param4.Value().push_back(_it.Current()); }
|
|
494
|
+
}
|
|
495
|
+
}
|
|
496
|
+
_value.param5 = Param5;
|
|
497
|
+
if (Param6.IsSet() == true) {
|
|
498
|
+
_value.param6 = Param6;
|
|
499
|
+
}
|
|
500
|
+
return (_value);
|
|
501
|
+
}
|
|
502
|
+
|
|
503
|
+
~RecordInfo() = default;
|
|
504
|
+
|
|
505
|
+
public:
|
|
506
|
+
bool IsDataValid() const
|
|
507
|
+
{
|
|
508
|
+
return ((Param0.IsSet() == true) && (((Param1.IsSet() == true) && (Param1.Length() <= 10))) && (((Param2.IsSet() == true) && (Param2.Length() <= 10))) && ((Param3.IsSet() == false) || (Param3.Length() <= 10)) && ((Param4.IsSet() == false) || (Param4.Length() <= 10)) && ((Param5.IsSet() == true) && (Param5.IsDataValid() == true)) && ((Param6.IsSet() == false) || (Param6.IsDataValid() == true)));
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
private:
|
|
512
|
+
void _Init()
|
|
513
|
+
{
|
|
514
|
+
Add(_T("param0"), &Param0);
|
|
515
|
+
Add(_T("param1"), &Param1);
|
|
516
|
+
Add(_T("param2"), &Param2);
|
|
517
|
+
Add(_T("param3"), &Param3);
|
|
518
|
+
Add(_T("param4"), &Param4);
|
|
519
|
+
Add(_T("param5"), &Param5);
|
|
520
|
+
Add(_T("param6"), &Param6);
|
|
521
|
+
}
|
|
522
|
+
|
|
523
|
+
public:
|
|
524
|
+
Core::JSON::String Param0;
|
|
525
|
+
Core::JSON::ArrayType<Core::JSON::String> Param1;
|
|
526
|
+
Core::JSON::ArrayType<Core::JSON::String> Param2;
|
|
527
|
+
Core::JSON::ArrayType<Core::JSON::String> Param3;
|
|
528
|
+
Core::JSON::ArrayType<Core::JSON::String> Param4;
|
|
529
|
+
SmallRecordInfo Param5;
|
|
530
|
+
SmallRecordInfo Param6;
|
|
531
|
+
}; // class RecordInfo
|
|
532
|
+
|
|
533
|
+
class TablesParamsInfo : public Core::JSON::Container {
|
|
534
|
+
public:
|
|
535
|
+
TablesParamsInfo()
|
|
536
|
+
: Core::JSON::Container()
|
|
537
|
+
{
|
|
538
|
+
Add(_T("fill"), &Fill);
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
TablesParamsInfo(const TablesParamsInfo&) = delete;
|
|
542
|
+
TablesParamsInfo(TablesParamsInfo&&) noexcept = delete;
|
|
543
|
+
|
|
544
|
+
TablesParamsInfo& operator=(const TablesParamsInfo&) = delete;
|
|
545
|
+
TablesParamsInfo& operator=(TablesParamsInfo&&) noexcept = delete;
|
|
546
|
+
|
|
547
|
+
~TablesParamsInfo() = default;
|
|
548
|
+
|
|
549
|
+
public:
|
|
550
|
+
bool IsDataValid() const
|
|
551
|
+
{
|
|
552
|
+
return (Fill.IsSet() == true);
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
public:
|
|
556
|
+
Core::JSON::Boolean Fill;
|
|
557
|
+
}; // class TablesParamsInfo
|
|
558
|
+
|
|
559
|
+
// Method params/result classes
|
|
560
|
+
//
|
|
561
|
+
|
|
562
|
+
class BindingChangedParamsData : public Core::JSON::Container {
|
|
563
|
+
public:
|
|
564
|
+
BindingChangedParamsData()
|
|
565
|
+
: Core::JSON::Container()
|
|
566
|
+
{
|
|
567
|
+
Add(_T("bound"), &Bound);
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
BindingChangedParamsData(const BindingChangedParamsData&) = delete;
|
|
571
|
+
BindingChangedParamsData(BindingChangedParamsData&&) noexcept = delete;
|
|
572
|
+
|
|
573
|
+
BindingChangedParamsData& operator=(const BindingChangedParamsData&) = delete;
|
|
574
|
+
BindingChangedParamsData& operator=(BindingChangedParamsData&&) noexcept = delete;
|
|
575
|
+
|
|
576
|
+
~BindingChangedParamsData() = default;
|
|
577
|
+
|
|
578
|
+
public:
|
|
579
|
+
bool IsDataValid() const
|
|
580
|
+
{
|
|
581
|
+
return (Bound.IsSet() == true);
|
|
582
|
+
}
|
|
583
|
+
|
|
584
|
+
public:
|
|
585
|
+
Core::JSON::Boolean Bound; // Signals completion of the Connect method
|
|
586
|
+
}; // class BindingChangedParamsData
|
|
587
|
+
|
|
588
|
+
class ConnectParamsData : public Core::JSON::Container {
|
|
589
|
+
public:
|
|
590
|
+
ConnectParamsData()
|
|
591
|
+
: Core::JSON::Container()
|
|
592
|
+
, Timeout(1000)
|
|
593
|
+
{
|
|
594
|
+
Add(_T("address"), &Address);
|
|
595
|
+
Add(_T("timeout"), &Timeout);
|
|
596
|
+
Add(_T("id"), &Cb);
|
|
597
|
+
}
|
|
598
|
+
|
|
599
|
+
ConnectParamsData(const ConnectParamsData&) = delete;
|
|
600
|
+
ConnectParamsData(ConnectParamsData&&) noexcept = delete;
|
|
601
|
+
|
|
602
|
+
ConnectParamsData& operator=(const ConnectParamsData&) = delete;
|
|
603
|
+
ConnectParamsData& operator=(ConnectParamsData&&) noexcept = delete;
|
|
604
|
+
|
|
605
|
+
~ConnectParamsData() = default;
|
|
606
|
+
|
|
607
|
+
public:
|
|
608
|
+
bool IsDataValid() const
|
|
609
|
+
{
|
|
610
|
+
return (((Address.IsSet() == false) || (Address.Value().size() >= 17 && Address.Value().size() <= 17)) && (Cb.IsSet() == true));
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
public:
|
|
614
|
+
Core::JSON::String Address; // Device address
|
|
615
|
+
Core::JSON::DecUInt16 Timeout; // Maximum time allowed for connecting in milliseconds
|
|
616
|
+
Core::JSON::String Cb; // Connects to a server
|
|
617
|
+
}; // class ConnectParamsData
|
|
618
|
+
|
|
619
|
+
class StatusChangedParamsData : public Core::JSON::Container {
|
|
620
|
+
public:
|
|
621
|
+
StatusChangedParamsData()
|
|
622
|
+
: Core::JSON::Container()
|
|
623
|
+
{
|
|
624
|
+
Add(_T("address"), &Address);
|
|
625
|
+
Add(_T("linked"), &Linked);
|
|
626
|
+
}
|
|
627
|
+
|
|
628
|
+
StatusChangedParamsData(const StatusChangedParamsData&) = delete;
|
|
629
|
+
StatusChangedParamsData(StatusChangedParamsData&&) noexcept = delete;
|
|
630
|
+
|
|
631
|
+
StatusChangedParamsData& operator=(const StatusChangedParamsData&) = delete;
|
|
632
|
+
StatusChangedParamsData& operator=(StatusChangedParamsData&&) noexcept = delete;
|
|
633
|
+
|
|
634
|
+
~StatusChangedParamsData() = default;
|
|
635
|
+
|
|
636
|
+
public:
|
|
637
|
+
bool IsDataValid() const
|
|
638
|
+
{
|
|
639
|
+
return ((((Address.IsSet() == true) && (Address.Length() >= 6 && Address.Length() <= 6))) && (Linked.IsSet() == true));
|
|
640
|
+
}
|
|
641
|
+
|
|
642
|
+
public:
|
|
643
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt8> Address; // Device address
|
|
644
|
+
Core::JSON::Boolean Linked; // Denotes if device is linked
|
|
645
|
+
}; // class StatusChangedParamsData
|
|
646
|
+
|
|
647
|
+
class Tables2ResultData : public Core::JSON::Container {
|
|
648
|
+
public:
|
|
649
|
+
Tables2ResultData()
|
|
650
|
+
: Core::JSON::Container()
|
|
651
|
+
{
|
|
652
|
+
Add(_T("stringTables"), &StringTables);
|
|
653
|
+
Add(_T("intTables"), &IntTables);
|
|
654
|
+
}
|
|
655
|
+
|
|
656
|
+
Tables2ResultData(const Tables2ResultData&) = delete;
|
|
657
|
+
Tables2ResultData(Tables2ResultData&&) noexcept = delete;
|
|
658
|
+
|
|
659
|
+
Tables2ResultData& operator=(const Tables2ResultData&) = delete;
|
|
660
|
+
Tables2ResultData& operator=(Tables2ResultData&&) noexcept = delete;
|
|
661
|
+
|
|
662
|
+
~Tables2ResultData() = default;
|
|
663
|
+
|
|
664
|
+
public:
|
|
665
|
+
bool IsDataValid() const
|
|
666
|
+
{
|
|
667
|
+
return ((((StringTables.IsSet() == true) && (StringTables.Length() <= 10))) && (((IntTables.IsSet() == true) && (IntTables.Length() <= 10))));
|
|
668
|
+
}
|
|
669
|
+
|
|
670
|
+
public:
|
|
671
|
+
Core::JSON::ArrayType<Core::JSON::String> StringTables;
|
|
672
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt8> IntTables;
|
|
673
|
+
}; // class Tables2ResultData
|
|
674
|
+
|
|
675
|
+
class Tables5ResultData : public Core::JSON::Container {
|
|
676
|
+
public:
|
|
677
|
+
Tables5ResultData()
|
|
678
|
+
: Core::JSON::Container()
|
|
679
|
+
{
|
|
680
|
+
Add(_T("stringTables"), &StringTables);
|
|
681
|
+
Add(_T("intTables"), &IntTables);
|
|
682
|
+
}
|
|
683
|
+
|
|
684
|
+
Tables5ResultData(const Tables5ResultData&) = delete;
|
|
685
|
+
Tables5ResultData(Tables5ResultData&&) noexcept = delete;
|
|
686
|
+
|
|
687
|
+
Tables5ResultData& operator=(const Tables5ResultData&) = delete;
|
|
688
|
+
Tables5ResultData& operator=(Tables5ResultData&&) noexcept = delete;
|
|
689
|
+
|
|
690
|
+
~Tables5ResultData() = default;
|
|
691
|
+
|
|
692
|
+
public:
|
|
693
|
+
bool IsDataValid() const
|
|
694
|
+
{
|
|
695
|
+
return ((StringTables.IsSet() == true) && (IntTables.IsSet() == true));
|
|
696
|
+
}
|
|
697
|
+
|
|
698
|
+
public:
|
|
699
|
+
Core::JSON::ArrayType<Core::JSON::String> StringTables;
|
|
700
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt32> IntTables;
|
|
701
|
+
}; // class Tables5ResultData
|
|
702
|
+
|
|
703
|
+
} // namespace SimpleAsync
|
|
704
|
+
|
|
705
|
+
POP_WARNING()
|
|
706
|
+
|
|
707
|
+
} // namespace JsonData
|
|
708
|
+
|
|
709
|
+
// Enum conversion handlers
|
|
710
|
+
ENUM_CONVERSION_HANDLER(Example::ISimpleAsync::state)
|
|
711
|
+
|
|
712
|
+
}
|
|
713
|
+
|
|
@@ -0,0 +1,136 @@
|
|
|
1
|
+
// C++ types for SimpleCustomObjects API.
|
|
2
|
+
// Generated automatically from 'ISimpleCustomObjects.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <example_interfaces/ISimpleCustomObjects.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SimpleCustomObjects {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AddedParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AddedParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("accessory"), &Accessory);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AddedParamsInfo(const AddedParamsInfo&) = delete;
|
|
31
|
+
AddedParamsInfo(AddedParamsInfo&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
AddedParamsInfo& operator=(const AddedParamsInfo&) = delete;
|
|
34
|
+
AddedParamsInfo& operator=(AddedParamsInfo&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~AddedParamsInfo() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Accessory.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Accessory; // Accessory instance
|
|
46
|
+
}; // class AddedParamsInfo
|
|
47
|
+
|
|
48
|
+
// Method params/result classes
|
|
49
|
+
//
|
|
50
|
+
|
|
51
|
+
class NameChangedParamsData : public Core::JSON::Container {
|
|
52
|
+
public:
|
|
53
|
+
NameChangedParamsData()
|
|
54
|
+
: Core::JSON::Container()
|
|
55
|
+
{
|
|
56
|
+
Add(_T("name"), &Name);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
NameChangedParamsData(const NameChangedParamsData&) = delete;
|
|
60
|
+
NameChangedParamsData(NameChangedParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
NameChangedParamsData& operator=(const NameChangedParamsData&) = delete;
|
|
63
|
+
NameChangedParamsData& operator=(NameChangedParamsData&&) noexcept = delete;
|
|
64
|
+
|
|
65
|
+
~NameChangedParamsData() = default;
|
|
66
|
+
|
|
67
|
+
public:
|
|
68
|
+
bool IsDataValid() const
|
|
69
|
+
{
|
|
70
|
+
return (Name.IsSet() == true);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
Core::JSON::String Name; // Name of the accessory
|
|
75
|
+
}; // class NameChangedParamsData
|
|
76
|
+
|
|
77
|
+
class NameData : public Core::JSON::Container {
|
|
78
|
+
public:
|
|
79
|
+
NameData()
|
|
80
|
+
: Core::JSON::Container()
|
|
81
|
+
{
|
|
82
|
+
Add(_T("value"), &Value);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
NameData(const NameData&) = delete;
|
|
86
|
+
NameData(NameData&&) noexcept = delete;
|
|
87
|
+
|
|
88
|
+
NameData& operator=(const NameData&) = delete;
|
|
89
|
+
NameData& operator=(NameData&&) noexcept = delete;
|
|
90
|
+
|
|
91
|
+
~NameData() = default;
|
|
92
|
+
|
|
93
|
+
public:
|
|
94
|
+
bool IsDataValid() const
|
|
95
|
+
{
|
|
96
|
+
return (Value.IsSet() == true);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
Core::JSON::String Value; // Name of the accessory
|
|
101
|
+
}; // class NameData
|
|
102
|
+
|
|
103
|
+
class PinData : public Core::JSON::Container {
|
|
104
|
+
public:
|
|
105
|
+
PinData()
|
|
106
|
+
: Core::JSON::Container()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("value"), &Value);
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
PinData(const PinData&) = delete;
|
|
112
|
+
PinData(PinData&&) noexcept = delete;
|
|
113
|
+
|
|
114
|
+
PinData& operator=(const PinData&) = delete;
|
|
115
|
+
PinData& operator=(PinData&&) noexcept = delete;
|
|
116
|
+
|
|
117
|
+
~PinData() = default;
|
|
118
|
+
|
|
119
|
+
public:
|
|
120
|
+
bool IsDataValid() const
|
|
121
|
+
{
|
|
122
|
+
return (Value.IsSet() == true);
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
public:
|
|
126
|
+
Core::JSON::Boolean Value; // Pin state
|
|
127
|
+
}; // class PinData
|
|
128
|
+
|
|
129
|
+
} // namespace SimpleCustomObjects
|
|
130
|
+
|
|
131
|
+
POP_WARNING()
|
|
132
|
+
|
|
133
|
+
} // namespace JsonData
|
|
134
|
+
|
|
135
|
+
}
|
|
136
|
+
|
|
@@ -0,0 +1,216 @@
|
|
|
1
|
+
// C++ types for SimpleInstanceObjects API.
|
|
2
|
+
// Generated automatically from 'ISimpleInstanceObjects.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <example_interfaces/ISimpleInstanceObjects.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SimpleInstanceObjects {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AcquireParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AcquireParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("name"), &Name);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AcquireParamsData(const AcquireParamsData&) = delete;
|
|
31
|
+
AcquireParamsData(AcquireParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
AcquireParamsData& operator=(const AcquireParamsData&) = delete;
|
|
34
|
+
AcquireParamsData& operator=(AcquireParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~AcquireParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Name.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Name; // Name of the device to acquire
|
|
46
|
+
}; // class AcquireParamsData
|
|
47
|
+
|
|
48
|
+
class NameChangedParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
NameChangedParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("state"), &State);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
NameChangedParamsData(const NameChangedParamsData&) = delete;
|
|
57
|
+
NameChangedParamsData(NameChangedParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
NameChangedParamsData& operator=(const NameChangedParamsData&) = delete;
|
|
60
|
+
NameChangedParamsData& operator=(NameChangedParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~NameChangedParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (State.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String State; // New name of the device
|
|
72
|
+
}; // class NameChangedParamsData
|
|
73
|
+
|
|
74
|
+
class NameData : public Core::JSON::Container {
|
|
75
|
+
public:
|
|
76
|
+
NameData()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
Add(_T("value"), &Value);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
NameData(const NameData&) = delete;
|
|
83
|
+
NameData(NameData&&) noexcept = delete;
|
|
84
|
+
|
|
85
|
+
NameData& operator=(const NameData&) = delete;
|
|
86
|
+
NameData& operator=(NameData&&) noexcept = delete;
|
|
87
|
+
|
|
88
|
+
~NameData() = default;
|
|
89
|
+
|
|
90
|
+
public:
|
|
91
|
+
bool IsDataValid() const
|
|
92
|
+
{
|
|
93
|
+
return (Value.IsSet() == true);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
public:
|
|
97
|
+
Core::JSON::String Value; // Name of the device
|
|
98
|
+
}; // class NameData
|
|
99
|
+
|
|
100
|
+
class PinChangedParamsData : public Core::JSON::Container {
|
|
101
|
+
public:
|
|
102
|
+
PinChangedParamsData()
|
|
103
|
+
: Core::JSON::Container()
|
|
104
|
+
{
|
|
105
|
+
Add(_T("pin"), &Pin);
|
|
106
|
+
Add(_T("high"), &High);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
PinChangedParamsData(const PinChangedParamsData&) = delete;
|
|
110
|
+
PinChangedParamsData(PinChangedParamsData&&) noexcept = delete;
|
|
111
|
+
|
|
112
|
+
PinChangedParamsData& operator=(const PinChangedParamsData&) = delete;
|
|
113
|
+
PinChangedParamsData& operator=(PinChangedParamsData&&) noexcept = delete;
|
|
114
|
+
|
|
115
|
+
~PinChangedParamsData() = default;
|
|
116
|
+
|
|
117
|
+
public:
|
|
118
|
+
bool IsDataValid() const
|
|
119
|
+
{
|
|
120
|
+
return (High.IsSet() == true);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
public:
|
|
124
|
+
Core::JSON::DecUInt8 Pin; // Signals pin state changes
|
|
125
|
+
Core::JSON::Boolean High; // Signals pin state changes
|
|
126
|
+
}; // class PinChangedParamsData
|
|
127
|
+
|
|
128
|
+
class PinData : public Core::JSON::Container {
|
|
129
|
+
public:
|
|
130
|
+
PinData()
|
|
131
|
+
: Core::JSON::Container()
|
|
132
|
+
{
|
|
133
|
+
Add(_T("value"), &Value);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
PinData(const PinData&) = delete;
|
|
137
|
+
PinData(PinData&&) noexcept = delete;
|
|
138
|
+
|
|
139
|
+
PinData& operator=(const PinData&) = delete;
|
|
140
|
+
PinData& operator=(PinData&&) noexcept = delete;
|
|
141
|
+
|
|
142
|
+
~PinData() = default;
|
|
143
|
+
|
|
144
|
+
public:
|
|
145
|
+
bool IsDataValid() const
|
|
146
|
+
{
|
|
147
|
+
return (Value.IsSet() == true);
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
public:
|
|
151
|
+
Core::JSON::Boolean Value; // A pin
|
|
152
|
+
}; // class PinData
|
|
153
|
+
|
|
154
|
+
class RelinquishParamsData : public Core::JSON::Container {
|
|
155
|
+
public:
|
|
156
|
+
RelinquishParamsData()
|
|
157
|
+
: Core::JSON::Container()
|
|
158
|
+
{
|
|
159
|
+
Add(_T("device"), &Device);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
RelinquishParamsData(const RelinquishParamsData&) = delete;
|
|
163
|
+
RelinquishParamsData(RelinquishParamsData&&) noexcept = delete;
|
|
164
|
+
|
|
165
|
+
RelinquishParamsData& operator=(const RelinquishParamsData&) = delete;
|
|
166
|
+
RelinquishParamsData& operator=(RelinquishParamsData&&) noexcept = delete;
|
|
167
|
+
|
|
168
|
+
~RelinquishParamsData() = default;
|
|
169
|
+
|
|
170
|
+
public:
|
|
171
|
+
bool IsDataValid() const
|
|
172
|
+
{
|
|
173
|
+
return (Device.IsSet() == true);
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
public:
|
|
177
|
+
Core::JSON::DecUInt32 Device; // Device instance to relinquish
|
|
178
|
+
}; // class RelinquishParamsData
|
|
179
|
+
|
|
180
|
+
class StateChangedParamsData : public Core::JSON::Container {
|
|
181
|
+
public:
|
|
182
|
+
StateChangedParamsData()
|
|
183
|
+
: Core::JSON::Container()
|
|
184
|
+
{
|
|
185
|
+
Add(_T("state"), &State);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
StateChangedParamsData(const StateChangedParamsData&) = delete;
|
|
189
|
+
StateChangedParamsData(StateChangedParamsData&&) noexcept = delete;
|
|
190
|
+
|
|
191
|
+
StateChangedParamsData& operator=(const StateChangedParamsData&) = delete;
|
|
192
|
+
StateChangedParamsData& operator=(StateChangedParamsData&&) noexcept = delete;
|
|
193
|
+
|
|
194
|
+
~StateChangedParamsData() = default;
|
|
195
|
+
|
|
196
|
+
public:
|
|
197
|
+
bool IsDataValid() const
|
|
198
|
+
{
|
|
199
|
+
return (State.IsSet() == true);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
public:
|
|
203
|
+
Core::JSON::EnumType<Example::ISimpleInstanceObjects::state> State; // New state of the device
|
|
204
|
+
}; // class StateChangedParamsData
|
|
205
|
+
|
|
206
|
+
} // namespace SimpleInstanceObjects
|
|
207
|
+
|
|
208
|
+
POP_WARNING()
|
|
209
|
+
|
|
210
|
+
} // namespace JsonData
|
|
211
|
+
|
|
212
|
+
// Enum conversion handlers
|
|
213
|
+
ENUM_CONVERSION_HANDLER(Example::ISimpleInstanceObjects::state)
|
|
214
|
+
|
|
215
|
+
}
|
|
216
|
+
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
// Enumeration code for SimpleAsync API.
|
|
2
|
+
// Generated automatically from 'ISimpleAsync.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <example_interfaces/ISimpleAsync.h>
|
|
8
|
+
#include "JsonData_SimpleAsync.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Example::ISimpleAsync::state)
|
|
13
|
+
{ Example::ISimpleAsync::state::DISCONNECTED, _TXT("DISCONNECTED") },
|
|
14
|
+
{ Example::ISimpleAsync::state::CONNECTING, _TXT("CONNECTING") },
|
|
15
|
+
{ Example::ISimpleAsync::state::CONNECTED, _TXT("CONNECTED") },
|
|
16
|
+
{ Example::ISimpleAsync::state::CONNECTING_FAILED, _TXT("CONNECTING_FAILED") },
|
|
17
|
+
{ Example::ISimpleAsync::state::CONNECTING_TIMED_OUT, _TXT("CONNECTING_TIMED_OUT") },
|
|
18
|
+
{ Example::ISimpleAsync::state::CONNECTING_ABORTED, _TXT("CONNECTING_ABORTED") },
|
|
19
|
+
ENUM_CONVERSION_END(Example::ISimpleAsync::state)
|
|
20
|
+
|
|
21
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// Enumeration code for SimpleInstanceObjects API.
|
|
2
|
+
// Generated automatically from 'ISimpleInstanceObjects.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <example_interfaces/ISimpleInstanceObjects.h>
|
|
8
|
+
#include "JsonData_SimpleInstanceObjects.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Example::ISimpleInstanceObjects::state)
|
|
13
|
+
{ Example::ISimpleInstanceObjects::state::ENABLED, _TXT("ENABLED") },
|
|
14
|
+
{ Example::ISimpleInstanceObjects::state::DISABLED, _TXT("DISABLED") },
|
|
15
|
+
ENUM_CONVERSION_END(Example::ISimpleInstanceObjects::state)
|
|
16
|
+
|
|
17
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ICustomErrorCode API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_CustomErrorCode.h"
|
|
7
|
+
#include "JCustomErrorCode.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISimpleAsync API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SimpleAsync.h"
|
|
7
|
+
#include "JSimpleAsync.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISimpleCustomObjects API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SimpleCustomObjects.h"
|
|
7
|
+
#include "JSimpleCustomObjects.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISimpleInstanceObjects API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SimpleInstanceObjects.h"
|
|
7
|
+
#include "JSimpleInstanceObjects.h"
|
|
@@ -0,0 +1,113 @@
|
|
|
1
|
+
// Generated automatically from 'IAVSClient.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_AVSController.h"
|
|
6
|
+
#include <interfaces/IAVSClient.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JAVSController {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IAVSController* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JAVSController"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'mute' - Mutes the audio output of AVS
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("mute"),
|
|
37
|
+
[_implementation__](const Core::JSON::Boolean& muted) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (muted.IsSet() == false) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAVSController"), _T("mute")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const bool _muted_{muted};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->Mute(_muted_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Method: 'record' - Starts or stops the voice recording, skipping keyword detection
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("record"),
|
|
56
|
+
[_implementation__](const Core::JSON::Boolean& started) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
if (started.IsSet() == false) {
|
|
60
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAVSController"), _T("record")));
|
|
61
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
62
|
+
}
|
|
63
|
+
else {
|
|
64
|
+
const bool _started_{started};
|
|
65
|
+
|
|
66
|
+
_errorCode__ = _implementation__->Record(_started_);
|
|
67
|
+
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
return (_errorCode__);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
template<typename MODULE>
|
|
76
|
+
static void Unregister(MODULE& _module__)
|
|
77
|
+
{
|
|
78
|
+
// Unregister methods and properties...
|
|
79
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("mute"));
|
|
80
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("record"));
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
namespace Event {
|
|
84
|
+
|
|
85
|
+
// Event: 'dialoguestatechange' - Notifies about dialogue state changes
|
|
86
|
+
template<typename MODULE>
|
|
87
|
+
static void DialogueStateChange(const MODULE& module_, const Core::JSON::EnumType<Exchange::IAVSController::INotification::dialoguestate>& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
88
|
+
{
|
|
89
|
+
module_.Notify(_T("dialoguestatechange"), state, sendIfMethod_);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
// Event: 'dialoguestatechange' - Notifies about dialogue state changes
|
|
93
|
+
template<typename MODULE>
|
|
94
|
+
static void DialogueStateChange(const MODULE& module_, const IAVSController::INotification::dialoguestate state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
95
|
+
{
|
|
96
|
+
Core::JSON::EnumType<Exchange::IAVSController::INotification::dialoguestate> params_;
|
|
97
|
+
params_ = state;
|
|
98
|
+
|
|
99
|
+
DialogueStateChange(module_, params_, sendIfMethod_);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
} // namespace Event
|
|
103
|
+
|
|
104
|
+
POP_WARNING()
|
|
105
|
+
POP_WARNING()
|
|
106
|
+
POP_WARNING()
|
|
107
|
+
|
|
108
|
+
} // namespace JAVSController
|
|
109
|
+
|
|
110
|
+
} // namespace Exchange
|
|
111
|
+
|
|
112
|
+
} // namespace Thunder
|
|
113
|
+
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
// Generated automatically from 'IAmazonPrime.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/IAmazonPrime.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JAmazonPrime {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IAmazonPrime* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JAmazonPrime"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Method: 'send' - Send a message over the message bus to ignition
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("send"),
|
|
36
|
+
[_implementation__](const Core::JSON::String& message) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
if (message.IsSet() == false) {
|
|
40
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAmazonPrime"), _T("send")));
|
|
41
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
42
|
+
}
|
|
43
|
+
else {
|
|
44
|
+
const string _message_{message};
|
|
45
|
+
|
|
46
|
+
_errorCode__ = _implementation__->Send(_message_);
|
|
47
|
+
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
return (_errorCode__);
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
template<typename MODULE>
|
|
56
|
+
static void Unregister(MODULE& _module__)
|
|
57
|
+
{
|
|
58
|
+
// Unregister methods and properties...
|
|
59
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("send"));
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
namespace Event {
|
|
63
|
+
|
|
64
|
+
// Event: 'receive' - Receive a message from the generic message bus
|
|
65
|
+
template<typename MODULE>
|
|
66
|
+
static void Receive(const MODULE& module_, const Core::JSON::String& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
67
|
+
{
|
|
68
|
+
module_.Notify(_T("receive"), message, sendIfMethod_);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
// Event: 'receive' - Receive a message from the generic message bus
|
|
72
|
+
template<typename MODULE>
|
|
73
|
+
static void Receive(const MODULE& module_, const string& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
74
|
+
{
|
|
75
|
+
Core::JSON::String params_;
|
|
76
|
+
params_ = message;
|
|
77
|
+
|
|
78
|
+
Receive(module_, params_, sendIfMethod_);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
} // namespace Event
|
|
82
|
+
|
|
83
|
+
POP_WARNING()
|
|
84
|
+
POP_WARNING()
|
|
85
|
+
POP_WARNING()
|
|
86
|
+
|
|
87
|
+
} // namespace JAmazonPrime
|
|
88
|
+
|
|
89
|
+
} // namespace Exchange
|
|
90
|
+
|
|
91
|
+
} // namespace Thunder
|
|
92
|
+
|
|
@@ -0,0 +1,208 @@
|
|
|
1
|
+
// Generated automatically from 'IApplication.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Application.h"
|
|
6
|
+
#include <interfaces/IApplication.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JApplication {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IApplication* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JApplication"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'reset' - Resets application data
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IApplication::resettype>, void>(_T("reset"),
|
|
37
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IApplication::resettype>& type) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (type.IsSet() == false) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JApplication"), _T("reset")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const Exchange::IApplication::resettype _type_{type};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->Reset(_type_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Property: 'identifier' - Application-specific identification string (r/o)
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("identifier"),
|
|
56
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
string _result_{};
|
|
60
|
+
|
|
61
|
+
_errorCode__ = _implementation__->Identifier(_result_);
|
|
62
|
+
|
|
63
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
64
|
+
result = _result_;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
return (_errorCode__);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
// Property: 'contentlink' - URI of the associated application-specific content (w/o)
|
|
71
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("contentlink"),
|
|
72
|
+
[_implementation__](const Core::JSON::String& params) -> uint32_t {
|
|
73
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
74
|
+
|
|
75
|
+
if (params.IsSet() == false) {
|
|
76
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JApplication"), _T("contentlink")));
|
|
77
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
78
|
+
}
|
|
79
|
+
else {
|
|
80
|
+
const string _params_{params};
|
|
81
|
+
|
|
82
|
+
_errorCode__ = _implementation__->ContentLink(_params_);
|
|
83
|
+
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
return (_errorCode__);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
// Property: 'launchpoint' - Application launching point
|
|
90
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IApplication::launchpointtype>, Core::JSON::EnumType<Exchange::IApplication::launchpointtype>>(_T("launchpoint"),
|
|
91
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IApplication::launchpointtype>& params, Core::JSON::EnumType<Exchange::IApplication::launchpointtype>& result) -> uint32_t {
|
|
92
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
93
|
+
|
|
94
|
+
if (params.IsSet() == false) {
|
|
95
|
+
Exchange::IApplication::launchpointtype _result_{};
|
|
96
|
+
|
|
97
|
+
_errorCode__ = (static_cast<const IApplication*>(_implementation__))->LaunchPoint(_result_);
|
|
98
|
+
|
|
99
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
100
|
+
result = _result_;
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
else {
|
|
104
|
+
const Exchange::IApplication::launchpointtype _params_{params};
|
|
105
|
+
|
|
106
|
+
_errorCode__ = _implementation__->LaunchPoint(_params_);
|
|
107
|
+
|
|
108
|
+
result.Null(true);
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
return (_errorCode__);
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
// Property: 'visible' - Current application visibility
|
|
115
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, Core::JSON::Boolean>(_T("visible"),
|
|
116
|
+
[_implementation__](const Core::JSON::Boolean& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
117
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
118
|
+
|
|
119
|
+
if (params.IsSet() == false) {
|
|
120
|
+
bool _result_{};
|
|
121
|
+
|
|
122
|
+
_errorCode__ = (static_cast<const IApplication*>(_implementation__))->Visible(_result_);
|
|
123
|
+
|
|
124
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
125
|
+
result = _result_;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
else {
|
|
129
|
+
const bool _params_{params};
|
|
130
|
+
|
|
131
|
+
_errorCode__ = _implementation__->Visible(_params_);
|
|
132
|
+
|
|
133
|
+
result.Null(true);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
return (_errorCode__);
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
// Property: 'language' - Current application user interface language
|
|
140
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("language"),
|
|
141
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
142
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
143
|
+
|
|
144
|
+
if (params.IsSet() == false) {
|
|
145
|
+
string _result_{};
|
|
146
|
+
|
|
147
|
+
_errorCode__ = (static_cast<const IApplication*>(_implementation__))->Language(_result_);
|
|
148
|
+
|
|
149
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
150
|
+
result = _result_;
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
else {
|
|
154
|
+
const string _params_{params};
|
|
155
|
+
|
|
156
|
+
_errorCode__ = _implementation__->Language(_params_);
|
|
157
|
+
|
|
158
|
+
result.Null(true);
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
return (_errorCode__);
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
template<typename MODULE>
|
|
167
|
+
static void Unregister(MODULE& _module__)
|
|
168
|
+
{
|
|
169
|
+
// Unregister methods and properties...
|
|
170
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("reset"));
|
|
171
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("identifier"));
|
|
172
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("contentlink"));
|
|
173
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("launchpoint"));
|
|
174
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("visible"));
|
|
175
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("language"));
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
namespace Event {
|
|
179
|
+
|
|
180
|
+
// Event: 'visibilitychange' - Application visibility changes
|
|
181
|
+
template<typename MODULE>
|
|
182
|
+
static void VisibilityChange(const MODULE& module_, const Core::JSON::Boolean& hidden, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
183
|
+
{
|
|
184
|
+
module_.Notify(_T("visibilitychange"), hidden, sendIfMethod_);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
// Event: 'visibilitychange' - Application visibility changes
|
|
188
|
+
template<typename MODULE>
|
|
189
|
+
static void VisibilityChange(const MODULE& module_, const bool hidden, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
190
|
+
{
|
|
191
|
+
Core::JSON::Boolean params_;
|
|
192
|
+
params_ = hidden;
|
|
193
|
+
|
|
194
|
+
VisibilityChange(module_, params_, sendIfMethod_);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
} // namespace Event
|
|
198
|
+
|
|
199
|
+
POP_WARNING()
|
|
200
|
+
POP_WARNING()
|
|
201
|
+
POP_WARNING()
|
|
202
|
+
|
|
203
|
+
} // namespace JApplication
|
|
204
|
+
|
|
205
|
+
} // namespace Exchange
|
|
206
|
+
|
|
207
|
+
} // namespace Thunder
|
|
208
|
+
|
|
@@ -0,0 +1,338 @@
|
|
|
1
|
+
// Generated automatically from 'IAudioStream.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_AudioStream.h"
|
|
6
|
+
#include <interfaces/IAudioStream.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JAudioStream {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
struct IHandler {
|
|
23
|
+
virtual ~IHandler() = default;
|
|
24
|
+
virtual void OnStateChangedEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
28
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
29
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
30
|
+
|
|
31
|
+
template<typename MODULE>
|
|
32
|
+
static void Register(MODULE& _module__, IAudioStream* _implementation__, IHandler* _handler_)
|
|
33
|
+
{
|
|
34
|
+
ASSERT(_implementation__ != nullptr);
|
|
35
|
+
ASSERT(_handler_ != nullptr);
|
|
36
|
+
|
|
37
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JAudioStream"), Version::Major, Version::Minor, Version::Patch);
|
|
38
|
+
|
|
39
|
+
// Register methods and properties...
|
|
40
|
+
|
|
41
|
+
// Property: 'name' - Name of the stream (r/o)
|
|
42
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("name"),
|
|
43
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
44
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
45
|
+
|
|
46
|
+
string _result_{};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->Name(_result_);
|
|
49
|
+
|
|
50
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
51
|
+
result = _result_;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Property: 'state' - Current state of the stream (r/o)
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IAudioStream::streamstate>>(_T("state"),
|
|
59
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IAudioStream::streamstate>& result) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
Exchange::IAudioStream::streamstate _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->State(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result = _result_;
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
return (_errorCode__);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
// Property: 'capabilities' - List of codecs supported by the stream (r/o)
|
|
74
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IAudioStream::codectype>>>(_T("capabilities"),
|
|
75
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IAudioStream::codectype>>& result) -> uint32_t {
|
|
76
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
77
|
+
|
|
78
|
+
Exchange::IAudioStream::codectype _result_{};
|
|
79
|
+
|
|
80
|
+
_errorCode__ = _implementation__->Capabilities(_result_);
|
|
81
|
+
|
|
82
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
83
|
+
result.Set(true);
|
|
84
|
+
result = _result_;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
return (_errorCode__);
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
// Property: 'audioprofile' - Preferred profile of the stream
|
|
91
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::AudioStream::ProfileData, JsonData::AudioStream::AudioprofileInfo>(_T("audioprofile"),
|
|
92
|
+
[_implementation__](const JsonData::AudioStream::ProfileData& params, JsonData::AudioStream::AudioprofileInfo& result) -> uint32_t {
|
|
93
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
94
|
+
|
|
95
|
+
if (params.IsSet() == false) {
|
|
96
|
+
Exchange::IAudioStream::audioprofile _result_{};
|
|
97
|
+
|
|
98
|
+
_errorCode__ = (static_cast<const IAudioStream*>(_implementation__))->Profile(_result_);
|
|
99
|
+
|
|
100
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
101
|
+
result.Set(true);
|
|
102
|
+
result = _result_;
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
else {
|
|
106
|
+
|
|
107
|
+
if (params.IsDataValid() == false) {
|
|
108
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAudioStream"), _T("audioprofile")));
|
|
109
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
110
|
+
}
|
|
111
|
+
else {
|
|
112
|
+
const Exchange::IAudioStream::audioprofile _value_(params.Value);
|
|
113
|
+
|
|
114
|
+
_errorCode__ = _implementation__->Profile(_value_);
|
|
115
|
+
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
result.Null(true);
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
return (_errorCode__);
|
|
122
|
+
});
|
|
123
|
+
|
|
124
|
+
// Property: 'time' - Stream position (r/o)
|
|
125
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32>(_T("time"),
|
|
126
|
+
[_implementation__](Core::JSON::DecUInt32& result) -> uint32_t {
|
|
127
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
128
|
+
|
|
129
|
+
uint32_t _result_{};
|
|
130
|
+
|
|
131
|
+
_errorCode__ = _implementation__->Time(_result_);
|
|
132
|
+
|
|
133
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
134
|
+
result = _result_;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
return (_errorCode__);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
// Property: 'speed' - Stream speed
|
|
141
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::AudioStream::SpeedData, Core::JSON::DecUInt8>(_T("speed"),
|
|
142
|
+
[_implementation__](const JsonData::AudioStream::SpeedData& params, Core::JSON::DecUInt8& result) -> uint32_t {
|
|
143
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
144
|
+
|
|
145
|
+
if (params.IsSet() == false) {
|
|
146
|
+
uint8_t _result_{};
|
|
147
|
+
|
|
148
|
+
_errorCode__ = (static_cast<const IAudioStream*>(_implementation__))->Speed(_result_);
|
|
149
|
+
|
|
150
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
151
|
+
result = _result_;
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
else {
|
|
155
|
+
|
|
156
|
+
if (params.IsDataValid() == false) {
|
|
157
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAudioStream"), _T("speed")));
|
|
158
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
159
|
+
}
|
|
160
|
+
else {
|
|
161
|
+
const uint8_t _value_{params.Value};
|
|
162
|
+
|
|
163
|
+
_errorCode__ = _implementation__->Speed(_value_);
|
|
164
|
+
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
result.Null(true);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
return (_errorCode__);
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
// Register event status listeners...
|
|
174
|
+
|
|
175
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("audiotransmission"),
|
|
176
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
177
|
+
_handler_->OnStateChangedEventRegistration(client_, status_);
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
template<typename MODULE>
|
|
183
|
+
static void Unregister(MODULE& _module__)
|
|
184
|
+
{
|
|
185
|
+
// Unregister methods and properties...
|
|
186
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("name"));
|
|
187
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("state"));
|
|
188
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("capabilities"));
|
|
189
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("audioprofile"));
|
|
190
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("time"));
|
|
191
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("speed"));
|
|
192
|
+
|
|
193
|
+
// Unregister event status listeners...
|
|
194
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("audiotransmission"));
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
namespace Event {
|
|
198
|
+
|
|
199
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
200
|
+
template<typename MODULE>
|
|
201
|
+
static void StateChanged(const MODULE& module_, const JsonData::AudioStream::StateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
202
|
+
{
|
|
203
|
+
module_.Notify(_T("audiotransmission"), params, sendIfMethod_);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
207
|
+
template<typename MODULE>
|
|
208
|
+
static void StateChanged(const MODULE& module_, const JsonData::AudioStream::StateChangedParamsData& params, const string& client_)
|
|
209
|
+
{
|
|
210
|
+
module_.Notify(_T("audiotransmission"), params, [&client_](const string& designator_) -> bool {
|
|
211
|
+
return ((client_ == designator_));
|
|
212
|
+
});
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
216
|
+
template<typename MODULE>
|
|
217
|
+
static void StateChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::IAudioStream::streamstate>& state, const JsonData::AudioStream::AudioprofileInfo& profile, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
218
|
+
{
|
|
219
|
+
JsonData::AudioStream::StateChangedParamsData params_;
|
|
220
|
+
params_.State = state;
|
|
221
|
+
params_.Profile = profile;
|
|
222
|
+
|
|
223
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
227
|
+
template<typename MODULE>
|
|
228
|
+
static void StateChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::IAudioStream::streamstate>& state, const JsonData::AudioStream::AudioprofileInfo& profile, const string& client_)
|
|
229
|
+
{
|
|
230
|
+
JsonData::AudioStream::StateChangedParamsData params_;
|
|
231
|
+
params_.State = state;
|
|
232
|
+
params_.Profile = profile;
|
|
233
|
+
|
|
234
|
+
StateChanged(module_, params_, client_);
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
238
|
+
template<typename MODULE>
|
|
239
|
+
static void StateChanged(const MODULE& module_, const IAudioStream::streamstate state, const Core::OptionalType<IAudioStream::audioprofile>& profile, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
240
|
+
{
|
|
241
|
+
JsonData::AudioStream::StateChangedParamsData params_;
|
|
242
|
+
params_.State = state;
|
|
243
|
+
|
|
244
|
+
if (profile.IsSet() == true) {
|
|
245
|
+
params_.Profile = profile.Value();
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
// Event: 'audiotransmission' - Signals state of the stream
|
|
252
|
+
template<typename MODULE>
|
|
253
|
+
static void StateChanged(const MODULE& module_, const IAudioStream::streamstate state, const Core::OptionalType<IAudioStream::audioprofile>& profile, const string& client_)
|
|
254
|
+
{
|
|
255
|
+
JsonData::AudioStream::StateChangedParamsData params_;
|
|
256
|
+
params_.State = state;
|
|
257
|
+
|
|
258
|
+
if (profile.IsSet() == true) {
|
|
259
|
+
params_.Profile = profile.Value();
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
StateChanged(module_, params_, client_);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
// Event: 'audioframe' - Provides audio data
|
|
266
|
+
template<typename MODULE>
|
|
267
|
+
static void Data(const MODULE& module_, const JsonData::AudioStream::DataParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
268
|
+
{
|
|
269
|
+
module_.Notify(_T("audioframe"), params, sendIfMethod_);
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
// Event: 'audioframe' - Provides audio data
|
|
273
|
+
template<typename MODULE>
|
|
274
|
+
static void Data(const MODULE& module_, const Core::JSON::DecUInt16& seq, const Core::JSON::DecUInt32& timestamp, const Core::JSON::DecUInt16& length, const Core::JSON::String& data, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
275
|
+
{
|
|
276
|
+
JsonData::AudioStream::DataParamsData params_;
|
|
277
|
+
params_.Seq = seq;
|
|
278
|
+
params_.Timestamp = timestamp;
|
|
279
|
+
params_.Length = length;
|
|
280
|
+
params_.Data = data;
|
|
281
|
+
|
|
282
|
+
Data(module_, params_, sendIfMethod_);
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
// Event: 'audioframe' - Provides audio data
|
|
286
|
+
template<typename MODULE>
|
|
287
|
+
static void Data(const MODULE& module_, const Core::OptionalType<uint16_t>& seq, const Core::OptionalType<uint32_t>& timestamp, const uint16_t length, const uint8_t* data, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
288
|
+
{
|
|
289
|
+
JsonData::AudioStream::DataParamsData params_;
|
|
290
|
+
|
|
291
|
+
if (seq.IsSet() == true) {
|
|
292
|
+
params_.Seq = seq.Value();
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
if (timestamp.IsSet() == true) {
|
|
296
|
+
params_.Timestamp = timestamp.Value();
|
|
297
|
+
}
|
|
298
|
+
params_.Length = length;
|
|
299
|
+
string _dataEncoded__;
|
|
300
|
+
ASSERT(data != nullptr);
|
|
301
|
+
Core::ToString(data, length, true, _dataEncoded__);
|
|
302
|
+
params_.Data = std::move(_dataEncoded__);
|
|
303
|
+
|
|
304
|
+
Data(module_, params_, sendIfMethod_);
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
// legacy array as string version
|
|
308
|
+
// Event: 'audioframe' - Provides audio data
|
|
309
|
+
template<typename MODULE>
|
|
310
|
+
static void Data(const MODULE& module_, const Core::OptionalType<uint16_t>& seq, const Core::OptionalType<uint32_t>& timestamp, const uint16_t length, const string& data, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
311
|
+
{
|
|
312
|
+
JsonData::AudioStream::DataParamsData params_;
|
|
313
|
+
|
|
314
|
+
if (seq.IsSet() == true) {
|
|
315
|
+
params_.Seq = seq.Value();
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
if (timestamp.IsSet() == true) {
|
|
319
|
+
params_.Timestamp = timestamp.Value();
|
|
320
|
+
}
|
|
321
|
+
params_.Length = length;
|
|
322
|
+
params_.Data = data;
|
|
323
|
+
|
|
324
|
+
Data(module_, params_, sendIfMethod_);
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
} // namespace Event
|
|
328
|
+
|
|
329
|
+
POP_WARNING()
|
|
330
|
+
POP_WARNING()
|
|
331
|
+
POP_WARNING()
|
|
332
|
+
|
|
333
|
+
} // namespace JAudioStream
|
|
334
|
+
|
|
335
|
+
} // namespace Exchange
|
|
336
|
+
|
|
337
|
+
} // namespace Thunder
|
|
338
|
+
|
|
@@ -0,0 +1,293 @@
|
|
|
1
|
+
// Generated automatically from 'IBluetoothAudio.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BluetoothAudioSink.h"
|
|
6
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace BluetoothAudio {
|
|
13
|
+
|
|
14
|
+
namespace JSink {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, IBluetoothAudio::ISink* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSink"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Method: 'sink::assign' - Assigns a Bluetooth sink device for audio playback
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothAudio::Sink::AssignParamsData, void>(_T("sink::assign"),
|
|
39
|
+
[_implementation__](const JsonData::BluetoothAudio::Sink::AssignParamsData& params) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSink"), _T("sink::assign")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const string _address_{params.Address};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Assign(_address_);
|
|
50
|
+
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
// Method: 'sink::revoke' - Revokes a Bluetooth sink device from audio playback
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("sink::revoke"),
|
|
58
|
+
[_implementation__]() -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
_errorCode__ = _implementation__->Revoke();
|
|
62
|
+
|
|
63
|
+
return (_errorCode__);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
// Property: 'sink::state' - Current state o the audio sink device (r/o)
|
|
67
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IBluetoothAudio::state>>(_T("sink::state"),
|
|
68
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IBluetoothAudio::state>& result) -> uint32_t {
|
|
69
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
70
|
+
|
|
71
|
+
Exchange::IBluetoothAudio::state _result_{};
|
|
72
|
+
|
|
73
|
+
_errorCode__ = _implementation__->State(_result_);
|
|
74
|
+
|
|
75
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
76
|
+
result = _result_;
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
return (_errorCode__);
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
// Property: 'sink::device' - Bluetooth address of the audio sink device (r/o)
|
|
83
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("sink::device"),
|
|
84
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
85
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
86
|
+
|
|
87
|
+
string _result_{};
|
|
88
|
+
|
|
89
|
+
_errorCode__ = _implementation__->Device(_result_);
|
|
90
|
+
|
|
91
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
92
|
+
result = _result_;
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
return (_errorCode__);
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
// Property: 'sink::type' - Type of the audio sink device (r/o)
|
|
99
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IBluetoothAudio::ISink::devicetype>>(_T("sink::type"),
|
|
100
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IBluetoothAudio::ISink::devicetype>& result) -> uint32_t {
|
|
101
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
102
|
+
|
|
103
|
+
Exchange::IBluetoothAudio::ISink::devicetype _result_{};
|
|
104
|
+
|
|
105
|
+
_errorCode__ = _implementation__->Type(_result_);
|
|
106
|
+
|
|
107
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
108
|
+
result = _result_;
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
return (_errorCode__);
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
// Property: 'sink::latency' - Latency of the audio sink device
|
|
115
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothAudio::Sink::LatencyData, Core::JSON::DecSInt16>(_T("sink::latency"),
|
|
116
|
+
[_implementation__](const JsonData::BluetoothAudio::Sink::LatencyData& params, Core::JSON::DecSInt16& result) -> uint32_t {
|
|
117
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
118
|
+
|
|
119
|
+
if (params.IsSet() == false) {
|
|
120
|
+
int16_t _result_{};
|
|
121
|
+
|
|
122
|
+
_errorCode__ = (static_cast<const IBluetoothAudio::ISink*>(_implementation__))->Latency(_result_);
|
|
123
|
+
|
|
124
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
125
|
+
result = _result_;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
else {
|
|
129
|
+
|
|
130
|
+
if (params.IsDataValid() == false) {
|
|
131
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSink"), _T("sink::latency")));
|
|
132
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
133
|
+
}
|
|
134
|
+
else {
|
|
135
|
+
const int16_t _value_{params.Value};
|
|
136
|
+
|
|
137
|
+
_errorCode__ = _implementation__->Latency(_value_);
|
|
138
|
+
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
result.Null(true);
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
return (_errorCode__);
|
|
145
|
+
});
|
|
146
|
+
|
|
147
|
+
// Property: 'sink::supportedcodecs' - Audio codecs supported by the audio sink device (r/o)
|
|
148
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IBluetoothAudio::audiocodec>>>(_T("sink::supportedcodecs"),
|
|
149
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IBluetoothAudio::audiocodec>>& result) -> uint32_t {
|
|
150
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
151
|
+
|
|
152
|
+
Exchange::IBluetoothAudio::audiocodec _result_{};
|
|
153
|
+
|
|
154
|
+
_errorCode__ = _implementation__->SupportedCodecs(_result_);
|
|
155
|
+
|
|
156
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
157
|
+
result.Set(true);
|
|
158
|
+
result = _result_;
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
return (_errorCode__);
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
// Property: 'sink::supporteddrms' - DRM schemes supported by the audio sink device (r/o)
|
|
165
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IBluetoothAudio::drmscheme>>>(_T("sink::supporteddrms"),
|
|
166
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IBluetoothAudio::drmscheme>>& result) -> uint32_t {
|
|
167
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
168
|
+
|
|
169
|
+
Exchange::IBluetoothAudio::drmscheme _result_{};
|
|
170
|
+
|
|
171
|
+
_errorCode__ = _implementation__->SupportedDRMs(_result_);
|
|
172
|
+
|
|
173
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
174
|
+
result.Set(true);
|
|
175
|
+
result = _result_;
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
return (_errorCode__);
|
|
179
|
+
});
|
|
180
|
+
|
|
181
|
+
// Property: 'sink::codec' - Properites of the currently used audio codec (r/o)
|
|
182
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Sink::CodecPropertiesData>(_T("sink::codec"),
|
|
183
|
+
[_implementation__](JsonData::BluetoothAudio::Sink::CodecPropertiesData& result) -> uint32_t {
|
|
184
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
185
|
+
|
|
186
|
+
Exchange::IBluetoothAudio::CodecProperties _result_{};
|
|
187
|
+
|
|
188
|
+
_errorCode__ = _implementation__->Codec(_result_);
|
|
189
|
+
|
|
190
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
191
|
+
result.Set(true);
|
|
192
|
+
result = _result_;
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
return (_errorCode__);
|
|
196
|
+
});
|
|
197
|
+
|
|
198
|
+
// Property: 'sink::drm' - Properites of the currently used DRM scheme (r/o)
|
|
199
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Sink::DRMPropertiesData>(_T("sink::drm"),
|
|
200
|
+
[_implementation__](JsonData::BluetoothAudio::Sink::DRMPropertiesData& result) -> uint32_t {
|
|
201
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
202
|
+
|
|
203
|
+
Exchange::IBluetoothAudio::DRMProperties _result_{};
|
|
204
|
+
|
|
205
|
+
_errorCode__ = _implementation__->DRM(_result_);
|
|
206
|
+
|
|
207
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
208
|
+
result.Set(true);
|
|
209
|
+
result = _result_;
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
return (_errorCode__);
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
// Property: 'sink::stream' - Properties of the currently transmitted audio stream (r/o)
|
|
216
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Sink::StreamPropertiesData>(_T("sink::stream"),
|
|
217
|
+
[_implementation__](JsonData::BluetoothAudio::Sink::StreamPropertiesData& result) -> uint32_t {
|
|
218
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
219
|
+
|
|
220
|
+
Exchange::IBluetoothAudio::StreamProperties _result_{};
|
|
221
|
+
|
|
222
|
+
_errorCode__ = _implementation__->Stream(_result_);
|
|
223
|
+
|
|
224
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
225
|
+
result.Set(true);
|
|
226
|
+
result = _result_;
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
return (_errorCode__);
|
|
230
|
+
});
|
|
231
|
+
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
template<typename MODULE>
|
|
235
|
+
static void Unregister(MODULE& _module__)
|
|
236
|
+
{
|
|
237
|
+
// Unregister methods and properties...
|
|
238
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::assign"));
|
|
239
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::revoke"));
|
|
240
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::state"));
|
|
241
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::device"));
|
|
242
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::type"));
|
|
243
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::latency"));
|
|
244
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::supportedcodecs"));
|
|
245
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::supporteddrms"));
|
|
246
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::codec"));
|
|
247
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::drm"));
|
|
248
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sink::stream"));
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
namespace Event {
|
|
252
|
+
|
|
253
|
+
// Event: 'sink::statechanged' - Signals audio sink state change
|
|
254
|
+
template<typename MODULE>
|
|
255
|
+
static void StateChanged(const MODULE& module_, const JsonData::BluetoothAudio::Sink::StateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
256
|
+
{
|
|
257
|
+
module_.Notify(_T("sink::statechanged"), params, sendIfMethod_);
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
// Event: 'sink::statechanged' - Signals audio sink state change
|
|
261
|
+
template<typename MODULE>
|
|
262
|
+
static void StateChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::IBluetoothAudio::state>& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
263
|
+
{
|
|
264
|
+
JsonData::BluetoothAudio::Sink::StateChangedParamsData params_;
|
|
265
|
+
params_.State = state;
|
|
266
|
+
|
|
267
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
// Event: 'sink::statechanged' - Signals audio sink state change
|
|
271
|
+
template<typename MODULE>
|
|
272
|
+
static void StateChanged(const MODULE& module_, const IBluetoothAudio::state state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
273
|
+
{
|
|
274
|
+
JsonData::BluetoothAudio::Sink::StateChangedParamsData params_;
|
|
275
|
+
params_.State = state;
|
|
276
|
+
|
|
277
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
} // namespace Event
|
|
281
|
+
|
|
282
|
+
POP_WARNING()
|
|
283
|
+
POP_WARNING()
|
|
284
|
+
POP_WARNING()
|
|
285
|
+
|
|
286
|
+
} // namespace JSink
|
|
287
|
+
|
|
288
|
+
} // namespace BluetoothAudio
|
|
289
|
+
|
|
290
|
+
} // namespace Exchange
|
|
291
|
+
|
|
292
|
+
} // namespace Thunder
|
|
293
|
+
|
|
@@ -0,0 +1,192 @@
|
|
|
1
|
+
// Generated automatically from 'IBluetoothAudio.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BluetoothAudioSource.h"
|
|
6
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace BluetoothAudio {
|
|
13
|
+
|
|
14
|
+
namespace JSource {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, IBluetoothAudio::ISource* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSource"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Property: 'source::state' - Current state of the source device (r/o)
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IBluetoothAudio::state>>(_T("source::state"),
|
|
39
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IBluetoothAudio::state>& result) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
Exchange::IBluetoothAudio::state _result_{};
|
|
43
|
+
|
|
44
|
+
_errorCode__ = _implementation__->State(_result_);
|
|
45
|
+
|
|
46
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
47
|
+
result = _result_;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
return (_errorCode__);
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
// Property: 'source::device' - Bluetooth address of the source device (r/o)
|
|
54
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("source::device"),
|
|
55
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
56
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
57
|
+
|
|
58
|
+
string _result_{};
|
|
59
|
+
|
|
60
|
+
_errorCode__ = _implementation__->Device(_result_);
|
|
61
|
+
|
|
62
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
63
|
+
result = _result_;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
return (_errorCode__);
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
// Property: 'source::type' - Type of the audio source device (r/o)
|
|
70
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IBluetoothAudio::ISource::devicetype>>(_T("source::type"),
|
|
71
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IBluetoothAudio::ISource::devicetype>& result) -> uint32_t {
|
|
72
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
73
|
+
|
|
74
|
+
Exchange::IBluetoothAudio::ISource::devicetype _result_{};
|
|
75
|
+
|
|
76
|
+
_errorCode__ = _implementation__->Type(_result_);
|
|
77
|
+
|
|
78
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
79
|
+
result = _result_;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
// Property: 'source::codec' - Properites of the currently used codec (r/o)
|
|
86
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Source::CodecPropertiesData>(_T("source::codec"),
|
|
87
|
+
[_implementation__](JsonData::BluetoothAudio::Source::CodecPropertiesData& result) -> uint32_t {
|
|
88
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
89
|
+
|
|
90
|
+
Exchange::IBluetoothAudio::CodecProperties _result_{};
|
|
91
|
+
|
|
92
|
+
_errorCode__ = _implementation__->Codec(_result_);
|
|
93
|
+
|
|
94
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
95
|
+
result.Set(true);
|
|
96
|
+
result = _result_;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
return (_errorCode__);
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
// Property: 'source::drm' - Properties of the currently used DRM scheme (r/o)
|
|
103
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Source::DRMPropertiesData>(_T("source::drm"),
|
|
104
|
+
[_implementation__](JsonData::BluetoothAudio::Source::DRMPropertiesData& result) -> uint32_t {
|
|
105
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
106
|
+
|
|
107
|
+
Exchange::IBluetoothAudio::DRMProperties _result_{};
|
|
108
|
+
|
|
109
|
+
_errorCode__ = _implementation__->DRM(_result_);
|
|
110
|
+
|
|
111
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
112
|
+
result.Set(true);
|
|
113
|
+
result = _result_;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
return (_errorCode__);
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
// Property: 'source::stream' - Properites of the currently transmitted audio stream (r/o)
|
|
120
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothAudio::Source::StreamPropertiesData>(_T("source::stream"),
|
|
121
|
+
[_implementation__](JsonData::BluetoothAudio::Source::StreamPropertiesData& result) -> uint32_t {
|
|
122
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
123
|
+
|
|
124
|
+
Exchange::IBluetoothAudio::StreamProperties _result_{};
|
|
125
|
+
|
|
126
|
+
_errorCode__ = _implementation__->Stream(_result_);
|
|
127
|
+
|
|
128
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
129
|
+
result.Set(true);
|
|
130
|
+
result = _result_;
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
return (_errorCode__);
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
template<typename MODULE>
|
|
139
|
+
static void Unregister(MODULE& _module__)
|
|
140
|
+
{
|
|
141
|
+
// Unregister methods and properties...
|
|
142
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::state"));
|
|
143
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::device"));
|
|
144
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::type"));
|
|
145
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::codec"));
|
|
146
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::drm"));
|
|
147
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source::stream"));
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
namespace Event {
|
|
151
|
+
|
|
152
|
+
// Event: 'source::statechanged' - Signals audio source state change
|
|
153
|
+
template<typename MODULE>
|
|
154
|
+
static void StateChanged(const MODULE& module_, const JsonData::BluetoothAudio::Source::StateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
155
|
+
{
|
|
156
|
+
module_.Notify(_T("source::statechanged"), params, sendIfMethod_);
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
// Event: 'source::statechanged' - Signals audio source state change
|
|
160
|
+
template<typename MODULE>
|
|
161
|
+
static void StateChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::IBluetoothAudio::state>& state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
162
|
+
{
|
|
163
|
+
JsonData::BluetoothAudio::Source::StateChangedParamsData params_;
|
|
164
|
+
params_.State = state;
|
|
165
|
+
|
|
166
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
// Event: 'source::statechanged' - Signals audio source state change
|
|
170
|
+
template<typename MODULE>
|
|
171
|
+
static void StateChanged(const MODULE& module_, const IBluetoothAudio::state state, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
172
|
+
{
|
|
173
|
+
JsonData::BluetoothAudio::Source::StateChangedParamsData params_;
|
|
174
|
+
params_.State = state;
|
|
175
|
+
|
|
176
|
+
StateChanged(module_, params_, sendIfMethod_);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
} // namespace Event
|
|
180
|
+
|
|
181
|
+
POP_WARNING()
|
|
182
|
+
POP_WARNING()
|
|
183
|
+
POP_WARNING()
|
|
184
|
+
|
|
185
|
+
} // namespace JSource
|
|
186
|
+
|
|
187
|
+
} // namespace BluetoothAudio
|
|
188
|
+
|
|
189
|
+
} // namespace Exchange
|
|
190
|
+
|
|
191
|
+
} // namespace Thunder
|
|
192
|
+
|
|
@@ -0,0 +1,925 @@
|
|
|
1
|
+
// Generated automatically from 'IBluetooth.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BluetoothControl.h"
|
|
6
|
+
#include <interfaces/IBluetooth.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JSONRPC {
|
|
13
|
+
|
|
14
|
+
namespace JBluetoothControl {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
struct IHandler {
|
|
25
|
+
virtual ~IHandler() = default;
|
|
26
|
+
virtual void OnDiscoverableStartedEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
27
|
+
virtual void OnScanStartedEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
28
|
+
virtual void OnDeviceStateChangedEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
32
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
33
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
34
|
+
|
|
35
|
+
template<typename MODULE>
|
|
36
|
+
static void Register(MODULE& _module__, IBluetoothControl* _implementation__, IHandler* _handler_)
|
|
37
|
+
{
|
|
38
|
+
ASSERT(_implementation__ != nullptr);
|
|
39
|
+
ASSERT(_handler_ != nullptr);
|
|
40
|
+
|
|
41
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBluetoothControl"), Version::Major, Version::Minor, Version::Patch);
|
|
42
|
+
|
|
43
|
+
// Register methods and properties...
|
|
44
|
+
|
|
45
|
+
// Method: 'setdiscoverable' - Starts LE advertising or BR/EDR inquiry scanning, making the local interface visible for nearby Bluetooth devices
|
|
46
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::SetDiscoverableParamsData, void>(_T("setdiscoverable"),
|
|
47
|
+
[_implementation__](const JsonData::BluetoothControl::SetDiscoverableParamsData& params) -> uint32_t {
|
|
48
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
49
|
+
|
|
50
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
51
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("setdiscoverable")));
|
|
52
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
53
|
+
}
|
|
54
|
+
else {
|
|
55
|
+
const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
|
|
56
|
+
const Core::OptionalType<Exchange::JSONRPC::IBluetoothControl::scanmode> _mode_{params.Mode};
|
|
57
|
+
const Core::OptionalType<bool> _connectable_{params.Connectable};
|
|
58
|
+
const Core::OptionalType<uint16_t> _duration_{params.Duration};
|
|
59
|
+
|
|
60
|
+
_errorCode__ = _implementation__->SetDiscoverable(_type_, _mode_, _connectable_, _duration_);
|
|
61
|
+
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
return (_errorCode__);
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
// Method: 'stopdiscoverable' - Stops LE advertising or BR/EDR inquiry scanning operation
|
|
68
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::StopDiscoverableParamsInfo, void>(_T("stopdiscoverable"),
|
|
69
|
+
[_implementation__](const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params) -> uint32_t {
|
|
70
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
71
|
+
|
|
72
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
73
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("stopdiscoverable")));
|
|
74
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
75
|
+
}
|
|
76
|
+
else {
|
|
77
|
+
const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
|
|
78
|
+
|
|
79
|
+
_errorCode__ = _implementation__->StopDiscoverable(_type_);
|
|
80
|
+
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
return (_errorCode__);
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
// Method: 'scan' - Starts LE active discovery or BR/EDR inquiry of nearby Bluetooth devices
|
|
87
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ScanParamsData, void>(_T("scan"),
|
|
88
|
+
[_implementation__](const JsonData::BluetoothControl::ScanParamsData& params) -> uint32_t {
|
|
89
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
90
|
+
|
|
91
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
92
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("scan")));
|
|
93
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
94
|
+
}
|
|
95
|
+
else {
|
|
96
|
+
const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
|
|
97
|
+
const Core::OptionalType<Exchange::JSONRPC::IBluetoothControl::scanmode> _mode_{params.Mode};
|
|
98
|
+
const Core::OptionalType<uint16_t> _duration_{params.Duration};
|
|
99
|
+
|
|
100
|
+
_errorCode__ = _implementation__->Scan(_type_, _mode_, _duration_);
|
|
101
|
+
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
return (_errorCode__);
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
// Method: 'stopscanning' - Stops LE discovery or BR/EDR inquiry operation
|
|
108
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::StopDiscoverableParamsInfo, void>(_T("stopscanning"),
|
|
109
|
+
[_implementation__](const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params) -> uint32_t {
|
|
110
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
111
|
+
|
|
112
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
113
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("stopscanning")));
|
|
114
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
115
|
+
}
|
|
116
|
+
else {
|
|
117
|
+
const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
|
|
118
|
+
|
|
119
|
+
_errorCode__ = _implementation__->StopScanning(_type_);
|
|
120
|
+
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
return (_errorCode__);
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
// Method: 'connect' - Connects to a Bluetooth device
|
|
127
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("connect"),
|
|
128
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
|
|
129
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
130
|
+
|
|
131
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
132
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("connect")));
|
|
133
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
134
|
+
}
|
|
135
|
+
else {
|
|
136
|
+
const string _address_{params.Address};
|
|
137
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
138
|
+
|
|
139
|
+
_errorCode__ = _implementation__->Connect(_address_, _type_);
|
|
140
|
+
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
return (_errorCode__);
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
// Method: 'disconnect' - Disconnects from a connected Bluetooth device
|
|
147
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("disconnect"),
|
|
148
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
|
|
149
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
150
|
+
|
|
151
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
152
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("disconnect")));
|
|
153
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
154
|
+
}
|
|
155
|
+
else {
|
|
156
|
+
const string _address_{params.Address};
|
|
157
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
158
|
+
|
|
159
|
+
_errorCode__ = _implementation__->Disconnect(_address_, _type_);
|
|
160
|
+
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
return (_errorCode__);
|
|
164
|
+
});
|
|
165
|
+
|
|
166
|
+
// Method: 'pair' - Pairs a Bluetooth device
|
|
167
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::PairParamsData, void>(_T("pair"),
|
|
168
|
+
[_implementation__](const JsonData::BluetoothControl::PairParamsData& params) -> uint32_t {
|
|
169
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
170
|
+
|
|
171
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
172
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("pair")));
|
|
173
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
174
|
+
}
|
|
175
|
+
else {
|
|
176
|
+
const string _address_{params.Address};
|
|
177
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
178
|
+
const Core::OptionalType<Exchange::JSONRPC::IBluetoothControl::pairingcapabilities> _capabilities_{params.Capabilities};
|
|
179
|
+
const Core::OptionalType<uint16_t> _timeout_{params.Timeout};
|
|
180
|
+
|
|
181
|
+
_errorCode__ = _implementation__->Pair(_address_, _type_, _capabilities_, _timeout_);
|
|
182
|
+
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
return (_errorCode__);
|
|
186
|
+
});
|
|
187
|
+
|
|
188
|
+
// Method: 'unpair' - Unpairs a paired Bluetooth device
|
|
189
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("unpair"),
|
|
190
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
|
|
191
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
192
|
+
|
|
193
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
194
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("unpair")));
|
|
195
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
196
|
+
}
|
|
197
|
+
else {
|
|
198
|
+
const string _address_{params.Address};
|
|
199
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
200
|
+
|
|
201
|
+
_errorCode__ = _implementation__->Unpair(_address_, _type_);
|
|
202
|
+
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
return (_errorCode__);
|
|
206
|
+
});
|
|
207
|
+
|
|
208
|
+
// Method: 'abortpairing' - Aborts pairing operation
|
|
209
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("abortpairing"),
|
|
210
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
|
|
211
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
212
|
+
|
|
213
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
214
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("abortpairing")));
|
|
215
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
216
|
+
}
|
|
217
|
+
else {
|
|
218
|
+
const string _address_{params.Address};
|
|
219
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
220
|
+
|
|
221
|
+
_errorCode__ = _implementation__->AbortPairing(_address_, _type_);
|
|
222
|
+
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
return (_errorCode__);
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
// Method: 'providepincode' - Provides a PIN-code for authentication during a legacy pairing process
|
|
229
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ProvidePINCodeParamsData, void>(_T("providepincode"),
|
|
230
|
+
[_implementation__](const JsonData::BluetoothControl::ProvidePINCodeParamsData& params) -> uint32_t {
|
|
231
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
232
|
+
|
|
233
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
234
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("providepincode")));
|
|
235
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
236
|
+
}
|
|
237
|
+
else {
|
|
238
|
+
const string _address_{params.Address};
|
|
239
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
240
|
+
const string _secret_{params.Secret};
|
|
241
|
+
|
|
242
|
+
_errorCode__ = _implementation__->ProvidePINCode(_address_, _type_, _secret_);
|
|
243
|
+
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
return (_errorCode__);
|
|
247
|
+
});
|
|
248
|
+
|
|
249
|
+
// Method: 'confirmpasskey' - Confirms a passkey for authentication during a BR/EDR SSP pairing processs
|
|
250
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConfirmPasskeyParamsData, void>(_T("confirmpasskey"),
|
|
251
|
+
[_implementation__](const JsonData::BluetoothControl::ConfirmPasskeyParamsData& params) -> uint32_t {
|
|
252
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
253
|
+
|
|
254
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
255
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("confirmpasskey")));
|
|
256
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
257
|
+
}
|
|
258
|
+
else {
|
|
259
|
+
const string _address_{params.Address};
|
|
260
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
261
|
+
const bool _accept_{params.Accept};
|
|
262
|
+
|
|
263
|
+
_errorCode__ = _implementation__->ConfirmPasskey(_address_, _type_, _accept_);
|
|
264
|
+
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
return (_errorCode__);
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
// Method: 'providepasskey' - Provides a passkey for authentication during a pairing process
|
|
271
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ProvidePasskeyParamsInfo, void>(_T("providepasskey"),
|
|
272
|
+
[_implementation__](const JsonData::BluetoothControl::ProvidePasskeyParamsInfo& params) -> uint32_t {
|
|
273
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
274
|
+
|
|
275
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
276
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("providepasskey")));
|
|
277
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
278
|
+
}
|
|
279
|
+
else {
|
|
280
|
+
const string _address_{params.Address};
|
|
281
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
282
|
+
const uint32_t _secret_{params.Secret};
|
|
283
|
+
|
|
284
|
+
_errorCode__ = _implementation__->ProvidePasskey(_address_, _type_, _secret_);
|
|
285
|
+
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
return (_errorCode__);
|
|
289
|
+
});
|
|
290
|
+
|
|
291
|
+
// Method: 'forget' - Forgets a previously seen Bluetooth device
|
|
292
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("forget"),
|
|
293
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
|
|
294
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
295
|
+
|
|
296
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
297
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("forget")));
|
|
298
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
299
|
+
}
|
|
300
|
+
else {
|
|
301
|
+
const string _address_{params.Address};
|
|
302
|
+
const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
303
|
+
|
|
304
|
+
_errorCode__ = _implementation__->Forget(_address_, _type_);
|
|
305
|
+
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
return (_errorCode__);
|
|
309
|
+
});
|
|
310
|
+
|
|
311
|
+
// Method: 'getdevicelist' - Retrieves a list of known remote Bluetooth devices
|
|
312
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::BluetoothControl::DeviceData>>(_T("getdevicelist"),
|
|
313
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::BluetoothControl::DeviceData>& devices) -> uint32_t {
|
|
314
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
315
|
+
|
|
316
|
+
RPC::IIteratorType<Exchange::JSONRPC::IBluetoothControl::device, 0>* _devices_{};
|
|
317
|
+
|
|
318
|
+
_errorCode__ = _implementation__->GetDeviceList(_devices_);
|
|
319
|
+
|
|
320
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
321
|
+
devices.Set(true);
|
|
322
|
+
|
|
323
|
+
if (_devices_ != nullptr) {
|
|
324
|
+
Exchange::JSONRPC::IBluetoothControl::device _resultItem__{};
|
|
325
|
+
while (_devices_->Next(_resultItem__) == true) { devices.Add() = _resultItem__; }
|
|
326
|
+
_devices_->Release();
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
return (_errorCode__);
|
|
331
|
+
});
|
|
332
|
+
|
|
333
|
+
// Method: 'getdeviceinfo' - Retrieves detailed information about a known Bluetooth device
|
|
334
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, JsonData::BluetoothControl::GetDeviceInfoResultData>(_T("getdeviceinfo"),
|
|
335
|
+
[_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params, JsonData::BluetoothControl::GetDeviceInfoResultData& result) -> uint32_t {
|
|
336
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
337
|
+
|
|
338
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
339
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("getdeviceinfo")));
|
|
340
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
341
|
+
}
|
|
342
|
+
else {
|
|
343
|
+
string _address_{params.Address};
|
|
344
|
+
Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
|
|
345
|
+
Core::OptionalType<string> _name_{};
|
|
346
|
+
Core::OptionalType<uint8_t> _version_{};
|
|
347
|
+
Core::OptionalType<uint16_t> _manufacturer_{};
|
|
348
|
+
Core::OptionalType<uint32_t> _cod_{};
|
|
349
|
+
Core::OptionalType<uint16_t> _appearance_{};
|
|
350
|
+
Core::OptionalType<RPC::IIteratorType<string, 0>*> _services_{};
|
|
351
|
+
bool _paired_{};
|
|
352
|
+
bool _connected_{};
|
|
353
|
+
|
|
354
|
+
_errorCode__ = _implementation__->GetDeviceInfo(_address_, _type_, _name_, _version_, _manufacturer_, _cod_, _appearance_, _services_, _paired_, _connected_);
|
|
355
|
+
|
|
356
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
357
|
+
result.Address = _address_;
|
|
358
|
+
result.Type = _type_;
|
|
359
|
+
result.Name = _name_;
|
|
360
|
+
result.Version = _version_;
|
|
361
|
+
result.Manufacturer = _manufacturer_;
|
|
362
|
+
result.Cod = _cod_;
|
|
363
|
+
result.Appearance = _appearance_;
|
|
364
|
+
|
|
365
|
+
if ((_services_.IsSet() == true) && (_services_.Value() != nullptr)) {
|
|
366
|
+
string _servicesItem__{};
|
|
367
|
+
while (_services_.Value()->Next(_servicesItem__) == true) { result.Services.Add() = _servicesItem__; }
|
|
368
|
+
_services_.Value()->Release();
|
|
369
|
+
}
|
|
370
|
+
result.Paired = _paired_;
|
|
371
|
+
result.Connected = _connected_;
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
return (_errorCode__);
|
|
376
|
+
});
|
|
377
|
+
|
|
378
|
+
// Property: 'adapters' - List of local Bluetooth adapters (r/o)
|
|
379
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::DecUInt8>>(_T("adapters"),
|
|
380
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::DecUInt8>& result) -> uint32_t {
|
|
381
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
382
|
+
|
|
383
|
+
RPC::IIteratorType<uint8_t, 0>* _result_{};
|
|
384
|
+
|
|
385
|
+
_errorCode__ = _implementation__->Adapters(_result_);
|
|
386
|
+
|
|
387
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
388
|
+
result.Set(true);
|
|
389
|
+
|
|
390
|
+
if (_result_ != nullptr) {
|
|
391
|
+
uint8_t _resultItem__{};
|
|
392
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
393
|
+
_result_->Release();
|
|
394
|
+
}
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
return (_errorCode__);
|
|
398
|
+
});
|
|
399
|
+
|
|
400
|
+
// Indexed Property: 'adapter' - Local Bluetooth adapter information (r/o)
|
|
401
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothControl::AdapterinfoData, std::function<uint32_t(const string&, JsonData::BluetoothControl::AdapterinfoData&)>>(_T("adapter"),
|
|
402
|
+
[_implementation__](const string& adapter, JsonData::BluetoothControl::AdapterinfoData& result) -> uint32_t {
|
|
403
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
404
|
+
|
|
405
|
+
uint8_t _adapterConv__{};
|
|
406
|
+
|
|
407
|
+
if (adapter.empty() == true) {
|
|
408
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("adapter")));
|
|
409
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
410
|
+
}
|
|
411
|
+
else {
|
|
412
|
+
const bool _adapterConvResult__ = Core::FromString(adapter, _adapterConv__);
|
|
413
|
+
|
|
414
|
+
if (_adapterConvResult__ == false) {
|
|
415
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("adapter")));
|
|
416
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
417
|
+
}
|
|
418
|
+
}
|
|
419
|
+
|
|
420
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
421
|
+
Exchange::JSONRPC::IBluetoothControl::adapterinfo _result_{};
|
|
422
|
+
|
|
423
|
+
_errorCode__ = _implementation__->Adapter(_adapterConv__, _result_);
|
|
424
|
+
|
|
425
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
426
|
+
result.Set(true);
|
|
427
|
+
result = _result_;
|
|
428
|
+
}
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
return (_errorCode__);
|
|
432
|
+
});
|
|
433
|
+
|
|
434
|
+
// Property: 'devices' - List of known remote Bluetooth LE devices (DEPRECATED) (r/o)
|
|
435
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("devices"),
|
|
436
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
437
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
438
|
+
|
|
439
|
+
RPC::IIteratorType<string, 0>* _result_{};
|
|
440
|
+
|
|
441
|
+
_errorCode__ = _implementation__->Devices(_result_);
|
|
442
|
+
|
|
443
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
444
|
+
result.Set(true);
|
|
445
|
+
|
|
446
|
+
if (_result_ != nullptr) {
|
|
447
|
+
string _resultItem__{};
|
|
448
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
449
|
+
_result_->Release();
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
|
|
453
|
+
return (_errorCode__);
|
|
454
|
+
});
|
|
455
|
+
|
|
456
|
+
// Indexed Property: 'device' - Remote Bluetooth LE device information (DEPRECATED) (r/o)
|
|
457
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothControl::DeviceinfoData, std::function<uint32_t(const string&, JsonData::BluetoothControl::DeviceinfoData&)>>(_T("device"),
|
|
458
|
+
[_implementation__](const string& deviceAddress, JsonData::BluetoothControl::DeviceinfoData& result) -> uint32_t {
|
|
459
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
460
|
+
|
|
461
|
+
if (deviceAddress.empty() == true) {
|
|
462
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("device")));
|
|
463
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
467
|
+
Exchange::JSONRPC::IBluetoothControl::deviceinfo _result_{};
|
|
468
|
+
|
|
469
|
+
_errorCode__ = _implementation__->Device(deviceAddress, _result_);
|
|
470
|
+
|
|
471
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
472
|
+
result.Set(true);
|
|
473
|
+
result = _result_;
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
return (_errorCode__);
|
|
478
|
+
});
|
|
479
|
+
|
|
480
|
+
// Register event status listeners...
|
|
481
|
+
|
|
482
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("discoverablestarted"),
|
|
483
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
484
|
+
_handler_->OnDiscoverableStartedEventRegistration(client_, status_);
|
|
485
|
+
});
|
|
486
|
+
|
|
487
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("scanstarted"),
|
|
488
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
489
|
+
_handler_->OnScanStartedEventRegistration(client_, status_);
|
|
490
|
+
});
|
|
491
|
+
|
|
492
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("devicestatechanged"),
|
|
493
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
494
|
+
_handler_->OnDeviceStateChangedEventRegistration(client_, status_);
|
|
495
|
+
});
|
|
496
|
+
|
|
497
|
+
}
|
|
498
|
+
|
|
499
|
+
template<typename MODULE>
|
|
500
|
+
static void Unregister(MODULE& _module__)
|
|
501
|
+
{
|
|
502
|
+
// Unregister methods and properties...
|
|
503
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setdiscoverable"));
|
|
504
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("stopdiscoverable"));
|
|
505
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("scan"));
|
|
506
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("stopscanning"));
|
|
507
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("connect"));
|
|
508
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("disconnect"));
|
|
509
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("pair"));
|
|
510
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unpair"));
|
|
511
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("abortpairing"));
|
|
512
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("providepincode"));
|
|
513
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("confirmpasskey"));
|
|
514
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("providepasskey"));
|
|
515
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("forget"));
|
|
516
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getdevicelist"));
|
|
517
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getdeviceinfo"));
|
|
518
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("adapters"));
|
|
519
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("adapter"));
|
|
520
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("devices"));
|
|
521
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device"));
|
|
522
|
+
|
|
523
|
+
// Unregister event status listeners...
|
|
524
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("discoverablestarted"));
|
|
525
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("scanstarted"));
|
|
526
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("devicestatechanged"));
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
namespace Event {
|
|
530
|
+
|
|
531
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
532
|
+
template<typename MODULE>
|
|
533
|
+
static void DiscoverableStarted(const MODULE& module_, const JsonData::BluetoothControl::DiscoverableStartedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
534
|
+
{
|
|
535
|
+
module_.Notify(_T("discoverablestarted"), params, sendIfMethod_);
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
539
|
+
template<typename MODULE>
|
|
540
|
+
static void DiscoverableStarted(const MODULE& module_, const JsonData::BluetoothControl::DiscoverableStartedParamsData& params, const string& client_)
|
|
541
|
+
{
|
|
542
|
+
module_.Notify(_T("discoverablestarted"), params, [&client_](const string& designator_) -> bool {
|
|
543
|
+
return ((client_ == designator_));
|
|
544
|
+
});
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
548
|
+
template<typename MODULE>
|
|
549
|
+
static void DiscoverableStarted(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode>& mode, const Core::JSON::Boolean& connectable, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
550
|
+
{
|
|
551
|
+
JsonData::BluetoothControl::DiscoverableStartedParamsData params_;
|
|
552
|
+
params_.Type = type;
|
|
553
|
+
params_.Mode = mode;
|
|
554
|
+
params_.Connectable = connectable;
|
|
555
|
+
|
|
556
|
+
DiscoverableStarted(module_, params_, sendIfMethod_);
|
|
557
|
+
}
|
|
558
|
+
|
|
559
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
560
|
+
template<typename MODULE>
|
|
561
|
+
static void DiscoverableStarted(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode>& mode, const Core::JSON::Boolean& connectable, const string& client_)
|
|
562
|
+
{
|
|
563
|
+
JsonData::BluetoothControl::DiscoverableStartedParamsData params_;
|
|
564
|
+
params_.Type = type;
|
|
565
|
+
params_.Mode = mode;
|
|
566
|
+
params_.Connectable = connectable;
|
|
567
|
+
|
|
568
|
+
DiscoverableStarted(module_, params_, client_);
|
|
569
|
+
}
|
|
570
|
+
|
|
571
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
572
|
+
template<typename MODULE>
|
|
573
|
+
static void DiscoverableStarted(const MODULE& module_, const IBluetoothControl::scantype type, const IBluetoothControl::scanmode mode, const Core::OptionalType<bool>& connectable, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
574
|
+
{
|
|
575
|
+
JsonData::BluetoothControl::DiscoverableStartedParamsData params_;
|
|
576
|
+
params_.Type = type;
|
|
577
|
+
params_.Mode = mode;
|
|
578
|
+
|
|
579
|
+
if (connectable.IsSet() == true) {
|
|
580
|
+
params_.Connectable = connectable.Value();
|
|
581
|
+
}
|
|
582
|
+
|
|
583
|
+
DiscoverableStarted(module_, params_, sendIfMethod_);
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
// Event: 'discoverablestarted' - Reports entering the discoverable state
|
|
587
|
+
template<typename MODULE>
|
|
588
|
+
static void DiscoverableStarted(const MODULE& module_, const IBluetoothControl::scantype type, const IBluetoothControl::scanmode mode, const Core::OptionalType<bool>& connectable, const string& client_)
|
|
589
|
+
{
|
|
590
|
+
JsonData::BluetoothControl::DiscoverableStartedParamsData params_;
|
|
591
|
+
params_.Type = type;
|
|
592
|
+
params_.Mode = mode;
|
|
593
|
+
|
|
594
|
+
if (connectable.IsSet() == true) {
|
|
595
|
+
params_.Connectable = connectable.Value();
|
|
596
|
+
}
|
|
597
|
+
|
|
598
|
+
DiscoverableStarted(module_, params_, client_);
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
// Event: 'discoverablecomplete' - Reports leaving the discoverable state
|
|
602
|
+
template<typename MODULE>
|
|
603
|
+
static void DiscoverableComplete(const MODULE& module_, const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
604
|
+
{
|
|
605
|
+
module_.Notify(_T("discoverablecomplete"), params, sendIfMethod_);
|
|
606
|
+
}
|
|
607
|
+
|
|
608
|
+
// Event: 'discoverablecomplete' - Reports leaving the discoverable state
|
|
609
|
+
template<typename MODULE>
|
|
610
|
+
static void DiscoverableComplete(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
611
|
+
{
|
|
612
|
+
JsonData::BluetoothControl::StopDiscoverableParamsInfo params_;
|
|
613
|
+
params_.Type = type;
|
|
614
|
+
|
|
615
|
+
DiscoverableComplete(module_, params_, sendIfMethod_);
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
// Event: 'discoverablecomplete' - Reports leaving the discoverable state
|
|
619
|
+
template<typename MODULE>
|
|
620
|
+
static void DiscoverableComplete(const MODULE& module_, const IBluetoothControl::scantype type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
621
|
+
{
|
|
622
|
+
JsonData::BluetoothControl::StopDiscoverableParamsInfo params_;
|
|
623
|
+
params_.Type = type;
|
|
624
|
+
|
|
625
|
+
DiscoverableComplete(module_, params_, sendIfMethod_);
|
|
626
|
+
}
|
|
627
|
+
|
|
628
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
629
|
+
template<typename MODULE>
|
|
630
|
+
static void ScanStarted(const MODULE& module_, const JsonData::BluetoothControl::ScanStartedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
631
|
+
{
|
|
632
|
+
module_.Notify(_T("scanstarted"), params, sendIfMethod_);
|
|
633
|
+
}
|
|
634
|
+
|
|
635
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
636
|
+
template<typename MODULE>
|
|
637
|
+
static void ScanStarted(const MODULE& module_, const JsonData::BluetoothControl::ScanStartedParamsData& params, const string& client_)
|
|
638
|
+
{
|
|
639
|
+
module_.Notify(_T("scanstarted"), params, [&client_](const string& designator_) -> bool {
|
|
640
|
+
return ((client_ == designator_));
|
|
641
|
+
});
|
|
642
|
+
}
|
|
643
|
+
|
|
644
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
645
|
+
template<typename MODULE>
|
|
646
|
+
static void ScanStarted(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode>& mode, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
647
|
+
{
|
|
648
|
+
JsonData::BluetoothControl::ScanStartedParamsData params_;
|
|
649
|
+
params_.Type = type;
|
|
650
|
+
params_.Mode = mode;
|
|
651
|
+
|
|
652
|
+
ScanStarted(module_, params_, sendIfMethod_);
|
|
653
|
+
}
|
|
654
|
+
|
|
655
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
656
|
+
template<typename MODULE>
|
|
657
|
+
static void ScanStarted(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode>& mode, const string& client_)
|
|
658
|
+
{
|
|
659
|
+
JsonData::BluetoothControl::ScanStartedParamsData params_;
|
|
660
|
+
params_.Type = type;
|
|
661
|
+
params_.Mode = mode;
|
|
662
|
+
|
|
663
|
+
ScanStarted(module_, params_, client_);
|
|
664
|
+
}
|
|
665
|
+
|
|
666
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
667
|
+
template<typename MODULE>
|
|
668
|
+
static void ScanStarted(const MODULE& module_, const IBluetoothControl::scantype type, const IBluetoothControl::scanmode mode, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
669
|
+
{
|
|
670
|
+
JsonData::BluetoothControl::ScanStartedParamsData params_;
|
|
671
|
+
params_.Type = type;
|
|
672
|
+
params_.Mode = mode;
|
|
673
|
+
|
|
674
|
+
ScanStarted(module_, params_, sendIfMethod_);
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
// Event: 'scanstarted' - Reports start of scanning
|
|
678
|
+
template<typename MODULE>
|
|
679
|
+
static void ScanStarted(const MODULE& module_, const IBluetoothControl::scantype type, const IBluetoothControl::scanmode mode, const string& client_)
|
|
680
|
+
{
|
|
681
|
+
JsonData::BluetoothControl::ScanStartedParamsData params_;
|
|
682
|
+
params_.Type = type;
|
|
683
|
+
params_.Mode = mode;
|
|
684
|
+
|
|
685
|
+
ScanStarted(module_, params_, client_);
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
// Event: 'scancomplete' - Reports end of scanning
|
|
689
|
+
template<typename MODULE>
|
|
690
|
+
static void ScanComplete(const MODULE& module_, const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
691
|
+
{
|
|
692
|
+
module_.Notify(_T("scancomplete"), params, sendIfMethod_);
|
|
693
|
+
}
|
|
694
|
+
|
|
695
|
+
// Event: 'scancomplete' - Reports end of scanning
|
|
696
|
+
template<typename MODULE>
|
|
697
|
+
static void ScanComplete(const MODULE& module_, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype>& type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
698
|
+
{
|
|
699
|
+
JsonData::BluetoothControl::StopDiscoverableParamsInfo params_;
|
|
700
|
+
params_.Type = type;
|
|
701
|
+
|
|
702
|
+
ScanComplete(module_, params_, sendIfMethod_);
|
|
703
|
+
}
|
|
704
|
+
|
|
705
|
+
// Event: 'scancomplete' - Reports end of scanning
|
|
706
|
+
template<typename MODULE>
|
|
707
|
+
static void ScanComplete(const MODULE& module_, const IBluetoothControl::scantype type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
708
|
+
{
|
|
709
|
+
JsonData::BluetoothControl::StopDiscoverableParamsInfo params_;
|
|
710
|
+
params_.Type = type;
|
|
711
|
+
|
|
712
|
+
ScanComplete(module_, params_, sendIfMethod_);
|
|
713
|
+
}
|
|
714
|
+
|
|
715
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
716
|
+
template<typename MODULE>
|
|
717
|
+
static void DeviceStateChanged(const MODULE& module_, const JsonData::BluetoothControl::DeviceStateChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
718
|
+
{
|
|
719
|
+
module_.Notify(_T("devicestatechanged"), params, sendIfMethod_);
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
723
|
+
template<typename MODULE>
|
|
724
|
+
static void DeviceStateChanged(const MODULE& module_, const JsonData::BluetoothControl::DeviceStateChangedParamsData& params, const string& client_)
|
|
725
|
+
{
|
|
726
|
+
module_.Notify(_T("devicestatechanged"), params, [&client_](const string& designator_) -> bool {
|
|
727
|
+
return ((client_ == designator_));
|
|
728
|
+
});
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
732
|
+
template<typename MODULE>
|
|
733
|
+
static void DeviceStateChanged(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicestate>& state, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::disconnectreason>& disconnectReason, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
734
|
+
{
|
|
735
|
+
JsonData::BluetoothControl::DeviceStateChangedParamsData params_;
|
|
736
|
+
params_.Address = address;
|
|
737
|
+
params_.Type = type;
|
|
738
|
+
params_.State = state;
|
|
739
|
+
params_.DisconnectReason = disconnectReason;
|
|
740
|
+
|
|
741
|
+
DeviceStateChanged(module_, params_, sendIfMethod_);
|
|
742
|
+
}
|
|
743
|
+
|
|
744
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
745
|
+
template<typename MODULE>
|
|
746
|
+
static void DeviceStateChanged(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicestate>& state, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::disconnectreason>& disconnectReason, const string& client_)
|
|
747
|
+
{
|
|
748
|
+
JsonData::BluetoothControl::DeviceStateChangedParamsData params_;
|
|
749
|
+
params_.Address = address;
|
|
750
|
+
params_.Type = type;
|
|
751
|
+
params_.State = state;
|
|
752
|
+
params_.DisconnectReason = disconnectReason;
|
|
753
|
+
|
|
754
|
+
DeviceStateChanged(module_, params_, client_);
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
758
|
+
template<typename MODULE>
|
|
759
|
+
static void DeviceStateChanged(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, const IBluetoothControl::devicestate state, const Core::OptionalType<IBluetoothControl::disconnectreason>& disconnectReason, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
760
|
+
{
|
|
761
|
+
JsonData::BluetoothControl::DeviceStateChangedParamsData params_;
|
|
762
|
+
params_.Address = address;
|
|
763
|
+
params_.Type = type;
|
|
764
|
+
params_.State = state;
|
|
765
|
+
|
|
766
|
+
if (disconnectReason.IsSet() == true) {
|
|
767
|
+
params_.DisconnectReason = disconnectReason.Value();
|
|
768
|
+
}
|
|
769
|
+
|
|
770
|
+
DeviceStateChanged(module_, params_, sendIfMethod_);
|
|
771
|
+
}
|
|
772
|
+
|
|
773
|
+
// Event: 'devicestatechanged' - disconnectReason If disconnected specifies the cause of disconnection
|
|
774
|
+
template<typename MODULE>
|
|
775
|
+
static void DeviceStateChanged(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, const IBluetoothControl::devicestate state, const Core::OptionalType<IBluetoothControl::disconnectreason>& disconnectReason, const string& client_)
|
|
776
|
+
{
|
|
777
|
+
JsonData::BluetoothControl::DeviceStateChangedParamsData params_;
|
|
778
|
+
params_.Address = address;
|
|
779
|
+
params_.Type = type;
|
|
780
|
+
params_.State = state;
|
|
781
|
+
|
|
782
|
+
if (disconnectReason.IsSet() == true) {
|
|
783
|
+
params_.DisconnectReason = disconnectReason.Value();
|
|
784
|
+
}
|
|
785
|
+
|
|
786
|
+
DeviceStateChanged(module_, params_, client_);
|
|
787
|
+
}
|
|
788
|
+
|
|
789
|
+
// Event: 'pincoderequest' - Notifies of a PIN code request during authenticated BR/EDR legacy pairing process
|
|
790
|
+
template<typename MODULE>
|
|
791
|
+
static void PINCodeRequest(const MODULE& module_, const JsonData::BluetoothControl::ConnectParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
792
|
+
{
|
|
793
|
+
module_.Notify(_T("pincoderequest"), params, sendIfMethod_);
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
// Event: 'pincoderequest' - Notifies of a PIN code request during authenticated BR/EDR legacy pairing process
|
|
797
|
+
template<typename MODULE>
|
|
798
|
+
static void PINCodeRequest(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
799
|
+
{
|
|
800
|
+
JsonData::BluetoothControl::ConnectParamsInfo params_;
|
|
801
|
+
params_.Address = address;
|
|
802
|
+
params_.Type = type;
|
|
803
|
+
|
|
804
|
+
PINCodeRequest(module_, params_, sendIfMethod_);
|
|
805
|
+
}
|
|
806
|
+
|
|
807
|
+
// Event: 'pincoderequest' - Notifies of a PIN code request during authenticated BR/EDR legacy pairing process
|
|
808
|
+
template<typename MODULE>
|
|
809
|
+
static void PINCodeRequest(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
810
|
+
{
|
|
811
|
+
JsonData::BluetoothControl::ConnectParamsInfo params_;
|
|
812
|
+
params_.Address = address;
|
|
813
|
+
params_.Type = type;
|
|
814
|
+
|
|
815
|
+
PINCodeRequest(module_, params_, sendIfMethod_);
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
// Event: 'passkeyconfirmrequest' - Notifies of a user confirmation request during authenticated BR/EDR SSP pairing process
|
|
819
|
+
template<typename MODULE>
|
|
820
|
+
static void PasskeyConfirmRequest(const MODULE& module_, const JsonData::BluetoothControl::PasskeyConfirmRequestParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
821
|
+
{
|
|
822
|
+
module_.Notify(_T("passkeyconfirmrequest"), params, sendIfMethod_);
|
|
823
|
+
}
|
|
824
|
+
|
|
825
|
+
// Event: 'passkeyconfirmrequest' - Notifies of a user confirmation request during authenticated BR/EDR SSP pairing process
|
|
826
|
+
template<typename MODULE>
|
|
827
|
+
static void PasskeyConfirmRequest(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, const Core::JSON::DecUInt32& secret, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
828
|
+
{
|
|
829
|
+
JsonData::BluetoothControl::PasskeyConfirmRequestParamsData params_;
|
|
830
|
+
params_.Address = address;
|
|
831
|
+
params_.Type = type;
|
|
832
|
+
params_.Secret = secret;
|
|
833
|
+
|
|
834
|
+
PasskeyConfirmRequest(module_, params_, sendIfMethod_);
|
|
835
|
+
}
|
|
836
|
+
|
|
837
|
+
// Event: 'passkeyconfirmrequest' - Notifies of a user confirmation request during authenticated BR/EDR SSP pairing process
|
|
838
|
+
template<typename MODULE>
|
|
839
|
+
static void PasskeyConfirmRequest(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, const Core::OptionalType<uint32_t>& secret, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
840
|
+
{
|
|
841
|
+
JsonData::BluetoothControl::PasskeyConfirmRequestParamsData params_;
|
|
842
|
+
params_.Address = address;
|
|
843
|
+
params_.Type = type;
|
|
844
|
+
|
|
845
|
+
if (secret.IsSet() == true) {
|
|
846
|
+
params_.Secret = secret.Value();
|
|
847
|
+
}
|
|
848
|
+
|
|
849
|
+
PasskeyConfirmRequest(module_, params_, sendIfMethod_);
|
|
850
|
+
}
|
|
851
|
+
|
|
852
|
+
// Event: 'passkeyrequest' - Notifies of a passkey supply request during authenticated LE pairing process
|
|
853
|
+
template<typename MODULE>
|
|
854
|
+
static void PasskeyRequest(const MODULE& module_, const JsonData::BluetoothControl::ConnectParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
855
|
+
{
|
|
856
|
+
module_.Notify(_T("passkeyrequest"), params, sendIfMethod_);
|
|
857
|
+
}
|
|
858
|
+
|
|
859
|
+
// Event: 'passkeyrequest' - Notifies of a passkey supply request during authenticated LE pairing process
|
|
860
|
+
template<typename MODULE>
|
|
861
|
+
static void PasskeyRequest(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
862
|
+
{
|
|
863
|
+
JsonData::BluetoothControl::ConnectParamsInfo params_;
|
|
864
|
+
params_.Address = address;
|
|
865
|
+
params_.Type = type;
|
|
866
|
+
|
|
867
|
+
PasskeyRequest(module_, params_, sendIfMethod_);
|
|
868
|
+
}
|
|
869
|
+
|
|
870
|
+
// Event: 'passkeyrequest' - Notifies of a passkey supply request during authenticated LE pairing process
|
|
871
|
+
template<typename MODULE>
|
|
872
|
+
static void PasskeyRequest(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
873
|
+
{
|
|
874
|
+
JsonData::BluetoothControl::ConnectParamsInfo params_;
|
|
875
|
+
params_.Address = address;
|
|
876
|
+
params_.Type = type;
|
|
877
|
+
|
|
878
|
+
PasskeyRequest(module_, params_, sendIfMethod_);
|
|
879
|
+
}
|
|
880
|
+
|
|
881
|
+
// Event: 'passkeydisplayrequest' - Notifies of a passkey presentation request during authenticated LE pairing process
|
|
882
|
+
template<typename MODULE>
|
|
883
|
+
static void PasskeyDisplayRequest(const MODULE& module_, const JsonData::BluetoothControl::ProvidePasskeyParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
884
|
+
{
|
|
885
|
+
module_.Notify(_T("passkeydisplayrequest"), params, sendIfMethod_);
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
// Event: 'passkeydisplayrequest' - Notifies of a passkey presentation request during authenticated LE pairing process
|
|
889
|
+
template<typename MODULE>
|
|
890
|
+
static void PasskeyDisplayRequest(const MODULE& module_, const Core::JSON::String& address, const Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype>& type, const Core::JSON::DecUInt32& secret, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
891
|
+
{
|
|
892
|
+
JsonData::BluetoothControl::ProvidePasskeyParamsInfo params_;
|
|
893
|
+
params_.Address = address;
|
|
894
|
+
params_.Type = type;
|
|
895
|
+
params_.Secret = secret;
|
|
896
|
+
|
|
897
|
+
PasskeyDisplayRequest(module_, params_, sendIfMethod_);
|
|
898
|
+
}
|
|
899
|
+
|
|
900
|
+
// Event: 'passkeydisplayrequest' - Notifies of a passkey presentation request during authenticated LE pairing process
|
|
901
|
+
template<typename MODULE>
|
|
902
|
+
static void PasskeyDisplayRequest(const MODULE& module_, const string& address, const IBluetoothControl::devicetype type, const uint32_t secret, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
903
|
+
{
|
|
904
|
+
JsonData::BluetoothControl::ProvidePasskeyParamsInfo params_;
|
|
905
|
+
params_.Address = address;
|
|
906
|
+
params_.Type = type;
|
|
907
|
+
params_.Secret = secret;
|
|
908
|
+
|
|
909
|
+
PasskeyDisplayRequest(module_, params_, sendIfMethod_);
|
|
910
|
+
}
|
|
911
|
+
|
|
912
|
+
} // namespace Event
|
|
913
|
+
|
|
914
|
+
POP_WARNING()
|
|
915
|
+
POP_WARNING()
|
|
916
|
+
POP_WARNING()
|
|
917
|
+
|
|
918
|
+
} // namespace JBluetoothControl
|
|
919
|
+
|
|
920
|
+
} // namespace JSONRPC
|
|
921
|
+
|
|
922
|
+
} // namespace Exchange
|
|
923
|
+
|
|
924
|
+
} // namespace Thunder
|
|
925
|
+
|
|
@@ -0,0 +1,251 @@
|
|
|
1
|
+
// Generated automatically from 'IBluetoothRemoteControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BluetoothRemoteControl.h"
|
|
6
|
+
#include <interfaces/IBluetoothRemoteControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JBluetoothRemoteControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
struct IHandler {
|
|
23
|
+
virtual ~IHandler() = default;
|
|
24
|
+
virtual void OnBatteryLevelChangeEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
28
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
29
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
30
|
+
|
|
31
|
+
template<typename MODULE>
|
|
32
|
+
static void Register(MODULE& _module__, IBluetoothRemoteControl* _implementation__, IHandler* _handler_)
|
|
33
|
+
{
|
|
34
|
+
ASSERT(_implementation__ != nullptr);
|
|
35
|
+
ASSERT(_handler_ != nullptr);
|
|
36
|
+
|
|
37
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBluetoothRemoteControl"), Version::Major, Version::Minor, Version::Patch);
|
|
38
|
+
|
|
39
|
+
// Register methods and properties...
|
|
40
|
+
|
|
41
|
+
// Method: 'assign' - Assigns a Bluetooth device as a RCU
|
|
42
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothRemoteControl::AssignParamsData, void>(_T("assign"),
|
|
43
|
+
[_implementation__](const JsonData::BluetoothRemoteControl::AssignParamsData& params) -> uint32_t {
|
|
44
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
45
|
+
|
|
46
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
47
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothRemoteControl"), _T("assign")));
|
|
48
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
49
|
+
}
|
|
50
|
+
else {
|
|
51
|
+
const string _address_{params.Address};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->Assign(_address_);
|
|
54
|
+
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return (_errorCode__);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
// Method: 'revoke' - Revokes a Bluetooth device from RCU operation
|
|
61
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("revoke"),
|
|
62
|
+
[_implementation__]() -> uint32_t {
|
|
63
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
64
|
+
|
|
65
|
+
_errorCode__ = _implementation__->Revoke();
|
|
66
|
+
|
|
67
|
+
return (_errorCode__);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
// Property: 'device' - Bluetooth address (r/o)
|
|
71
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("device"),
|
|
72
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
73
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
74
|
+
|
|
75
|
+
string _result_{};
|
|
76
|
+
|
|
77
|
+
_errorCode__ = _implementation__->Device(_result_);
|
|
78
|
+
|
|
79
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
80
|
+
result = _result_;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
return (_errorCode__);
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
_module__.PluginHost::JSONRPC::Register(_T("address"), _T("device"));
|
|
87
|
+
|
|
88
|
+
// Property: 'metadata' - Device metadata (r/o)
|
|
89
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::BluetoothRemoteControl::UnitmetadataData>(_T("metadata"),
|
|
90
|
+
[_implementation__](JsonData::BluetoothRemoteControl::UnitmetadataData& result) -> uint32_t {
|
|
91
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
92
|
+
|
|
93
|
+
Exchange::IBluetoothRemoteControl::unitmetadata _result_{};
|
|
94
|
+
|
|
95
|
+
_errorCode__ = _implementation__->Metadata(_result_);
|
|
96
|
+
|
|
97
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
98
|
+
result.Set(true);
|
|
99
|
+
result = _result_;
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
return (_errorCode__);
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
_module__.PluginHost::JSONRPC::Register(_T("info"), _T("metadata"));
|
|
106
|
+
|
|
107
|
+
// Property: 'batterylevel' - Battery level (r/o)
|
|
108
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt8>(_T("batterylevel"),
|
|
109
|
+
[_implementation__](Core::JSON::DecUInt8& result) -> uint32_t {
|
|
110
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
111
|
+
|
|
112
|
+
uint8_t _result_{};
|
|
113
|
+
|
|
114
|
+
_errorCode__ = _implementation__->BatteryLevel(_result_);
|
|
115
|
+
|
|
116
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
117
|
+
result = _result_;
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
return (_errorCode__);
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
// Property: 'voicecontrol' - Toggle voice control
|
|
124
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothRemoteControl::VoiceControlData, Core::JSON::Boolean>(_T("voicecontrol"),
|
|
125
|
+
[_implementation__](const JsonData::BluetoothRemoteControl::VoiceControlData& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
126
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
127
|
+
|
|
128
|
+
if (params.IsSet() == false) {
|
|
129
|
+
bool _result_{};
|
|
130
|
+
|
|
131
|
+
_errorCode__ = (static_cast<const IBluetoothRemoteControl*>(_implementation__))->VoiceControl(_result_);
|
|
132
|
+
|
|
133
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
134
|
+
result = _result_;
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
else {
|
|
138
|
+
|
|
139
|
+
if (params.IsDataValid() == false) {
|
|
140
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothRemoteControl"), _T("voicecontrol")));
|
|
141
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
142
|
+
}
|
|
143
|
+
else {
|
|
144
|
+
const bool _value_{params.Value};
|
|
145
|
+
|
|
146
|
+
_errorCode__ = _implementation__->VoiceControl(_value_);
|
|
147
|
+
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
result.Null(true);
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
return (_errorCode__);
|
|
154
|
+
});
|
|
155
|
+
|
|
156
|
+
// Register event status listeners...
|
|
157
|
+
|
|
158
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("batterylevelchange"),
|
|
159
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
160
|
+
_handler_->OnBatteryLevelChangeEventRegistration(client_, status_);
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
template<typename MODULE>
|
|
166
|
+
static void Unregister(MODULE& _module__)
|
|
167
|
+
{
|
|
168
|
+
// Unregister methods and properties...
|
|
169
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("assign"));
|
|
170
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("revoke"));
|
|
171
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device"));
|
|
172
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("address"));
|
|
173
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("metadata"));
|
|
174
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("info"));
|
|
175
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("batterylevel"));
|
|
176
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("voicecontrol"));
|
|
177
|
+
|
|
178
|
+
// Unregister event status listeners...
|
|
179
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("batterylevelchange"));
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
namespace Event {
|
|
183
|
+
|
|
184
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
185
|
+
template<typename MODULE>
|
|
186
|
+
static void BatteryLevelChange(const MODULE& module_, const JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
187
|
+
{
|
|
188
|
+
module_.Notify(_T("batterylevelchange"), params, sendIfMethod_);
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
192
|
+
template<typename MODULE>
|
|
193
|
+
static void BatteryLevelChange(const MODULE& module_, const JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData& params, const string& client_)
|
|
194
|
+
{
|
|
195
|
+
module_.Notify(_T("batterylevelchange"), params, [&client_](const string& designator_) -> bool {
|
|
196
|
+
return ((client_ == designator_));
|
|
197
|
+
});
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
201
|
+
template<typename MODULE>
|
|
202
|
+
static void BatteryLevelChange(const MODULE& module_, const Core::JSON::DecUInt8& level, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
203
|
+
{
|
|
204
|
+
JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData params_;
|
|
205
|
+
params_.Level = level;
|
|
206
|
+
|
|
207
|
+
BatteryLevelChange(module_, params_, sendIfMethod_);
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
211
|
+
template<typename MODULE>
|
|
212
|
+
static void BatteryLevelChange(const MODULE& module_, const Core::JSON::DecUInt8& level, const string& client_)
|
|
213
|
+
{
|
|
214
|
+
JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData params_;
|
|
215
|
+
params_.Level = level;
|
|
216
|
+
|
|
217
|
+
BatteryLevelChange(module_, params_, client_);
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
221
|
+
template<typename MODULE>
|
|
222
|
+
static void BatteryLevelChange(const MODULE& module_, const uint8_t level, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
223
|
+
{
|
|
224
|
+
JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData params_;
|
|
225
|
+
params_.Level = level;
|
|
226
|
+
|
|
227
|
+
BatteryLevelChange(module_, params_, sendIfMethod_);
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
// Event: 'batterylevelchange' - Signals battery level change
|
|
231
|
+
template<typename MODULE>
|
|
232
|
+
static void BatteryLevelChange(const MODULE& module_, const uint8_t level, const string& client_)
|
|
233
|
+
{
|
|
234
|
+
JsonData::BluetoothRemoteControl::BatteryLevelChangeParamsData params_;
|
|
235
|
+
params_.Level = level;
|
|
236
|
+
|
|
237
|
+
BatteryLevelChange(module_, params_, client_);
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
} // namespace Event
|
|
241
|
+
|
|
242
|
+
POP_WARNING()
|
|
243
|
+
POP_WARNING()
|
|
244
|
+
POP_WARNING()
|
|
245
|
+
|
|
246
|
+
} // namespace JBluetoothRemoteControl
|
|
247
|
+
|
|
248
|
+
} // namespace Exchange
|
|
249
|
+
|
|
250
|
+
} // namespace Thunder
|
|
251
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Browser.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Browser.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JBrowser {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JBrowser
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BrowserCookieJar.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JBrowserCookieJar {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IBrowserCookieJar* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBrowserCookieJar"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'cookiejar' - Get/Set CookieJar config details
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BrowserCookieJar::ConfigData, JsonData::BrowserCookieJar::ConfigData>(_T("cookiejar"),
|
|
37
|
+
[_implementation__](const JsonData::BrowserCookieJar::ConfigData& params, JsonData::BrowserCookieJar::ConfigData& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (params.IsSet() == false) {
|
|
41
|
+
Exchange::IBrowserCookieJar::Config _result_{};
|
|
42
|
+
|
|
43
|
+
_errorCode__ = (static_cast<const IBrowserCookieJar*>(_implementation__))->CookieJar(_result_);
|
|
44
|
+
|
|
45
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
46
|
+
result.Set(true);
|
|
47
|
+
result = _result_;
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
else {
|
|
51
|
+
|
|
52
|
+
if (params.IsDataValid() == false) {
|
|
53
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserCookieJar"), _T("cookiejar")));
|
|
54
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
55
|
+
}
|
|
56
|
+
else {
|
|
57
|
+
const Exchange::IBrowserCookieJar::Config _params_(params);
|
|
58
|
+
|
|
59
|
+
_errorCode__ = _implementation__->CookieJar(_params_);
|
|
60
|
+
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
result.Null(true);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
return (_errorCode__);
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void Unregister(MODULE& _module__)
|
|
73
|
+
{
|
|
74
|
+
// Unregister methods and properties...
|
|
75
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("cookiejar"));
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
namespace Event {
|
|
79
|
+
|
|
80
|
+
// Event: 'cookiejarchanged' - Notifies that cookies were added, removed or modified
|
|
81
|
+
template<typename MODULE>
|
|
82
|
+
static void CookieJarChanged(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
83
|
+
{
|
|
84
|
+
module_.Notify(_T("cookiejarchanged"), sendIfMethod_);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
} // namespace Event
|
|
88
|
+
|
|
89
|
+
POP_WARNING()
|
|
90
|
+
POP_WARNING()
|
|
91
|
+
POP_WARNING()
|
|
92
|
+
|
|
93
|
+
} // namespace JBrowserCookieJar
|
|
94
|
+
|
|
95
|
+
} // namespace Exchange
|
|
96
|
+
|
|
97
|
+
} // namespace Thunder
|
|
98
|
+
|
|
@@ -0,0 +1,134 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BrowserResources.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JBrowserResources {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IBrowserResources* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBrowserResources"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'userScripts' - User scripts used by the browser
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("userScripts"),
|
|
37
|
+
[_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (params.IsSet() == false) {
|
|
41
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
42
|
+
|
|
43
|
+
_errorCode__ = (static_cast<const IBrowserResources*>(_implementation__))->UserScripts(_result_);
|
|
44
|
+
|
|
45
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
46
|
+
result.Set(true);
|
|
47
|
+
|
|
48
|
+
if (_result_ != nullptr) {
|
|
49
|
+
string _resultItem__{};
|
|
50
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
51
|
+
_result_->Release();
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
else {
|
|
56
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
|
|
57
|
+
std::list<string> _paramsElements_{};
|
|
58
|
+
auto _paramsIterator_ = params.Elements();
|
|
59
|
+
while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
|
|
60
|
+
using _paramsIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
|
|
61
|
+
_params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
|
|
62
|
+
ASSERT(_params_ != nullptr);
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->UserScripts(static_cast<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
|
|
65
|
+
if (_params_ != nullptr) {
|
|
66
|
+
_params_->Release();
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
result.Null(true);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
return (_errorCode__);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
// Property: 'userStyleSheets' - User style sheets used by the browser
|
|
76
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("userStyleSheets"),
|
|
77
|
+
[_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
78
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
79
|
+
|
|
80
|
+
if (params.IsSet() == false) {
|
|
81
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
82
|
+
|
|
83
|
+
_errorCode__ = (static_cast<const IBrowserResources*>(_implementation__))->UserStyleSheets(_result_);
|
|
84
|
+
|
|
85
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
86
|
+
result.Set(true);
|
|
87
|
+
|
|
88
|
+
if (_result_ != nullptr) {
|
|
89
|
+
string _resultItem__{};
|
|
90
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
91
|
+
_result_->Release();
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
else {
|
|
96
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
|
|
97
|
+
std::list<string> _paramsElements_{};
|
|
98
|
+
auto _paramsIterator_ = params.Elements();
|
|
99
|
+
while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
|
|
100
|
+
using _paramsIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
|
|
101
|
+
_params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
|
|
102
|
+
ASSERT(_params_ != nullptr);
|
|
103
|
+
|
|
104
|
+
_errorCode__ = _implementation__->UserStyleSheets(static_cast<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
|
|
105
|
+
if (_params_ != nullptr) {
|
|
106
|
+
_params_->Release();
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
result.Null(true);
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
return (_errorCode__);
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
template<typename MODULE>
|
|
118
|
+
static void Unregister(MODULE& _module__)
|
|
119
|
+
{
|
|
120
|
+
// Unregister methods and properties...
|
|
121
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("userScripts"));
|
|
122
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("userStyleSheets"));
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
POP_WARNING()
|
|
126
|
+
POP_WARNING()
|
|
127
|
+
POP_WARNING()
|
|
128
|
+
|
|
129
|
+
} // namespace JBrowserResources
|
|
130
|
+
|
|
131
|
+
} // namespace Exchange
|
|
132
|
+
|
|
133
|
+
} // namespace Thunder
|
|
134
|
+
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BrowserScripting.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JBrowserScripting {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IBrowserScripting* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBrowserScripting"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'runjavascript' - Run javascript in main frame
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BrowserScripting::RunJavaScriptParamsData, void>(_T("runjavascript"),
|
|
37
|
+
[_implementation__](const JsonData::BrowserScripting::RunJavaScriptParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserScripting"), _T("runjavascript")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _script_{params.Script};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->RunJavaScript(_script_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Method: 'adduserscript' - Add user script to be executed at document start
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::BrowserScripting::AddUserScriptParamsData, void>(_T("adduserscript"),
|
|
56
|
+
[_implementation__](const JsonData::BrowserScripting::AddUserScriptParamsData& params) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
60
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserScripting"), _T("adduserscript")));
|
|
61
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
62
|
+
}
|
|
63
|
+
else {
|
|
64
|
+
const string _script_{params.Script};
|
|
65
|
+
const bool _topFrameOnly_{params.TopFrameOnly};
|
|
66
|
+
|
|
67
|
+
_errorCode__ = _implementation__->AddUserScript(_script_, _topFrameOnly_);
|
|
68
|
+
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
return (_errorCode__);
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
// Method: 'removealluserscripts' - Remove all user scripts
|
|
75
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("removealluserscripts"),
|
|
76
|
+
[_implementation__]() -> uint32_t {
|
|
77
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
78
|
+
|
|
79
|
+
_errorCode__ = _implementation__->RemoveAllUserScripts();
|
|
80
|
+
|
|
81
|
+
return (_errorCode__);
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
template<typename MODULE>
|
|
87
|
+
static void Unregister(MODULE& _module__)
|
|
88
|
+
{
|
|
89
|
+
// Unregister methods and properties...
|
|
90
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("runjavascript"));
|
|
91
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("adduserscript"));
|
|
92
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("removealluserscripts"));
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
POP_WARNING()
|
|
96
|
+
POP_WARNING()
|
|
97
|
+
POP_WARNING()
|
|
98
|
+
|
|
99
|
+
} // namespace JBrowserScripting
|
|
100
|
+
|
|
101
|
+
} // namespace Exchange
|
|
102
|
+
|
|
103
|
+
} // namespace Thunder
|
|
104
|
+
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_BrowserSecurity.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JBrowserSecurity {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IBrowserSecurity* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBrowserSecurity"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'securityprofile' - Security profile for secure connections
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("securityprofile"),
|
|
37
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (params.IsSet() == false) {
|
|
41
|
+
string _result_{};
|
|
42
|
+
|
|
43
|
+
_errorCode__ = (static_cast<const IBrowserSecurity*>(_implementation__))->SecurityProfile(_result_);
|
|
44
|
+
|
|
45
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
46
|
+
result = _result_;
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
else {
|
|
50
|
+
const string _params_{params};
|
|
51
|
+
|
|
52
|
+
_errorCode__ = _implementation__->SecurityProfile(_params_);
|
|
53
|
+
|
|
54
|
+
result.Null(true);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return (_errorCode__);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
// Property: 'mixedcontentpolicy' - Mixed content policy
|
|
61
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IBrowserSecurity::MixedContentPolicyType>, Core::JSON::EnumType<Exchange::IBrowserSecurity::MixedContentPolicyType>>(_T("mixedcontentpolicy"),
|
|
62
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IBrowserSecurity::MixedContentPolicyType>& params, Core::JSON::EnumType<Exchange::IBrowserSecurity::MixedContentPolicyType>& result) -> uint32_t {
|
|
63
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
64
|
+
|
|
65
|
+
if (params.IsSet() == false) {
|
|
66
|
+
Exchange::IBrowserSecurity::MixedContentPolicyType _result_{};
|
|
67
|
+
|
|
68
|
+
_errorCode__ = (static_cast<const IBrowserSecurity*>(_implementation__))->MixedContentPolicy(_result_);
|
|
69
|
+
|
|
70
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
71
|
+
result = _result_;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
else {
|
|
75
|
+
const Exchange::IBrowserSecurity::MixedContentPolicyType _params_{params};
|
|
76
|
+
|
|
77
|
+
_errorCode__ = _implementation__->MixedContentPolicy(_params_);
|
|
78
|
+
|
|
79
|
+
result.Null(true);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
template<typename MODULE>
|
|
88
|
+
static void Unregister(MODULE& _module__)
|
|
89
|
+
{
|
|
90
|
+
// Unregister methods and properties...
|
|
91
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("securityprofile"));
|
|
92
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("mixedcontentpolicy"));
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
POP_WARNING()
|
|
96
|
+
POP_WARNING()
|
|
97
|
+
POP_WARNING()
|
|
98
|
+
|
|
99
|
+
} // namespace JBrowserSecurity
|
|
100
|
+
|
|
101
|
+
} // namespace Exchange
|
|
102
|
+
|
|
103
|
+
} // namespace Thunder
|
|
104
|
+
|
|
@@ -0,0 +1,356 @@
|
|
|
1
|
+
// Generated automatically from 'IButler.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Butler.h"
|
|
6
|
+
#include <interfaces/IButler.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JButler {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IButler* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
ASSERT(_module__.template Exists<IValuePoint>() == true);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JButler"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Method: 'name'
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::NameParamsData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Butler::NameParamsData&, Core::JSON::String&)>>(_T("name"),
|
|
39
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::Butler::NameParamsData& params, Core::JSON::String& valuePoint) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("name")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const string _name_{params.Name};
|
|
48
|
+
string _valuePoint_{};
|
|
49
|
+
Exchange::IValuePoint* _real_valuePoint_{};
|
|
50
|
+
|
|
51
|
+
_errorCode__ = _implementation__->Name(_name_, _real_valuePoint_);
|
|
52
|
+
|
|
53
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
54
|
+
_valuePoint_ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(_real_valuePoint_, context_);
|
|
55
|
+
_real_valuePoint_->Release();
|
|
56
|
+
valuePoint = std::move(_valuePoint_);
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
return (_errorCode__);
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
// Method: 'identifier'
|
|
64
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::IdentifierParamsInfo, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Butler::IdentifierParamsInfo&, Core::JSON::String&)>>(_T("identifier"),
|
|
65
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::Butler::IdentifierParamsInfo& params, Core::JSON::String& valuePoint) -> uint32_t {
|
|
66
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
67
|
+
|
|
68
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
69
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("identifier")));
|
|
70
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
71
|
+
}
|
|
72
|
+
else {
|
|
73
|
+
const uint32_t _id_{params.Id};
|
|
74
|
+
string _valuePoint_{};
|
|
75
|
+
Exchange::IValuePoint* _real_valuePoint_{};
|
|
76
|
+
|
|
77
|
+
_errorCode__ = _implementation__->Identifier(_id_, _real_valuePoint_);
|
|
78
|
+
|
|
79
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
80
|
+
_valuePoint_ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(_real_valuePoint_, context_);
|
|
81
|
+
_real_valuePoint_->Release();
|
|
82
|
+
valuePoint = std::move(_valuePoint_);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
return (_errorCode__);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
// Method: 'branch'
|
|
90
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::BranchParamsInfo, void>(_T("branch"),
|
|
91
|
+
[_implementation__](const JsonData::Butler::BranchParamsInfo& params) -> uint32_t {
|
|
92
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
93
|
+
|
|
94
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
95
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("branch")));
|
|
96
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
97
|
+
}
|
|
98
|
+
else {
|
|
99
|
+
const string _path_{params.Path};
|
|
100
|
+
|
|
101
|
+
_errorCode__ = _implementation__->Branch(_path_);
|
|
102
|
+
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
return (_errorCode__);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
// Method: 'move'
|
|
109
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::MoveParamsData, void>(_T("move"),
|
|
110
|
+
[_implementation__](const JsonData::Butler::MoveParamsData& params) -> uint32_t {
|
|
111
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
112
|
+
|
|
113
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
114
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("move")));
|
|
115
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
116
|
+
}
|
|
117
|
+
else {
|
|
118
|
+
const string _path_{params.Path};
|
|
119
|
+
const string _newName_{params.NewName};
|
|
120
|
+
|
|
121
|
+
_errorCode__ = _implementation__->Move(_path_, _newName_);
|
|
122
|
+
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
return (_errorCode__);
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
// Method: 'delete'
|
|
129
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::BranchParamsInfo, void>(_T("delete"),
|
|
130
|
+
[_implementation__](const JsonData::Butler::BranchParamsInfo& params) -> uint32_t {
|
|
131
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
132
|
+
|
|
133
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
134
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("delete")));
|
|
135
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
136
|
+
}
|
|
137
|
+
else {
|
|
138
|
+
const string _path_{params.Path};
|
|
139
|
+
|
|
140
|
+
_errorCode__ = _implementation__->Delete(_path_);
|
|
141
|
+
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
return (_errorCode__);
|
|
145
|
+
});
|
|
146
|
+
|
|
147
|
+
// Method: 'source'
|
|
148
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::IdentifierParamsInfo, Core::JSON::String>(_T("source"),
|
|
149
|
+
[_implementation__](const JsonData::Butler::IdentifierParamsInfo& params, Core::JSON::String& callsign) -> uint32_t {
|
|
150
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
151
|
+
|
|
152
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
153
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("source")));
|
|
154
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
155
|
+
}
|
|
156
|
+
else {
|
|
157
|
+
const uint32_t _id_{params.Id};
|
|
158
|
+
string _callsign_{};
|
|
159
|
+
|
|
160
|
+
_errorCode__ = _implementation__->Source(_id_, _callsign_);
|
|
161
|
+
|
|
162
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
163
|
+
callsign = _callsign_;
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
return (_errorCode__);
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
// Method: 'link'
|
|
171
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::LinkParamsData, void>(_T("link"),
|
|
172
|
+
[_implementation__](const JsonData::Butler::LinkParamsData& params) -> uint32_t {
|
|
173
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
174
|
+
|
|
175
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
176
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("link")));
|
|
177
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
178
|
+
}
|
|
179
|
+
else {
|
|
180
|
+
const string _name_{params.Name};
|
|
181
|
+
const uint32_t _id_{params.Id};
|
|
182
|
+
|
|
183
|
+
_errorCode__ = _implementation__->Link(_name_, _id_);
|
|
184
|
+
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
return (_errorCode__);
|
|
188
|
+
});
|
|
189
|
+
|
|
190
|
+
// Method: 'orphans'
|
|
191
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Butler::OrphansParamsData, Core::JSON::ArrayType<Core::JSON::DecUInt32>>(_T("orphans"),
|
|
192
|
+
[_implementation__](const JsonData::Butler::OrphansParamsData& params, Core::JSON::ArrayType<Core::JSON::DecUInt32>& iterator) -> uint32_t {
|
|
193
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
194
|
+
|
|
195
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
196
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("orphans")));
|
|
197
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
198
|
+
}
|
|
199
|
+
else {
|
|
200
|
+
const uint8_t _module_{params.Module};
|
|
201
|
+
RPC::IIteratorType<uint32_t, RPC::ID_VALUEITERATOR>* _iterator_{};
|
|
202
|
+
|
|
203
|
+
_errorCode__ = _implementation__->Orphans(_module_, _iterator_);
|
|
204
|
+
|
|
205
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
206
|
+
iterator.Set(true);
|
|
207
|
+
|
|
208
|
+
if (_iterator_ != nullptr) {
|
|
209
|
+
uint32_t _resultItem__{};
|
|
210
|
+
while (_iterator_->Next(_resultItem__) == true) { iterator.Add() = _resultItem__; }
|
|
211
|
+
_iterator_->Release();
|
|
212
|
+
}
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
return (_errorCode__);
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
template<typename MODULE>
|
|
222
|
+
static void Unregister(MODULE& _module__)
|
|
223
|
+
{
|
|
224
|
+
// Unregister methods and properties...
|
|
225
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("name"));
|
|
226
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("identifier"));
|
|
227
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("branch"));
|
|
228
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("move"));
|
|
229
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("delete"));
|
|
230
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("source"));
|
|
231
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("link"));
|
|
232
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("orphans"));
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
namespace Event {
|
|
236
|
+
|
|
237
|
+
// Event: 'added'
|
|
238
|
+
template<typename MODULE>
|
|
239
|
+
static void Added(const MODULE& module_, const JsonData::Butler::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
240
|
+
{
|
|
241
|
+
module_.Notify(_T("added"), params, sendIfMethod_);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
// Event: 'added'
|
|
245
|
+
template<typename MODULE>
|
|
246
|
+
static void Added(const MODULE& module_, const Core::JSON::String& element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
247
|
+
{
|
|
248
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
249
|
+
params_.Element = element;
|
|
250
|
+
|
|
251
|
+
Added(module_, params_, sendIfMethod_);
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
// Event: 'added'
|
|
255
|
+
template<typename MODULE>
|
|
256
|
+
static void Added(const MODULE& module_, IValuePoint* const element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
257
|
+
{
|
|
258
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
259
|
+
params_.Element = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(element);
|
|
260
|
+
|
|
261
|
+
Added(module_, params_, sendIfMethod_);
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
// Event: 'removed'
|
|
265
|
+
template<typename MODULE>
|
|
266
|
+
static void Removed(const MODULE& module_, const JsonData::Butler::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
267
|
+
{
|
|
268
|
+
module_.Notify(_T("removed"), params, sendIfMethod_);
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
// Event: 'removed'
|
|
272
|
+
template<typename MODULE>
|
|
273
|
+
static void Removed(const MODULE& module_, const Core::JSON::String& element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
274
|
+
{
|
|
275
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
276
|
+
params_.Element = element;
|
|
277
|
+
|
|
278
|
+
Removed(module_, params_, sendIfMethod_);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
// Event: 'removed'
|
|
282
|
+
template<typename MODULE>
|
|
283
|
+
static void Removed(const MODULE& module_, IValuePoint* const element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
284
|
+
{
|
|
285
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
286
|
+
params_.Element = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(element);
|
|
287
|
+
|
|
288
|
+
Removed(module_, params_, sendIfMethod_);
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
// Event: 'updated'
|
|
292
|
+
template<typename MODULE>
|
|
293
|
+
static void Updated(const MODULE& module_, const JsonData::Butler::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
294
|
+
{
|
|
295
|
+
module_.Notify(_T("updated"), params, sendIfMethod_);
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
// Event: 'updated'
|
|
299
|
+
template<typename MODULE>
|
|
300
|
+
static void Updated(const MODULE& module_, const Core::JSON::String& element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
301
|
+
{
|
|
302
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
303
|
+
params_.Element = element;
|
|
304
|
+
|
|
305
|
+
Updated(module_, params_, sendIfMethod_);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
// Event: 'updated'
|
|
309
|
+
template<typename MODULE>
|
|
310
|
+
static void Updated(const MODULE& module_, IValuePoint* const element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
311
|
+
{
|
|
312
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
313
|
+
params_.Element = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(element);
|
|
314
|
+
|
|
315
|
+
Updated(module_, params_, sendIfMethod_);
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
// Event: 'metadata'
|
|
319
|
+
template<typename MODULE>
|
|
320
|
+
static void Metadata(const MODULE& module_, const JsonData::Butler::AddedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
321
|
+
{
|
|
322
|
+
module_.Notify(_T("metadata"), params, sendIfMethod_);
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
// Event: 'metadata'
|
|
326
|
+
template<typename MODULE>
|
|
327
|
+
static void Metadata(const MODULE& module_, const Core::JSON::String& element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
328
|
+
{
|
|
329
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
330
|
+
params_.Element = element;
|
|
331
|
+
|
|
332
|
+
Metadata(module_, params_, sendIfMethod_);
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
// Event: 'metadata'
|
|
336
|
+
template<typename MODULE>
|
|
337
|
+
static void Metadata(const MODULE& module_, IValuePoint* const element, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
338
|
+
{
|
|
339
|
+
JsonData::Butler::AddedParamsInfo params_;
|
|
340
|
+
params_.Element = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(element);
|
|
341
|
+
|
|
342
|
+
Metadata(module_, params_, sendIfMethod_);
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
} // namespace Event
|
|
346
|
+
|
|
347
|
+
POP_WARNING()
|
|
348
|
+
POP_WARNING()
|
|
349
|
+
POP_WARNING()
|
|
350
|
+
|
|
351
|
+
} // namespace JButler
|
|
352
|
+
|
|
353
|
+
} // namespace Exchange
|
|
354
|
+
|
|
355
|
+
} // namespace Thunder
|
|
356
|
+
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
// Generated automatically from 'Cobalt.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
|
|
6
|
+
namespace Thunder {
|
|
7
|
+
|
|
8
|
+
namespace Exchange {
|
|
9
|
+
|
|
10
|
+
namespace JCobalt {
|
|
11
|
+
|
|
12
|
+
namespace Version {
|
|
13
|
+
|
|
14
|
+
constexpr uint8_t Major = 1;
|
|
15
|
+
constexpr uint8_t Minor = 0;
|
|
16
|
+
constexpr uint8_t Patch = 0;
|
|
17
|
+
|
|
18
|
+
} // namespace Version
|
|
19
|
+
|
|
20
|
+
} // namespace JCobalt
|
|
21
|
+
|
|
22
|
+
} // namespace Exchange
|
|
23
|
+
|
|
24
|
+
} // namespace Thunder
|
|
25
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Compositor.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Compositor.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JCompositor {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JCompositor
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,280 @@
|
|
|
1
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ConnectionProperties.h"
|
|
6
|
+
#include <interfaces/IDisplayInfo.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JConnectionProperties {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IConnectionProperties* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JConnectionProperties"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'edid' - TV's Extended Display Identification Data
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ConnectionProperties::EDIDParamsData, JsonData::ConnectionProperties::EDIDResultData>(_T("edid"),
|
|
37
|
+
[_implementation__](const JsonData::ConnectionProperties::EDIDParamsData& params, JsonData::ConnectionProperties::EDIDResultData& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConnectionProperties"), _T("edid")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
uint16_t _length_{params.Length.Value()};
|
|
46
|
+
uint8_t* _data_{};
|
|
47
|
+
|
|
48
|
+
if (_length_ != 0) {
|
|
49
|
+
_data_ = reinterpret_cast<uint8_t*>(ALLOCA(_length_));
|
|
50
|
+
ASSERT(_data_ != nullptr);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->EDID(_length_, _data_);
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
result.Length = _length_;
|
|
57
|
+
|
|
58
|
+
if ((_length_ != 0) && (_data_ != nullptr)) {
|
|
59
|
+
string _dataEncoded__;
|
|
60
|
+
Core::ToString(_data_, _length_, true, _dataEncoded__);
|
|
61
|
+
result.Data = std::move(_dataEncoded__);
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
return (_errorCode__);
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
// Method: 'widthincentimeters' - Horizontal size in centimeters
|
|
70
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt8>(_T("widthincentimeters"),
|
|
71
|
+
[_implementation__](Core::JSON::DecUInt8& width) -> uint32_t {
|
|
72
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
73
|
+
|
|
74
|
+
uint8_t _width_{};
|
|
75
|
+
|
|
76
|
+
_errorCode__ = _implementation__->WidthInCentimeters(_width_);
|
|
77
|
+
|
|
78
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
79
|
+
width = _width_;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
// Method: 'heightincentimeters' - Vertical size in centimeters
|
|
86
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt8>(_T("heightincentimeters"),
|
|
87
|
+
[_implementation__](Core::JSON::DecUInt8& height) -> uint32_t {
|
|
88
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
89
|
+
|
|
90
|
+
uint8_t _height_{};
|
|
91
|
+
|
|
92
|
+
_errorCode__ = _implementation__->HeightInCentimeters(_height_);
|
|
93
|
+
|
|
94
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
95
|
+
height = _height_;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
return (_errorCode__);
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
// Property: 'isaudiopassthrough' - Current audio passthrough status on HDMI (r/o)
|
|
102
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::Boolean>(_T("isaudiopassthrough"),
|
|
103
|
+
[_implementation__](Core::JSON::Boolean& result) -> uint32_t {
|
|
104
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
105
|
+
|
|
106
|
+
bool _result_{};
|
|
107
|
+
|
|
108
|
+
_errorCode__ = _implementation__->IsAudioPassthrough(_result_);
|
|
109
|
+
|
|
110
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
111
|
+
result = _result_;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
return (_errorCode__);
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
// Property: 'connected' - Current HDMI connection status (r/o)
|
|
118
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::Boolean>(_T("connected"),
|
|
119
|
+
[_implementation__](Core::JSON::Boolean& result) -> uint32_t {
|
|
120
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
121
|
+
|
|
122
|
+
bool _result_{};
|
|
123
|
+
|
|
124
|
+
_errorCode__ = _implementation__->Connected(_result_);
|
|
125
|
+
|
|
126
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
127
|
+
result = _result_;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
return (_errorCode__);
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
// Property: 'width' - Horizontal resolution of TV (r/o)
|
|
134
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32>(_T("width"),
|
|
135
|
+
[_implementation__](Core::JSON::DecUInt32& result) -> uint32_t {
|
|
136
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
137
|
+
|
|
138
|
+
uint32_t _result_{};
|
|
139
|
+
|
|
140
|
+
_errorCode__ = _implementation__->Width(_result_);
|
|
141
|
+
|
|
142
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
143
|
+
result = _result_;
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
return (_errorCode__);
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
// Property: 'height' - Vertical resolution of TV (r/o)
|
|
150
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32>(_T("height"),
|
|
151
|
+
[_implementation__](Core::JSON::DecUInt32& result) -> uint32_t {
|
|
152
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
153
|
+
|
|
154
|
+
uint32_t _result_{};
|
|
155
|
+
|
|
156
|
+
_errorCode__ = _implementation__->Height(_result_);
|
|
157
|
+
|
|
158
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
159
|
+
result = _result_;
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
return (_errorCode__);
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
// Property: 'verticalfreq' - Vertical Frequency (r/o)
|
|
166
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32>(_T("verticalfreq"),
|
|
167
|
+
[_implementation__](Core::JSON::DecUInt32& result) -> uint32_t {
|
|
168
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
169
|
+
|
|
170
|
+
uint32_t _result_{};
|
|
171
|
+
|
|
172
|
+
_errorCode__ = _implementation__->VerticalFreq(_result_);
|
|
173
|
+
|
|
174
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
175
|
+
result = _result_;
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
return (_errorCode__);
|
|
179
|
+
});
|
|
180
|
+
|
|
181
|
+
// Property: 'hdcpprotection' - HDCP protocol used for transmission
|
|
182
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IConnectionProperties::HDCPProtectionType>, Core::JSON::EnumType<Exchange::IConnectionProperties::HDCPProtectionType>>(_T("hdcpprotection"),
|
|
183
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IConnectionProperties::HDCPProtectionType>& params, Core::JSON::EnumType<Exchange::IConnectionProperties::HDCPProtectionType>& result) -> uint32_t {
|
|
184
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
185
|
+
|
|
186
|
+
if (params.IsSet() == false) {
|
|
187
|
+
Exchange::IConnectionProperties::HDCPProtectionType _result_{};
|
|
188
|
+
|
|
189
|
+
_errorCode__ = (static_cast<const IConnectionProperties*>(_implementation__))->HDCPProtection(_result_);
|
|
190
|
+
|
|
191
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
192
|
+
result = _result_;
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
else {
|
|
196
|
+
const Exchange::IConnectionProperties::HDCPProtectionType _params_{params};
|
|
197
|
+
|
|
198
|
+
_errorCode__ = _implementation__->HDCPProtection(_params_);
|
|
199
|
+
|
|
200
|
+
result.Null(true);
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
return (_errorCode__);
|
|
204
|
+
});
|
|
205
|
+
|
|
206
|
+
// Property: 'portname' - Video output port on the STB used for connection to TV (r/o)
|
|
207
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::String>(_T("portname"),
|
|
208
|
+
[_implementation__](Core::JSON::String& result) -> uint32_t {
|
|
209
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
210
|
+
|
|
211
|
+
string _result_{};
|
|
212
|
+
|
|
213
|
+
_errorCode__ = _implementation__->PortName(_result_);
|
|
214
|
+
|
|
215
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
216
|
+
result = _result_;
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
return (_errorCode__);
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
template<typename MODULE>
|
|
225
|
+
static void Unregister(MODULE& _module__)
|
|
226
|
+
{
|
|
227
|
+
// Unregister methods and properties...
|
|
228
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("edid"));
|
|
229
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("widthincentimeters"));
|
|
230
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("heightincentimeters"));
|
|
231
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("isaudiopassthrough"));
|
|
232
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("connected"));
|
|
233
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("width"));
|
|
234
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("height"));
|
|
235
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("verticalfreq"));
|
|
236
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("hdcpprotection"));
|
|
237
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("portname"));
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
namespace Event {
|
|
241
|
+
|
|
242
|
+
// Event: 'updated' - Signal changes on the display update
|
|
243
|
+
template<typename MODULE>
|
|
244
|
+
static void Updated(const MODULE& module_, const JsonData::ConnectionProperties::UpdatedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
245
|
+
{
|
|
246
|
+
module_.Notify(_T("updated"), params, sendIfMethod_);
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
// Event: 'updated' - Signal changes on the display update
|
|
250
|
+
template<typename MODULE>
|
|
251
|
+
static void Updated(const MODULE& module_, const Core::JSON::EnumType<Exchange::IConnectionProperties::INotification::Source>& event, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
252
|
+
{
|
|
253
|
+
JsonData::ConnectionProperties::UpdatedParamsData params_;
|
|
254
|
+
params_.Event = event;
|
|
255
|
+
|
|
256
|
+
Updated(module_, params_, sendIfMethod_);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
// Event: 'updated' - Signal changes on the display update
|
|
260
|
+
template<typename MODULE>
|
|
261
|
+
static void Updated(const MODULE& module_, const IConnectionProperties::INotification::Source event, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
262
|
+
{
|
|
263
|
+
JsonData::ConnectionProperties::UpdatedParamsData params_;
|
|
264
|
+
params_.Event = event;
|
|
265
|
+
|
|
266
|
+
Updated(module_, params_, sendIfMethod_);
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
} // namespace Event
|
|
270
|
+
|
|
271
|
+
POP_WARNING()
|
|
272
|
+
POP_WARNING()
|
|
273
|
+
POP_WARNING()
|
|
274
|
+
|
|
275
|
+
} // namespace JConnectionProperties
|
|
276
|
+
|
|
277
|
+
} // namespace Exchange
|
|
278
|
+
|
|
279
|
+
} // namespace Thunder
|
|
280
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Containers.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Containers.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JContainers {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JContainers
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,232 @@
|
|
|
1
|
+
// Generated automatically from 'IContentProtection.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ContentProtection.h"
|
|
6
|
+
#include <interfaces/IContentProtection.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JContentProtection {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IContentProtection* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JContentProtection"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'openDrmSession'
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::OpenDrmSessionParamsData, JsonData::ContentProtection::OpenDrmSessionResultData>(_T("openDrmSession"),
|
|
37
|
+
[_implementation__](const JsonData::ContentProtection::OpenDrmSessionParamsData& params, JsonData::ContentProtection::OpenDrmSessionResultData& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("openDrmSession")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _clientId_{params.ClientId};
|
|
46
|
+
const string _appId_{params.AppId};
|
|
47
|
+
const Exchange::IContentProtection::KeySystem _keySystem_{params.KeySystem};
|
|
48
|
+
const string _licenseRequest_{params.LicenseRequest};
|
|
49
|
+
const string _initData_{params.InitData};
|
|
50
|
+
string _sessionId_{};
|
|
51
|
+
string _response_{};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->OpenDrmSession(_clientId_, _appId_, _keySystem_, _licenseRequest_, _initData_, _sessionId_, _response_);
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
result.SessionId = _sessionId_;
|
|
57
|
+
result.Response = _response_;
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
return (_errorCode__);
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
// Method: 'setDrmSessionState'
|
|
65
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::SetDrmSessionStateParamsData, void>(_T("setDrmSessionState"),
|
|
66
|
+
[_implementation__](const JsonData::ContentProtection::SetDrmSessionStateParamsData& params) -> uint32_t {
|
|
67
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
68
|
+
|
|
69
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
70
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("setDrmSessionState")));
|
|
71
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
72
|
+
}
|
|
73
|
+
else {
|
|
74
|
+
const string _sessionId_{params.SessionId};
|
|
75
|
+
const Exchange::IContentProtection::State _sessionState_{params.SessionState};
|
|
76
|
+
|
|
77
|
+
_errorCode__ = _implementation__->SetDrmSessionState(_sessionId_, _sessionState_);
|
|
78
|
+
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
return (_errorCode__);
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
// Method: 'updateDrmSession'
|
|
85
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::UpdateDrmSessionParamsData, Core::JSON::String>(_T("updateDrmSession"),
|
|
86
|
+
[_implementation__](const JsonData::ContentProtection::UpdateDrmSessionParamsData& params, Core::JSON::String& response) -> uint32_t {
|
|
87
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
88
|
+
|
|
89
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
90
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("updateDrmSession")));
|
|
91
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
92
|
+
}
|
|
93
|
+
else {
|
|
94
|
+
const string _sessionId_{params.SessionId};
|
|
95
|
+
const string _licenseRequest_{params.LicenseRequest};
|
|
96
|
+
const string _initData_{params.InitData};
|
|
97
|
+
string _response_{};
|
|
98
|
+
|
|
99
|
+
_errorCode__ = _implementation__->UpdateDrmSession(_sessionId_, _licenseRequest_, _initData_, _response_);
|
|
100
|
+
|
|
101
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
102
|
+
response = _response_;
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
return (_errorCode__);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
// Method: 'closeDrmSession'
|
|
110
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::CloseDrmSessionParamsData, Core::JSON::String>(_T("closeDrmSession"),
|
|
111
|
+
[_implementation__](const JsonData::ContentProtection::CloseDrmSessionParamsData& params, Core::JSON::String& response) -> uint32_t {
|
|
112
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
113
|
+
|
|
114
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
115
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("closeDrmSession")));
|
|
116
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
117
|
+
}
|
|
118
|
+
else {
|
|
119
|
+
const string _sessionId_{params.SessionId};
|
|
120
|
+
string _response_{};
|
|
121
|
+
|
|
122
|
+
_errorCode__ = _implementation__->CloseDrmSession(_sessionId_, _response_);
|
|
123
|
+
|
|
124
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
125
|
+
response = _response_;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
return (_errorCode__);
|
|
130
|
+
});
|
|
131
|
+
|
|
132
|
+
// Method: 'showWatermark'
|
|
133
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::ShowWatermarkParamsData, void>(_T("showWatermark"),
|
|
134
|
+
[_implementation__](const JsonData::ContentProtection::ShowWatermarkParamsData& params) -> uint32_t {
|
|
135
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
136
|
+
|
|
137
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
138
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("showWatermark")));
|
|
139
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
140
|
+
}
|
|
141
|
+
else {
|
|
142
|
+
const string _sessionId_{params.SessionId};
|
|
143
|
+
const bool _show_{params.Show};
|
|
144
|
+
const uint8_t _opacityLevel_{params.OpacityLevel};
|
|
145
|
+
|
|
146
|
+
_errorCode__ = _implementation__->ShowWatermark(_sessionId_, _show_, _opacityLevel_);
|
|
147
|
+
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
return (_errorCode__);
|
|
151
|
+
});
|
|
152
|
+
|
|
153
|
+
// Method: 'setPlaybackPosition'
|
|
154
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::SetPlaybackPositionParamsData, void>(_T("setPlaybackPosition"),
|
|
155
|
+
[_implementation__](const JsonData::ContentProtection::SetPlaybackPositionParamsData& params) -> uint32_t {
|
|
156
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
157
|
+
|
|
158
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
159
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("setPlaybackPosition")));
|
|
160
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
161
|
+
}
|
|
162
|
+
else {
|
|
163
|
+
const string _sessionId_{params.SessionId};
|
|
164
|
+
const int32_t _speed_{params.Speed};
|
|
165
|
+
const int32_t _position_{params.Position};
|
|
166
|
+
|
|
167
|
+
_errorCode__ = _implementation__->SetPlaybackPosition(_sessionId_, _speed_, _position_);
|
|
168
|
+
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
return (_errorCode__);
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
template<typename MODULE>
|
|
177
|
+
static void Unregister(MODULE& _module__)
|
|
178
|
+
{
|
|
179
|
+
// Unregister methods and properties...
|
|
180
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("openDrmSession"));
|
|
181
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setDrmSessionState"));
|
|
182
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("updateDrmSession"));
|
|
183
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("closeDrmSession"));
|
|
184
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("showWatermark"));
|
|
185
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setPlaybackPosition"));
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
namespace Event {
|
|
189
|
+
|
|
190
|
+
// Event: 'onWatermarkStatusChanged'
|
|
191
|
+
template<typename MODULE>
|
|
192
|
+
static void WatermarkStatusChanged(const MODULE& module_, const JsonData::ContentProtection::WatermarkStatusChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
193
|
+
{
|
|
194
|
+
module_.Notify(_T("onWatermarkStatusChanged"), params, sendIfMethod_);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
// Event: 'onWatermarkStatusChanged'
|
|
198
|
+
template<typename MODULE>
|
|
199
|
+
static void WatermarkStatusChanged(const MODULE& module_, const Core::JSON::String& sessionId, const Core::JSON::String& appId, const JsonData::ContentProtection::WatermarkStatusChangedParamsData::StatusData& status, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
200
|
+
{
|
|
201
|
+
JsonData::ContentProtection::WatermarkStatusChangedParamsData params_;
|
|
202
|
+
params_.SessionId = sessionId;
|
|
203
|
+
params_.AppId = appId;
|
|
204
|
+
params_.Status = status;
|
|
205
|
+
|
|
206
|
+
WatermarkStatusChanged(module_, params_, sendIfMethod_);
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
// Event: 'onWatermarkStatusChanged'
|
|
210
|
+
template<typename MODULE>
|
|
211
|
+
static void WatermarkStatusChanged(const MODULE& module_, const string& sessionId, const string& appId, const IContentProtection::INotification::Status& status, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
212
|
+
{
|
|
213
|
+
JsonData::ContentProtection::WatermarkStatusChangedParamsData params_;
|
|
214
|
+
params_.SessionId = sessionId;
|
|
215
|
+
params_.AppId = appId;
|
|
216
|
+
params_.Status = status;
|
|
217
|
+
|
|
218
|
+
WatermarkStatusChanged(module_, params_, sendIfMethod_);
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
} // namespace Event
|
|
222
|
+
|
|
223
|
+
POP_WARNING()
|
|
224
|
+
POP_WARNING()
|
|
225
|
+
POP_WARNING()
|
|
226
|
+
|
|
227
|
+
} // namespace JContentProtection
|
|
228
|
+
|
|
229
|
+
} // namespace Exchange
|
|
230
|
+
|
|
231
|
+
} // namespace Thunder
|
|
232
|
+
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
// Generated automatically from 'ICustomerCareOperations.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/ICustomerCareOperations.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JCustomerCareOperations {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, ICustomerCareOperations* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JCustomerCareOperations"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Method: 'factoryReset' - Executes all operations needed for a plugin's factory reset
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("factoryReset"),
|
|
36
|
+
[_implementation__]() -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
_errorCode__ = _implementation__->FactoryReset();
|
|
40
|
+
|
|
41
|
+
return (_errorCode__);
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
template<typename MODULE>
|
|
47
|
+
static void Unregister(MODULE& _module__)
|
|
48
|
+
{
|
|
49
|
+
// Unregister methods and properties...
|
|
50
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("factoryReset"));
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
POP_WARNING()
|
|
54
|
+
POP_WARNING()
|
|
55
|
+
POP_WARNING()
|
|
56
|
+
|
|
57
|
+
} // namespace JCustomerCareOperations
|
|
58
|
+
|
|
59
|
+
} // namespace Exchange
|
|
60
|
+
|
|
61
|
+
} // namespace Thunder
|
|
62
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'DHCPServer.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DHCPServer.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JDHCPServer {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JDHCPServer
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'DIALServer.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DIALServer.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JDIALServer {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JDIALServer
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,170 @@
|
|
|
1
|
+
// Generated automatically from 'IDNSServer.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DNSServer.h"
|
|
6
|
+
#include <interfaces/IDNSServer.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JDNSServer {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IDNSServer* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JDNSServer"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'findByKey'
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::FindByKeyParamsData, JsonData::DNSServer::RecordInfo>(_T("findByKey"),
|
|
37
|
+
[_implementation__](const JsonData::DNSServer::FindByKeyParamsData& params, JsonData::DNSServer::RecordInfo& entry) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("findByKey")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _designator_{params.Designator};
|
|
46
|
+
const string _key_{params.Key};
|
|
47
|
+
Exchange::IDNSServer::Record _entry_{};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->FindByKey(_designator_, _key_, _entry_);
|
|
50
|
+
|
|
51
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
52
|
+
entry.Set(true);
|
|
53
|
+
entry = _entry_;
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return (_errorCode__);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
// Method: 'countByType'
|
|
61
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::CountByTypeParamsData, Core::JSON::DecUInt8>(_T("countByType"),
|
|
62
|
+
[_implementation__](const JsonData::DNSServer::CountByTypeParamsData& params, Core::JSON::DecUInt8& index) -> uint32_t {
|
|
63
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
64
|
+
|
|
65
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
66
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("countByType")));
|
|
67
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
68
|
+
}
|
|
69
|
+
else {
|
|
70
|
+
const string _designator_{params.Designator};
|
|
71
|
+
const Exchange::IDNSServer::Record::type _kind_{params.Kind};
|
|
72
|
+
uint8_t _index_{};
|
|
73
|
+
|
|
74
|
+
_errorCode__ = _implementation__->CountByType(_designator_, _kind_, _index_);
|
|
75
|
+
|
|
76
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
77
|
+
index = _index_;
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
return (_errorCode__);
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
// Method: 'findByType'
|
|
85
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::FindByTypeParamsData, JsonData::DNSServer::RecordInfo>(_T("findByType"),
|
|
86
|
+
[_implementation__](const JsonData::DNSServer::FindByTypeParamsData& params, JsonData::DNSServer::RecordInfo& entry) -> uint32_t {
|
|
87
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
88
|
+
|
|
89
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
90
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("findByType")));
|
|
91
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
92
|
+
}
|
|
93
|
+
else {
|
|
94
|
+
const string _designator_{params.Designator};
|
|
95
|
+
const Exchange::IDNSServer::Record::type _kind_{params.Kind};
|
|
96
|
+
const uint8_t _index_{params.Index};
|
|
97
|
+
Exchange::IDNSServer::Record _entry_{};
|
|
98
|
+
|
|
99
|
+
_errorCode__ = _implementation__->FindByType(_designator_, _kind_, _index_, _entry_);
|
|
100
|
+
|
|
101
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
102
|
+
entry.Set(true);
|
|
103
|
+
entry = _entry_;
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
return (_errorCode__);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
// Method: 'add'
|
|
111
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::AddParamsData, void>(_T("add"),
|
|
112
|
+
[_implementation__](const JsonData::DNSServer::AddParamsData& params) -> uint32_t {
|
|
113
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
114
|
+
|
|
115
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
116
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("add")));
|
|
117
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
118
|
+
}
|
|
119
|
+
else {
|
|
120
|
+
const Exchange::IDNSServer::Record _entry_(params.Entry);
|
|
121
|
+
|
|
122
|
+
_errorCode__ = _implementation__->Add(_entry_);
|
|
123
|
+
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
return (_errorCode__);
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
// Method: 'remove'
|
|
130
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::RemoveParamsData, void>(_T("remove"),
|
|
131
|
+
[_implementation__](const JsonData::DNSServer::RemoveParamsData& params) -> uint32_t {
|
|
132
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
133
|
+
|
|
134
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
135
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("remove")));
|
|
136
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
137
|
+
}
|
|
138
|
+
else {
|
|
139
|
+
const Exchange::IDNSServer::Record _record_(params.Record);
|
|
140
|
+
|
|
141
|
+
_errorCode__ = _implementation__->Remove(_record_);
|
|
142
|
+
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
return (_errorCode__);
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
template<typename MODULE>
|
|
151
|
+
static void Unregister(MODULE& _module__)
|
|
152
|
+
{
|
|
153
|
+
// Unregister methods and properties...
|
|
154
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("findByKey"));
|
|
155
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("countByType"));
|
|
156
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("findByType"));
|
|
157
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("add"));
|
|
158
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("remove"));
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
POP_WARNING()
|
|
162
|
+
POP_WARNING()
|
|
163
|
+
POP_WARNING()
|
|
164
|
+
|
|
165
|
+
} // namespace JDNSServer
|
|
166
|
+
|
|
167
|
+
} // namespace Exchange
|
|
168
|
+
|
|
169
|
+
} // namespace Thunder
|
|
170
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'DTV.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DTV.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JDTV {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JDTV
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
// Generated automatically from 'IDeviceIdentification.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DeviceIdentification.h"
|
|
6
|
+
#include <interfaces/IDeviceIdentification.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JDeviceIdentification {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IDeviceIdentification* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JDeviceIdentification"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'deviceidentification' - Get device paltform specific information (r/o)
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::DeviceIdentification::DeviceInfoData>(_T("deviceidentification"),
|
|
37
|
+
[_implementation__](JsonData::DeviceIdentification::DeviceInfoData& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
Exchange::IDeviceIdentification::DeviceInfo _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = _implementation__->Identification(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result.Set(true);
|
|
46
|
+
result = _result_;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
return (_errorCode__);
|
|
50
|
+
});
|
|
51
|
+
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
template<typename MODULE>
|
|
55
|
+
static void Unregister(MODULE& _module__)
|
|
56
|
+
{
|
|
57
|
+
// Unregister methods and properties...
|
|
58
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deviceidentification"));
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
POP_WARNING()
|
|
62
|
+
POP_WARNING()
|
|
63
|
+
POP_WARNING()
|
|
64
|
+
|
|
65
|
+
} // namespace JDeviceIdentification
|
|
66
|
+
|
|
67
|
+
} // namespace Exchange
|
|
68
|
+
|
|
69
|
+
} // namespace Thunder
|
|
70
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'DeviceInfo.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DeviceInfo.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JDeviceInfo {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JDeviceInfo
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,174 @@
|
|
|
1
|
+
// Generated automatically from 'IDictionary.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Dictionary.h"
|
|
6
|
+
#include <interfaces/IDictionary.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JDictionary {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IDictionary* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JDictionary"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'get' - Getters for the dictionary
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::GetParamsData, Core::JSON::String>(_T("get"),
|
|
37
|
+
[_implementation__](const JsonData::Dictionary::GetParamsData& params, Core::JSON::String& value) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("get")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _path_{params.Path};
|
|
46
|
+
const string _key_{params.Key};
|
|
47
|
+
string _value_{};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Get(_path_, _key_, _value_);
|
|
50
|
+
|
|
51
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
52
|
+
value = _value_;
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
// Method: 'set' - Setters for the dictionary
|
|
60
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::SetParamsData, void>(_T("set"),
|
|
61
|
+
[_implementation__](const JsonData::Dictionary::SetParamsData& params) -> uint32_t {
|
|
62
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
63
|
+
|
|
64
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
65
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("set")));
|
|
66
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
67
|
+
}
|
|
68
|
+
else {
|
|
69
|
+
const string _path_{params.Path};
|
|
70
|
+
const string _key_{params.Key};
|
|
71
|
+
const string _value_{params.Value};
|
|
72
|
+
|
|
73
|
+
_errorCode__ = _implementation__->Set(_path_, _key_, _value_);
|
|
74
|
+
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
return (_errorCode__);
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
// Method: 'pathentries' - Get a list of all entries for this namespace (could be keys or nested namespaces)
|
|
81
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::PathEntriesParamsData, Core::JSON::ArrayType<JsonData::Dictionary::PathEntryData>>(_T("pathentries"),
|
|
82
|
+
[_implementation__](const JsonData::Dictionary::PathEntriesParamsData& params, Core::JSON::ArrayType<JsonData::Dictionary::PathEntryData>& entries) -> uint32_t {
|
|
83
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
84
|
+
|
|
85
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
86
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("pathentries")));
|
|
87
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
88
|
+
}
|
|
89
|
+
else {
|
|
90
|
+
const string _path_{params.Path};
|
|
91
|
+
RPC::IIteratorType<Exchange::IDictionary::PathEntry, Exchange::ID_DICTIONARY_ITERATOR>* _entries_{};
|
|
92
|
+
|
|
93
|
+
_errorCode__ = _implementation__->PathEntries(_path_, _entries_);
|
|
94
|
+
|
|
95
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
96
|
+
entries.Set(true);
|
|
97
|
+
|
|
98
|
+
if (_entries_ != nullptr) {
|
|
99
|
+
Exchange::IDictionary::PathEntry _resultItem__{};
|
|
100
|
+
while (_entries_->Next(_resultItem__) == true) { entries.Add() = _resultItem__; }
|
|
101
|
+
_entries_->Release();
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
return (_errorCode__);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
template<typename MODULE>
|
|
112
|
+
static void Unregister(MODULE& _module__)
|
|
113
|
+
{
|
|
114
|
+
// Unregister methods and properties...
|
|
115
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("get"));
|
|
116
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("set"));
|
|
117
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("pathentries"));
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
namespace Event {
|
|
121
|
+
|
|
122
|
+
// Event: 'modified' - Changes on the subscribed namespace
|
|
123
|
+
template<typename MODULE>
|
|
124
|
+
static void Modified(const MODULE& module_, const string& id_, const JsonData::Dictionary::ModifiedParamsData& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
125
|
+
{
|
|
126
|
+
if (sendIfMethod_ == nullptr) {
|
|
127
|
+
module_.Notify(_T("modified"), params, [&id_](const string&, const string& index_) -> bool {
|
|
128
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
129
|
+
|
|
130
|
+
if (index_.empty() == true) {
|
|
131
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
132
|
+
}
|
|
133
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
|
|
134
|
+
});
|
|
135
|
+
}
|
|
136
|
+
else {
|
|
137
|
+
module_.Notify(_T("modified"), params, sendIfMethod_);
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// Event: 'modified' - Changes on the subscribed namespace
|
|
142
|
+
template<typename MODULE>
|
|
143
|
+
static void Modified(const MODULE& module_, const string& id_, const Core::JSON::String& key, const Core::JSON::String& value, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
144
|
+
{
|
|
145
|
+
JsonData::Dictionary::ModifiedParamsData params_;
|
|
146
|
+
params_.Key = key;
|
|
147
|
+
params_.Value = value;
|
|
148
|
+
|
|
149
|
+
Modified(module_, id_, params_, sendIfMethod_);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
// Event: 'modified' - Changes on the subscribed namespace
|
|
153
|
+
template<typename MODULE>
|
|
154
|
+
static void Modified(const MODULE& module_, const string& id_, const string& key, const string& value, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
155
|
+
{
|
|
156
|
+
JsonData::Dictionary::ModifiedParamsData params_;
|
|
157
|
+
params_.Key = key;
|
|
158
|
+
params_.Value = value;
|
|
159
|
+
|
|
160
|
+
Modified(module_, id_, params_, sendIfMethod_);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
} // namespace Event
|
|
164
|
+
|
|
165
|
+
POP_WARNING()
|
|
166
|
+
POP_WARNING()
|
|
167
|
+
POP_WARNING()
|
|
168
|
+
|
|
169
|
+
} // namespace JDictionary
|
|
170
|
+
|
|
171
|
+
} // namespace Exchange
|
|
172
|
+
|
|
173
|
+
} // namespace Thunder
|
|
174
|
+
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DisplayProperties.h"
|
|
6
|
+
#include <interfaces/IDisplayInfo.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JDisplayProperties {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IDisplayProperties* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JDisplayProperties"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'colorspace' - Provides access to the display's Colour space (chroma subsampling format) (r/o)
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IDisplayProperties::ColourSpaceType>>(_T("colorspace"),
|
|
37
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IDisplayProperties::ColourSpaceType>& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
Exchange::IDisplayProperties::ColourSpaceType _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = _implementation__->ColorSpace(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result = _result_;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
return (_errorCode__);
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
// Property: 'framerate' - Provides access to Frame Rate (r/o)
|
|
52
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IDisplayProperties::FrameRateType>>(_T("framerate"),
|
|
53
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IDisplayProperties::FrameRateType>& result) -> uint32_t {
|
|
54
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
55
|
+
|
|
56
|
+
Exchange::IDisplayProperties::FrameRateType _result_{};
|
|
57
|
+
|
|
58
|
+
_errorCode__ = _implementation__->FrameRate(_result_);
|
|
59
|
+
|
|
60
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
61
|
+
result = _result_;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
return (_errorCode__);
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
// Property: 'colourdepth' - Provides access to display's colour Depth (r/o)
|
|
68
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IDisplayProperties::ColourDepthType>>(_T("colourdepth"),
|
|
69
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IDisplayProperties::ColourDepthType>& result) -> uint32_t {
|
|
70
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
71
|
+
|
|
72
|
+
Exchange::IDisplayProperties::ColourDepthType _result_{};
|
|
73
|
+
|
|
74
|
+
_errorCode__ = _implementation__->ColourDepth(_result_);
|
|
75
|
+
|
|
76
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
77
|
+
result = _result_;
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
return (_errorCode__);
|
|
81
|
+
});
|
|
82
|
+
|
|
83
|
+
// Property: 'colorimetry' - Provides access to display's colorimetry (r/o)
|
|
84
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IDisplayProperties::ColorimetryType>>>(_T("colorimetry"),
|
|
85
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IDisplayProperties::ColorimetryType>>& result) -> uint32_t {
|
|
86
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
87
|
+
|
|
88
|
+
RPC::IIteratorType<Exchange::IDisplayProperties::ColorimetryType, Exchange::ID_COLORIMETRY_ITERATOR>* _result_{};
|
|
89
|
+
|
|
90
|
+
_errorCode__ = _implementation__->Colorimetry(_result_);
|
|
91
|
+
|
|
92
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
93
|
+
result.Set(true);
|
|
94
|
+
|
|
95
|
+
if (_result_ != nullptr) {
|
|
96
|
+
Exchange::IDisplayProperties::ColorimetryType _resultItem__{};
|
|
97
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
98
|
+
_result_->Release();
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
return (_errorCode__);
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
// Property: 'quantizationrange' - Provides access to display's Qauntization Range (r/o)
|
|
106
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IDisplayProperties::QuantizationRangeType>>(_T("quantizationrange"),
|
|
107
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IDisplayProperties::QuantizationRangeType>& result) -> uint32_t {
|
|
108
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
109
|
+
|
|
110
|
+
Exchange::IDisplayProperties::QuantizationRangeType _result_{};
|
|
111
|
+
|
|
112
|
+
_errorCode__ = _implementation__->QuantizationRange(_result_);
|
|
113
|
+
|
|
114
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
115
|
+
result = _result_;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
return (_errorCode__);
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
// Property: 'eotf' - Provides access to display's Electro optical transfer function (r/o)
|
|
122
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IDisplayProperties::EotfType>>(_T("eotf"),
|
|
123
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IDisplayProperties::EotfType>& result) -> uint32_t {
|
|
124
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
125
|
+
|
|
126
|
+
Exchange::IDisplayProperties::EotfType _result_{};
|
|
127
|
+
|
|
128
|
+
_errorCode__ = _implementation__->EOTF(_result_);
|
|
129
|
+
|
|
130
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
131
|
+
result = _result_;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
return (_errorCode__);
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
template<typename MODULE>
|
|
140
|
+
static void Unregister(MODULE& _module__)
|
|
141
|
+
{
|
|
142
|
+
// Unregister methods and properties...
|
|
143
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("colorspace"));
|
|
144
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("framerate"));
|
|
145
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("colourdepth"));
|
|
146
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("colorimetry"));
|
|
147
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("quantizationrange"));
|
|
148
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("eotf"));
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
POP_WARNING()
|
|
152
|
+
POP_WARNING()
|
|
153
|
+
POP_WARNING()
|
|
154
|
+
|
|
155
|
+
} // namespace JDisplayProperties
|
|
156
|
+
|
|
157
|
+
} // namespace Exchange
|
|
158
|
+
|
|
159
|
+
} // namespace Thunder
|
|
160
|
+
|
|
@@ -0,0 +1,187 @@
|
|
|
1
|
+
// Generated automatically from 'IDolby.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_DolbyOutput.h"
|
|
6
|
+
#include <interfaces/IDolby.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace Dolby {
|
|
13
|
+
|
|
14
|
+
namespace JOutput {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, Dolby::IOutput* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JOutput"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register alternative notification names...
|
|
36
|
+
_module__.PluginHost::JSONRPC::RegisterEventAlias(_T("dolby_audiomodechanged"), _T("soundmodechanged"));
|
|
37
|
+
|
|
38
|
+
// Register methods and properties...
|
|
39
|
+
|
|
40
|
+
// Property: 'dolbyatmossupported' - Atmos capabilities of Sink (r/o)
|
|
41
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::Boolean>(_T("dolbyatmossupported"),
|
|
42
|
+
[_implementation__](Core::JSON::Boolean& result) -> uint32_t {
|
|
43
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
44
|
+
|
|
45
|
+
bool _result_{};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->AtmosMetadata(_result_);
|
|
48
|
+
|
|
49
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
50
|
+
result = _result_;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
_module__.PluginHost::JSONRPC::Register(_T("dolby_atmosmetadata"), _T("dolbyatmossupported"));
|
|
57
|
+
|
|
58
|
+
// Property: 'dolbysoundmode' - Sound Mode - Mono/Stereo/Surround (r/o)
|
|
59
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::Dolby::IOutput::SoundModes>>(_T("dolbysoundmode"),
|
|
60
|
+
[_implementation__](Core::JSON::EnumType<Exchange::Dolby::IOutput::SoundModes>& result) -> uint32_t {
|
|
61
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
62
|
+
|
|
63
|
+
Exchange::Dolby::IOutput::SoundModes _result_{};
|
|
64
|
+
|
|
65
|
+
_errorCode__ = _implementation__->SoundMode(_result_);
|
|
66
|
+
|
|
67
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
68
|
+
result = _result_;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
return (_errorCode__);
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
_module__.PluginHost::JSONRPC::Register(_T("dolby_soundmode"), _T("dolbysoundmode"));
|
|
75
|
+
|
|
76
|
+
// Property: 'dolbyatmosoutput' - Enable Atmos Audio Output (w/o)
|
|
77
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("dolbyatmosoutput"),
|
|
78
|
+
[_implementation__](const Core::JSON::Boolean& params) -> uint32_t {
|
|
79
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
80
|
+
|
|
81
|
+
if (params.IsSet() == false) {
|
|
82
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JOutput"), _T("dolbyatmosoutput")));
|
|
83
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
84
|
+
}
|
|
85
|
+
else {
|
|
86
|
+
const bool _params_{params};
|
|
87
|
+
|
|
88
|
+
_errorCode__ = _implementation__->EnableAtmosOutput(_params_);
|
|
89
|
+
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
return (_errorCode__);
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
_module__.PluginHost::JSONRPC::Register(_T("dolby_enableatmosoutput"), _T("dolbyatmosoutput"));
|
|
96
|
+
|
|
97
|
+
// Property: 'dolbymode' - Dolby Mode
|
|
98
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::Dolby::IOutput::Type>, Core::JSON::EnumType<Exchange::Dolby::IOutput::Type>>(_T("dolbymode"),
|
|
99
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::Dolby::IOutput::Type>& params, Core::JSON::EnumType<Exchange::Dolby::IOutput::Type>& result) -> uint32_t {
|
|
100
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
101
|
+
|
|
102
|
+
if (params.IsSet() == false) {
|
|
103
|
+
Exchange::Dolby::IOutput::Type _result_{};
|
|
104
|
+
|
|
105
|
+
_errorCode__ = (static_cast<const Dolby::IOutput*>(_implementation__))->Mode(_result_);
|
|
106
|
+
|
|
107
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
108
|
+
result = _result_;
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
else {
|
|
112
|
+
const Exchange::Dolby::IOutput::Type _params_{params};
|
|
113
|
+
|
|
114
|
+
_errorCode__ = _implementation__->Mode(_params_);
|
|
115
|
+
|
|
116
|
+
result.Null(true);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
return (_errorCode__);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
_module__.PluginHost::JSONRPC::Register(_T("dolby_mode"), _T("dolbymode"));
|
|
123
|
+
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
template<typename MODULE>
|
|
127
|
+
static void Unregister(MODULE& _module__)
|
|
128
|
+
{
|
|
129
|
+
// Unregister methods and properties...
|
|
130
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolbyatmossupported"));
|
|
131
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolby_atmosmetadata"));
|
|
132
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolbysoundmode"));
|
|
133
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolby_soundmode"));
|
|
134
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolbyatmosoutput"));
|
|
135
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolby_enableatmosoutput"));
|
|
136
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolbymode"));
|
|
137
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dolby_mode"));
|
|
138
|
+
|
|
139
|
+
// Unegister alternative notification names...
|
|
140
|
+
_module__.PluginHost::JSONRPC::UnregisterEventAlias(_T("dolby_audiomodechanged"), _T("soundmodechanged"));
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
namespace Event {
|
|
144
|
+
|
|
145
|
+
// Event: 'soundmodechanged' - Signal audio mode change
|
|
146
|
+
template<typename MODULE>
|
|
147
|
+
static void AudioModeChanged(const MODULE& module_, const JsonData::Dolby::Output::AudioModeChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
148
|
+
{
|
|
149
|
+
module_.Notify(_T("soundmodechanged"), params, sendIfMethod_);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
// Event: 'soundmodechanged' - Signal audio mode change
|
|
153
|
+
template<typename MODULE>
|
|
154
|
+
static void AudioModeChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::Dolby::IOutput::SoundModes>& mode, const Core::JSON::Boolean& enabled, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
155
|
+
{
|
|
156
|
+
JsonData::Dolby::Output::AudioModeChangedParamsData params_;
|
|
157
|
+
params_.Mode = mode;
|
|
158
|
+
params_.Enabled = enabled;
|
|
159
|
+
|
|
160
|
+
AudioModeChanged(module_, params_, sendIfMethod_);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
// Event: 'soundmodechanged' - Signal audio mode change
|
|
164
|
+
template<typename MODULE>
|
|
165
|
+
static void AudioModeChanged(const MODULE& module_, const Dolby::IOutput::SoundModes mode, const bool enabled, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
166
|
+
{
|
|
167
|
+
JsonData::Dolby::Output::AudioModeChangedParamsData params_;
|
|
168
|
+
params_.Mode = mode;
|
|
169
|
+
params_.Enabled = enabled;
|
|
170
|
+
|
|
171
|
+
AudioModeChanged(module_, params_, sendIfMethod_);
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
} // namespace Event
|
|
175
|
+
|
|
176
|
+
POP_WARNING()
|
|
177
|
+
POP_WARNING()
|
|
178
|
+
POP_WARNING()
|
|
179
|
+
|
|
180
|
+
} // namespace JOutput
|
|
181
|
+
|
|
182
|
+
} // namespace Dolby
|
|
183
|
+
|
|
184
|
+
} // namespace Exchange
|
|
185
|
+
|
|
186
|
+
} // namespace Thunder
|
|
187
|
+
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
// Generated automatically from 'IContentProtection.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ErrorToString.h"
|
|
6
|
+
#include <interfaces/IContentProtection.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JErrorToString {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IErrorToString* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JErrorToString"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'errorToString'
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ErrorToString::ErrorToStringParamsData, Core::JSON::String>(_T("errorToString"),
|
|
37
|
+
[_implementation__](const JsonData::ErrorToString::ErrorToStringParamsData& params, Core::JSON::String& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JErrorToString"), _T("errorToString")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const int32_t _code_{params.Code};
|
|
46
|
+
string _result_{};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->ErrorToString(_code_, _result_);
|
|
49
|
+
|
|
50
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
51
|
+
result = _result_;
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
return (_errorCode__);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
template<typename MODULE>
|
|
61
|
+
static void Unregister(MODULE& _module__)
|
|
62
|
+
{
|
|
63
|
+
// Unregister methods and properties...
|
|
64
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("errorToString"));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
POP_WARNING()
|
|
68
|
+
POP_WARNING()
|
|
69
|
+
POP_WARNING()
|
|
70
|
+
|
|
71
|
+
} // namespace JErrorToString
|
|
72
|
+
|
|
73
|
+
} // namespace Exchange
|
|
74
|
+
|
|
75
|
+
} // namespace Thunder
|
|
76
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'FirmwareControl.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_FirmwareControl.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JFirmwareControl {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JFirmwareControl
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/IDisplayInfo.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JGraphicsProperties {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IGraphicsProperties* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JGraphicsProperties"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Property: 'totalgpuram' - Total GPU DRAM memory (in bytes) (r/o)
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt64>(_T("totalgpuram"),
|
|
36
|
+
[_implementation__](Core::JSON::DecUInt64& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
uint64_t _result_{};
|
|
40
|
+
|
|
41
|
+
_errorCode__ = _implementation__->TotalGpuRam(_result_);
|
|
42
|
+
|
|
43
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
44
|
+
result = _result_;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
return (_errorCode__);
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
// Property: 'freegpuram' - Free GPU DRAM memory (in bytes) (r/o)
|
|
51
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt64>(_T("freegpuram"),
|
|
52
|
+
[_implementation__](Core::JSON::DecUInt64& result) -> uint32_t {
|
|
53
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
54
|
+
|
|
55
|
+
uint64_t _result_{};
|
|
56
|
+
|
|
57
|
+
_errorCode__ = _implementation__->FreeGpuRam(_result_);
|
|
58
|
+
|
|
59
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
60
|
+
result = _result_;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
return (_errorCode__);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
template<typename MODULE>
|
|
69
|
+
static void Unregister(MODULE& _module__)
|
|
70
|
+
{
|
|
71
|
+
// Unregister methods and properties...
|
|
72
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("totalgpuram"));
|
|
73
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("freegpuram"));
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
POP_WARNING()
|
|
78
|
+
POP_WARNING()
|
|
79
|
+
|
|
80
|
+
} // namespace JGraphicsProperties
|
|
81
|
+
|
|
82
|
+
} // namespace Exchange
|
|
83
|
+
|
|
84
|
+
} // namespace Thunder
|
|
85
|
+
|
|
@@ -0,0 +1,115 @@
|
|
|
1
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_HDRProperties.h"
|
|
6
|
+
#include <interfaces/IDisplayInfo.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JHDRProperties {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IHDRProperties* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JHDRProperties"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'tvcapabilities' - HDR formats supported by TV (r/o)
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>>>(_T("tvcapabilities"),
|
|
37
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>>& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
RPC::IIteratorType<Exchange::IHDRProperties::HDRType, Exchange::ID_HDR_ITERATOR>* _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = _implementation__->TVCapabilities(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result.Set(true);
|
|
46
|
+
|
|
47
|
+
if (_result_ != nullptr) {
|
|
48
|
+
Exchange::IHDRProperties::HDRType _resultItem__{};
|
|
49
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
50
|
+
_result_->Release();
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Property: 'stbcapabilities' - HDR formats supported by STB (r/o)
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>>>(_T("stbcapabilities"),
|
|
59
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>>& result) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
RPC::IIteratorType<Exchange::IHDRProperties::HDRType, Exchange::ID_HDR_ITERATOR>* _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->STBCapabilities(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result.Set(true);
|
|
68
|
+
|
|
69
|
+
if (_result_ != nullptr) {
|
|
70
|
+
Exchange::IHDRProperties::HDRType _resultItem__{};
|
|
71
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
72
|
+
_result_->Release();
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
return (_errorCode__);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
// Property: 'hdrsetting' - HDR format in use (r/o)
|
|
80
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>>(_T("hdrsetting"),
|
|
81
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IHDRProperties::HDRType>& result) -> uint32_t {
|
|
82
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
83
|
+
|
|
84
|
+
Exchange::IHDRProperties::HDRType _result_{};
|
|
85
|
+
|
|
86
|
+
_errorCode__ = _implementation__->HDRSetting(_result_);
|
|
87
|
+
|
|
88
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
89
|
+
result = _result_;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
return (_errorCode__);
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
template<typename MODULE>
|
|
98
|
+
static void Unregister(MODULE& _module__)
|
|
99
|
+
{
|
|
100
|
+
// Unregister methods and properties...
|
|
101
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("tvcapabilities"));
|
|
102
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("stbcapabilities"));
|
|
103
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("hdrsetting"));
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
POP_WARNING()
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
POP_WARNING()
|
|
109
|
+
|
|
110
|
+
} // namespace JHDRProperties
|
|
111
|
+
|
|
112
|
+
} // namespace Exchange
|
|
113
|
+
|
|
114
|
+
} // namespace Thunder
|
|
115
|
+
|
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
// Generated automatically from 'IIOConnector.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_IOConnector.h"
|
|
6
|
+
#include <interfaces/IIOConnector.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JIOConnector {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IIOConnector* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JIOConnector"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Indexed Property: 'pin' - GPIO pin value
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::IOConnector::PinInfo, Core::JSON::DecSInt32, std::function<uint32_t(const string&, const JsonData::IOConnector::PinInfo&, Core::JSON::DecSInt32&)>>(_T("pin"),
|
|
37
|
+
[_implementation__](const string& id, const JsonData::IOConnector::PinInfo& params, Core::JSON::DecSInt32& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
uint16_t _idConv__{};
|
|
41
|
+
|
|
42
|
+
if (id.empty() == true) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JIOConnector"), _T("pin")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const bool _idConvResult__ = Core::FromString(id, _idConv__);
|
|
48
|
+
|
|
49
|
+
if (_idConvResult__ == false) {
|
|
50
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JIOConnector"), _T("pin")));
|
|
51
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
|
|
57
|
+
if (params.IsSet() == false) {
|
|
58
|
+
int32_t _result_{};
|
|
59
|
+
|
|
60
|
+
_errorCode__ = (static_cast<const IIOConnector*>(_implementation__))->Pin(_idConv__, _result_);
|
|
61
|
+
|
|
62
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
63
|
+
result = _result_;
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
else {
|
|
67
|
+
|
|
68
|
+
if (params.IsDataValid() == false) {
|
|
69
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JIOConnector"), _T("pin")));
|
|
70
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
71
|
+
}
|
|
72
|
+
else {
|
|
73
|
+
const int32_t _value_{params.Value};
|
|
74
|
+
|
|
75
|
+
_errorCode__ = _implementation__->Pin(_idConv__, _value_);
|
|
76
|
+
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
result.Null(true);
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
return (_errorCode__);
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
template<typename MODULE>
|
|
89
|
+
static void Unregister(MODULE& _module__)
|
|
90
|
+
{
|
|
91
|
+
// Unregister methods and properties...
|
|
92
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("pin"));
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
namespace Event {
|
|
96
|
+
|
|
97
|
+
// Event: 'activity' - Notifies about GPIO pin activity
|
|
98
|
+
template<typename MODULE>
|
|
99
|
+
static void Activity(const MODULE& module_, const uint16_t& id_, const JsonData::IOConnector::PinInfo& params, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
100
|
+
{
|
|
101
|
+
if (sendIfMethod_ == nullptr) {
|
|
102
|
+
module_.Notify(_T("activity"), params, [&id_](const string&, const string& index_) -> bool {
|
|
103
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
104
|
+
uint16_t _indexConv__{};
|
|
105
|
+
|
|
106
|
+
if (index_.empty() == true) {
|
|
107
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
108
|
+
}
|
|
109
|
+
else {
|
|
110
|
+
const bool _indexConvResult__ = Core::FromString(index_, _indexConv__);
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == _indexConv__));
|
|
114
|
+
});
|
|
115
|
+
}
|
|
116
|
+
else {
|
|
117
|
+
module_.Notify(_T("activity"), params, sendIfMethod_);
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
// Event: 'activity' - Notifies about GPIO pin activity
|
|
122
|
+
template<typename MODULE>
|
|
123
|
+
static void Activity(const MODULE& module_, const uint16_t& id_, const Core::JSON::DecSInt32& value, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
124
|
+
{
|
|
125
|
+
JsonData::IOConnector::PinInfo params_;
|
|
126
|
+
params_.Value = value;
|
|
127
|
+
|
|
128
|
+
Activity(module_, id_, params_, sendIfMethod_);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// Event: 'activity' - Notifies about GPIO pin activity
|
|
132
|
+
template<typename MODULE>
|
|
133
|
+
static void Activity(const MODULE& module_, const uint16_t& id_, const int32_t value, typename MODULE::SendIfMethodIndexed sendIfMethod_ = nullptr)
|
|
134
|
+
{
|
|
135
|
+
JsonData::IOConnector::PinInfo params_;
|
|
136
|
+
params_.Value = value;
|
|
137
|
+
|
|
138
|
+
Activity(module_, id_, params_, sendIfMethod_);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
} // namespace Event
|
|
142
|
+
|
|
143
|
+
POP_WARNING()
|
|
144
|
+
POP_WARNING()
|
|
145
|
+
POP_WARNING()
|
|
146
|
+
|
|
147
|
+
} // namespace JIOConnector
|
|
148
|
+
|
|
149
|
+
} // namespace Exchange
|
|
150
|
+
|
|
151
|
+
} // namespace Thunder
|
|
152
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'InputSwitch.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_InputSwitch.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JInputSwitch {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JInputSwitch
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'LISA.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_LISA.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JLISA {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JLISA
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
// Generated automatically from 'ILanguageTag.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/ILanguageTag.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JLanguageTag {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, ILanguageTag* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JLanguageTag"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Property: 'language' - Current application user interface language tag
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("language"),
|
|
36
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
if (params.IsSet() == false) {
|
|
40
|
+
string _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = (static_cast<const ILanguageTag*>(_implementation__))->Language(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result = _result_;
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
else {
|
|
49
|
+
const string _params_{params};
|
|
50
|
+
|
|
51
|
+
_errorCode__ = _implementation__->Language(_params_);
|
|
52
|
+
|
|
53
|
+
result.Null(true);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
template<typename MODULE>
|
|
62
|
+
static void Unregister(MODULE& _module__)
|
|
63
|
+
{
|
|
64
|
+
// Unregister methods and properties...
|
|
65
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("language"));
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
namespace Event {
|
|
69
|
+
|
|
70
|
+
// Event: 'languagechanged' - Notify that the Language tag has been changed
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void LanguageChanged(const MODULE& module_, const Core::JSON::String& language, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
73
|
+
{
|
|
74
|
+
module_.Notify(_T("languagechanged"), language, sendIfMethod_);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
// Event: 'languagechanged' - Notify that the Language tag has been changed
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void LanguageChanged(const MODULE& module_, const string& language, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
80
|
+
{
|
|
81
|
+
Core::JSON::String params_;
|
|
82
|
+
params_ = language;
|
|
83
|
+
|
|
84
|
+
LanguageChanged(module_, params_, sendIfMethod_);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
} // namespace Event
|
|
88
|
+
|
|
89
|
+
POP_WARNING()
|
|
90
|
+
POP_WARNING()
|
|
91
|
+
POP_WARNING()
|
|
92
|
+
|
|
93
|
+
} // namespace JLanguageTag
|
|
94
|
+
|
|
95
|
+
} // namespace Exchange
|
|
96
|
+
|
|
97
|
+
} // namespace Thunder
|
|
98
|
+
|
|
@@ -0,0 +1,97 @@
|
|
|
1
|
+
// Generated automatically from 'ILocationSync.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_LocationSync.h"
|
|
6
|
+
#include <interfaces/ILocationSync.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JLocationSync {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ILocationSync* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JLocationSync"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register alternative notification names...
|
|
34
|
+
_module__.PluginHost::JSONRPC::RegisterEventAlias(_T("locationchange"), _T("updated"));
|
|
35
|
+
|
|
36
|
+
// Register methods and properties...
|
|
37
|
+
|
|
38
|
+
// Method: 'sync' - Synchronize the location
|
|
39
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("sync"),
|
|
40
|
+
[_implementation__]() -> uint32_t {
|
|
41
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
42
|
+
|
|
43
|
+
_errorCode__ = _implementation__->Sync();
|
|
44
|
+
|
|
45
|
+
return (_errorCode__);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
// Property: 'location' - Get information about the location (r/o)
|
|
49
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::LocationSync::LocationInfoData>(_T("location"),
|
|
50
|
+
[_implementation__](JsonData::LocationSync::LocationInfoData& result) -> uint32_t {
|
|
51
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
52
|
+
|
|
53
|
+
Exchange::ILocationSync::LocationInfo _result_{};
|
|
54
|
+
|
|
55
|
+
_errorCode__ = _implementation__->Location(_result_);
|
|
56
|
+
|
|
57
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
58
|
+
result = _result_;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
return (_errorCode__);
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
template<typename MODULE>
|
|
67
|
+
static void Unregister(MODULE& _module__)
|
|
68
|
+
{
|
|
69
|
+
// Unregister methods and properties...
|
|
70
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sync"));
|
|
71
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("location"));
|
|
72
|
+
|
|
73
|
+
// Unegister alternative notification names...
|
|
74
|
+
_module__.PluginHost::JSONRPC::UnregisterEventAlias(_T("locationchange"), _T("updated"));
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
namespace Event {
|
|
78
|
+
|
|
79
|
+
// Event: 'updated' - Signals a location change
|
|
80
|
+
template<typename MODULE>
|
|
81
|
+
static void Updated(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
82
|
+
{
|
|
83
|
+
module_.Notify(_T("updated"), sendIfMethod_);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
} // namespace Event
|
|
87
|
+
|
|
88
|
+
POP_WARNING()
|
|
89
|
+
POP_WARNING()
|
|
90
|
+
POP_WARNING()
|
|
91
|
+
|
|
92
|
+
} // namespace JLocationSync
|
|
93
|
+
|
|
94
|
+
} // namespace Exchange
|
|
95
|
+
|
|
96
|
+
} // namespace Thunder
|
|
97
|
+
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
// Generated automatically from 'IMath.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Math.h"
|
|
6
|
+
#include <interfaces/IMath.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JMath {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IMath* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMath"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'add' - Perform addition on given inputs
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Math::AddParamsInfo, Core::JSON::DecUInt16>(_T("add"),
|
|
37
|
+
[_implementation__](const JsonData::Math::AddParamsInfo& params, Core::JSON::DecUInt16& sum) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMath"), _T("add")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint16_t _a_{params.A};
|
|
46
|
+
const uint16_t _b_{params.B};
|
|
47
|
+
uint16_t _sum_{};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Add(_a_, _b_, _sum_);
|
|
50
|
+
|
|
51
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
52
|
+
sum = _sum_;
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
// Method: 'sub' - Perform subtraction on given inputs
|
|
60
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Math::AddParamsInfo, Core::JSON::DecUInt16>(_T("sub"),
|
|
61
|
+
[_implementation__](const JsonData::Math::AddParamsInfo& params, Core::JSON::DecUInt16& sum) -> uint32_t {
|
|
62
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
63
|
+
|
|
64
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
65
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMath"), _T("sub")));
|
|
66
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
67
|
+
}
|
|
68
|
+
else {
|
|
69
|
+
const uint16_t _a_{params.A};
|
|
70
|
+
const uint16_t _b_{params.B};
|
|
71
|
+
uint16_t _sum_{};
|
|
72
|
+
|
|
73
|
+
_errorCode__ = _implementation__->Sub(_a_, _b_, _sum_);
|
|
74
|
+
|
|
75
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
76
|
+
sum = _sum_;
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
return (_errorCode__);
|
|
81
|
+
});
|
|
82
|
+
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
template<typename MODULE>
|
|
86
|
+
static void Unregister(MODULE& _module__)
|
|
87
|
+
{
|
|
88
|
+
// Unregister methods and properties...
|
|
89
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("add"));
|
|
90
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("sub"));
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
POP_WARNING()
|
|
94
|
+
POP_WARNING()
|
|
95
|
+
POP_WARNING()
|
|
96
|
+
|
|
97
|
+
} // namespace JMath
|
|
98
|
+
|
|
99
|
+
} // namespace Exchange
|
|
100
|
+
|
|
101
|
+
} // namespace Thunder
|
|
102
|
+
|
|
@@ -0,0 +1,201 @@
|
|
|
1
|
+
// Generated automatically from 'IMemoryMonitor.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_MemoryMonitor.h"
|
|
6
|
+
#include <interfaces/IMemoryMonitor.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JMemoryMonitor {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IMemoryMonitor* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMemoryMonitor"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'resetstatistics' - Resets memory statistics for a given service
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::MemoryMonitor::ResetStatisticsParamsData, void>(_T("resetstatistics"),
|
|
37
|
+
[_implementation__](const JsonData::MemoryMonitor::ResetStatisticsParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("resetstatistics")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _callsign_{params.Callsign};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->ResetStatistics(_callsign_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Indexed Property: 'restartinglimits' - Limits of restarting of a service
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::MemoryMonitor::RestartingLimitsData, JsonData::MemoryMonitor::RestartInfo, std::function<uint32_t(const string&, const JsonData::MemoryMonitor::RestartingLimitsData&, JsonData::MemoryMonitor::RestartInfo&)>>(_T("restartinglimits"),
|
|
56
|
+
[_implementation__](const string& callsign, const JsonData::MemoryMonitor::RestartingLimitsData& params, JsonData::MemoryMonitor::RestartInfo& result) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
if (callsign.empty() == true) {
|
|
60
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("restartinglimits")));
|
|
61
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
65
|
+
|
|
66
|
+
if (params.IsSet() == false) {
|
|
67
|
+
Exchange::IMemoryMonitor::Restart _result_{};
|
|
68
|
+
|
|
69
|
+
_errorCode__ = (static_cast<const IMemoryMonitor*>(_implementation__))->RestartingLimits(callsign, _result_);
|
|
70
|
+
|
|
71
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
72
|
+
result.Set(true);
|
|
73
|
+
result = _result_;
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
else {
|
|
77
|
+
|
|
78
|
+
if (params.IsDataValid() == false) {
|
|
79
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("restartinglimits")));
|
|
80
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
81
|
+
}
|
|
82
|
+
else {
|
|
83
|
+
const Exchange::IMemoryMonitor::Restart _value_(params.Value);
|
|
84
|
+
|
|
85
|
+
_errorCode__ = _implementation__->RestartingLimits(callsign, _value_);
|
|
86
|
+
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
result.Null(true);
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
return (_errorCode__);
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
// Property: 'observables' - List of services watched by the Monitor (r/o)
|
|
97
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("observables"),
|
|
98
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
99
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
100
|
+
|
|
101
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
102
|
+
|
|
103
|
+
_errorCode__ = _implementation__->Observables(_result_);
|
|
104
|
+
|
|
105
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
106
|
+
result.Set(true);
|
|
107
|
+
|
|
108
|
+
if (_result_ != nullptr) {
|
|
109
|
+
string _resultItem__{};
|
|
110
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
111
|
+
_result_->Release();
|
|
112
|
+
}
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
return (_errorCode__);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
// Indexed Property: 'measurementdata' - Memory statistics for a given service (r/o)
|
|
119
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::MemoryMonitor::StatisticsData, std::function<uint32_t(const string&, JsonData::MemoryMonitor::StatisticsData&)>>(_T("measurementdata"),
|
|
120
|
+
[_implementation__](const string& callsign, JsonData::MemoryMonitor::StatisticsData& result) -> uint32_t {
|
|
121
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
122
|
+
|
|
123
|
+
if (callsign.empty() == true) {
|
|
124
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("measurementdata")));
|
|
125
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
129
|
+
Exchange::IMemoryMonitor::Statistics _result_{};
|
|
130
|
+
|
|
131
|
+
_errorCode__ = _implementation__->MeasurementData(callsign, _result_);
|
|
132
|
+
|
|
133
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
134
|
+
result.Set(true);
|
|
135
|
+
result = _result_;
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
return (_errorCode__);
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
template<typename MODULE>
|
|
145
|
+
static void Unregister(MODULE& _module__)
|
|
146
|
+
{
|
|
147
|
+
// Unregister methods and properties...
|
|
148
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("resetstatistics"));
|
|
149
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("restartinglimits"));
|
|
150
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("observables"));
|
|
151
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("measurementdata"));
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
namespace Event {
|
|
155
|
+
|
|
156
|
+
// Event: 'statuschanged' - Signals an action taken by the Monitor
|
|
157
|
+
template<typename MODULE>
|
|
158
|
+
static void StatusChanged(const MODULE& module_, const JsonData::MemoryMonitor::StatusChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
159
|
+
{
|
|
160
|
+
module_.Notify(_T("statuschanged"), params, sendIfMethod_);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
// Event: 'statuschanged' - Signals an action taken by the Monitor
|
|
164
|
+
template<typename MODULE>
|
|
165
|
+
static void StatusChanged(const MODULE& module_, const Core::JSON::String& callsign, const Core::JSON::EnumType<Exchange::IMemoryMonitor::INotification::action>& action, const Core::JSON::EnumType<Exchange::IMemoryMonitor::INotification::reason>& reason, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
166
|
+
{
|
|
167
|
+
JsonData::MemoryMonitor::StatusChangedParamsData params_;
|
|
168
|
+
params_.Callsign = callsign;
|
|
169
|
+
params_.Action = action;
|
|
170
|
+
params_.Reason = reason;
|
|
171
|
+
|
|
172
|
+
StatusChanged(module_, params_, sendIfMethod_);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
// Event: 'statuschanged' - Signals an action taken by the Monitor
|
|
176
|
+
template<typename MODULE>
|
|
177
|
+
static void StatusChanged(const MODULE& module_, const string& callsign, const IMemoryMonitor::INotification::action action, const Core::OptionalType<IMemoryMonitor::INotification::reason>& reason, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
178
|
+
{
|
|
179
|
+
JsonData::MemoryMonitor::StatusChangedParamsData params_;
|
|
180
|
+
params_.Callsign = callsign;
|
|
181
|
+
params_.Action = action;
|
|
182
|
+
|
|
183
|
+
if (reason.IsSet() == true) {
|
|
184
|
+
params_.Reason = reason.Value();
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
StatusChanged(module_, params_, sendIfMethod_);
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
} // namespace Event
|
|
191
|
+
|
|
192
|
+
POP_WARNING()
|
|
193
|
+
POP_WARNING()
|
|
194
|
+
POP_WARNING()
|
|
195
|
+
|
|
196
|
+
} // namespace JMemoryMonitor
|
|
197
|
+
|
|
198
|
+
} // namespace Exchange
|
|
199
|
+
|
|
200
|
+
} // namespace Thunder
|
|
201
|
+
|
|
@@ -0,0 +1,128 @@
|
|
|
1
|
+
// Generated automatically from 'IMessagingControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_MessagingControl.h"
|
|
6
|
+
#include <interfaces/IMessagingControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JMessagingControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IMessagingControl* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMessagingControl"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'enable' - Enables/disables a message control
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::MessagingControl::ControlInfo, void>(_T("enable"),
|
|
37
|
+
[_implementation__](const JsonData::MessagingControl::ControlInfo& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessagingControl"), _T("enable")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const Exchange::IMessagingControl::messagetype _type_{params.Type};
|
|
46
|
+
const string _category_{params.Category};
|
|
47
|
+
const string _module_{params.Module};
|
|
48
|
+
const bool _enabled_{params.Enabled};
|
|
49
|
+
|
|
50
|
+
_errorCode__ = _implementation__->Enable(_type_, _category_, _module_, _enabled_);
|
|
51
|
+
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Property: 'modules' - Retrieves a list of current message modules (r/o)
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("modules"),
|
|
59
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->Modules(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result.Set(true);
|
|
68
|
+
|
|
69
|
+
if (_result_ != nullptr) {
|
|
70
|
+
string _resultItem__{};
|
|
71
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
72
|
+
_result_->Release();
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
return (_errorCode__);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
// Indexed Property: 'controls' - Retrieves a list of current message controls for a specific module (r/o)
|
|
80
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::MessagingControl::ControlInfo>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::MessagingControl::ControlInfo>&)>>(_T("controls"),
|
|
81
|
+
[_implementation__](const string& module, Core::JSON::ArrayType<JsonData::MessagingControl::ControlInfo>& result) -> uint32_t {
|
|
82
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
83
|
+
|
|
84
|
+
if (module.empty() == true) {
|
|
85
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JMessagingControl"), _T("controls")));
|
|
86
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
90
|
+
RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>* _result_{};
|
|
91
|
+
|
|
92
|
+
_errorCode__ = _implementation__->Controls(module, _result_);
|
|
93
|
+
|
|
94
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
95
|
+
result.Set(true);
|
|
96
|
+
|
|
97
|
+
if (_result_ != nullptr) {
|
|
98
|
+
Exchange::IMessagingControl::Control _resultItem__{};
|
|
99
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
100
|
+
_result_->Release();
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
return (_errorCode__);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
template<typename MODULE>
|
|
111
|
+
static void Unregister(MODULE& _module__)
|
|
112
|
+
{
|
|
113
|
+
// Unregister methods and properties...
|
|
114
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("enable"));
|
|
115
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("modules"));
|
|
116
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("controls"));
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
POP_WARNING()
|
|
120
|
+
POP_WARNING()
|
|
121
|
+
POP_WARNING()
|
|
122
|
+
|
|
123
|
+
} // namespace JMessagingControl
|
|
124
|
+
|
|
125
|
+
} // namespace Exchange
|
|
126
|
+
|
|
127
|
+
} // namespace Thunder
|
|
128
|
+
|
|
@@ -0,0 +1,347 @@
|
|
|
1
|
+
// Generated automatically from 'IMessenger.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Messenger.h"
|
|
6
|
+
#include <interfaces/IMessenger.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JSONRPC {
|
|
13
|
+
|
|
14
|
+
namespace JMessenger {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
struct IHandler {
|
|
25
|
+
virtual ~IHandler() = default;
|
|
26
|
+
virtual void OnRoomUpdateEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
27
|
+
virtual void OnUserUpdateEventRegistration(const string& client, const PluginHost::JSONRPCSupportsEventStatus::Status status) = 0;
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
31
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
32
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
33
|
+
|
|
34
|
+
template<typename MODULE>
|
|
35
|
+
static void Register(MODULE& _module__, IMessenger* _implementation__, IHandler* _handler_)
|
|
36
|
+
{
|
|
37
|
+
ASSERT(_implementation__ != nullptr);
|
|
38
|
+
ASSERT(_handler_ != nullptr);
|
|
39
|
+
|
|
40
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMessenger"), Version::Major, Version::Minor, Version::Patch);
|
|
41
|
+
|
|
42
|
+
// Register methods and properties...
|
|
43
|
+
|
|
44
|
+
// Method: 'join' - Joins a messaging room
|
|
45
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::JoinParamsData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Messenger::JoinParamsData&, Core::JSON::String&)>>(_T("join"),
|
|
46
|
+
[_implementation__](const Core::JSONRPC::Context& context_, const JsonData::Messenger::JoinParamsData& params, Core::JSON::String& roomId) -> uint32_t {
|
|
47
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
48
|
+
|
|
49
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
50
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("join")));
|
|
51
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
52
|
+
}
|
|
53
|
+
else {
|
|
54
|
+
const string _room_{params.Room};
|
|
55
|
+
const string _user_{params.User};
|
|
56
|
+
const Exchange::JSONRPC::IMessenger::security _secure_{params.Secure};
|
|
57
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _acl_{};
|
|
58
|
+
std::list<string> _aclElements_{};
|
|
59
|
+
auto _aclIterator_ = params.Acl.Elements();
|
|
60
|
+
while (_aclIterator_.Next() == true) { _aclElements_.push_back(_aclIterator_.Current()); }
|
|
61
|
+
using _aclIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
|
|
62
|
+
_acl_ = Core::ServiceType<_aclIteratorImplType_>::Create<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_aclElements_));
|
|
63
|
+
ASSERT(_acl_ != nullptr);
|
|
64
|
+
|
|
65
|
+
string _roomId_{};
|
|
66
|
+
|
|
67
|
+
_errorCode__ = _implementation__->Join(context_, _room_, _user_, _secure_, _acl_, _roomId_);
|
|
68
|
+
if (_acl_ != nullptr) {
|
|
69
|
+
_acl_->Release();
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
73
|
+
roomId = _roomId_;
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
return (_errorCode__);
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
// Method: 'leave' - Leaves a messaging room
|
|
81
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::LeaveParamsData, void>(_T("leave"),
|
|
82
|
+
[_implementation__](const JsonData::Messenger::LeaveParamsData& params) -> uint32_t {
|
|
83
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
84
|
+
|
|
85
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
86
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("leave")));
|
|
87
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
88
|
+
}
|
|
89
|
+
else {
|
|
90
|
+
const string _roomId_{params.RoomId};
|
|
91
|
+
|
|
92
|
+
_errorCode__ = _implementation__->Leave(_roomId_);
|
|
93
|
+
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
return (_errorCode__);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
// Method: 'send' - Sends a message to a messaging room
|
|
100
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::SendParamsData, void>(_T("send"),
|
|
101
|
+
[_implementation__](const JsonData::Messenger::SendParamsData& params) -> uint32_t {
|
|
102
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
103
|
+
|
|
104
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
105
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("send")));
|
|
106
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
107
|
+
}
|
|
108
|
+
else {
|
|
109
|
+
const string _roomId_{params.RoomId};
|
|
110
|
+
const string _message_{params.Message};
|
|
111
|
+
|
|
112
|
+
_errorCode__ = _implementation__->Send(_roomId_, _message_);
|
|
113
|
+
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
return (_errorCode__);
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
// Register event status listeners...
|
|
120
|
+
|
|
121
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("roomupdate"),
|
|
122
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
123
|
+
_handler_->OnRoomUpdateEventRegistration(client_, status_);
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::RegisterEventStatusListener(_T("userupdate"),
|
|
127
|
+
[_handler_](const uint32_t, const string&, const string& client_, const string&, const PluginHost::JSONRPCSupportsEventStatus::Status status_) {
|
|
128
|
+
_handler_->OnUserUpdateEventRegistration(client_, status_);
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
template<typename MODULE>
|
|
134
|
+
static void Unregister(MODULE& _module__)
|
|
135
|
+
{
|
|
136
|
+
// Unregister methods and properties...
|
|
137
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("join"));
|
|
138
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("leave"));
|
|
139
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("send"));
|
|
140
|
+
|
|
141
|
+
// Unregister event status listeners...
|
|
142
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("roomupdate"));
|
|
143
|
+
_module__.PluginHost::JSONRPCSupportsEventStatus::UnregisterEventStatusListener(_T("userupdate"));
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
namespace Event {
|
|
147
|
+
|
|
148
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
149
|
+
template<typename MODULE>
|
|
150
|
+
static void RoomUpdate(const MODULE& module_, const JsonData::Messenger::RoomUpdateParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
151
|
+
{
|
|
152
|
+
module_.Notify(_T("roomupdate"), params, sendIfMethod_);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
156
|
+
template<typename MODULE>
|
|
157
|
+
static void RoomUpdate(const MODULE& module_, const JsonData::Messenger::RoomUpdateParamsData& params, const string& client_)
|
|
158
|
+
{
|
|
159
|
+
module_.Notify(_T("roomupdate"), params, [&client_](const string& designator_) -> bool {
|
|
160
|
+
return ((client_ == designator_));
|
|
161
|
+
});
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
165
|
+
template<typename MODULE>
|
|
166
|
+
static void RoomUpdate(const MODULE& module_, const Core::JSON::String& room, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::roomupdate>& action, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::security>& secure, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
167
|
+
{
|
|
168
|
+
JsonData::Messenger::RoomUpdateParamsData params_;
|
|
169
|
+
params_.Room = room;
|
|
170
|
+
params_.Action = action;
|
|
171
|
+
params_.Secure = secure;
|
|
172
|
+
|
|
173
|
+
RoomUpdate(module_, params_, sendIfMethod_);
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
177
|
+
template<typename MODULE>
|
|
178
|
+
static void RoomUpdate(const MODULE& module_, const Core::JSON::String& room, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::roomupdate>& action, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::security>& secure, const string& client_)
|
|
179
|
+
{
|
|
180
|
+
JsonData::Messenger::RoomUpdateParamsData params_;
|
|
181
|
+
params_.Room = room;
|
|
182
|
+
params_.Action = action;
|
|
183
|
+
params_.Secure = secure;
|
|
184
|
+
|
|
185
|
+
RoomUpdate(module_, params_, client_);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
189
|
+
template<typename MODULE>
|
|
190
|
+
static void RoomUpdate(const MODULE& module_, const string& room, const IMessenger::INotification::roomupdate action, const IMessenger::security secure, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
191
|
+
{
|
|
192
|
+
JsonData::Messenger::RoomUpdateParamsData params_;
|
|
193
|
+
params_.Room = room;
|
|
194
|
+
params_.Action = action;
|
|
195
|
+
params_.Secure = secure;
|
|
196
|
+
|
|
197
|
+
RoomUpdate(module_, params_, sendIfMethod_);
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
// Event: 'roomupdate' - Notifies of room status changes
|
|
201
|
+
template<typename MODULE>
|
|
202
|
+
static void RoomUpdate(const MODULE& module_, const string& room, const IMessenger::INotification::roomupdate action, const IMessenger::security secure, const string& client_)
|
|
203
|
+
{
|
|
204
|
+
JsonData::Messenger::RoomUpdateParamsData params_;
|
|
205
|
+
params_.Room = room;
|
|
206
|
+
params_.Action = action;
|
|
207
|
+
params_.Secure = secure;
|
|
208
|
+
|
|
209
|
+
RoomUpdate(module_, params_, client_);
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
213
|
+
template<typename MODULE>
|
|
214
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const JsonData::Messenger::UserUpdateParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
215
|
+
{
|
|
216
|
+
if (sendIfMethod_ == nullptr) {
|
|
217
|
+
module_.Notify(_T("userupdate"), params, [&id_](const string& designator_) -> bool {
|
|
218
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
219
|
+
const string index_ = designator_.substr(0, designator_.find('.'));
|
|
220
|
+
|
|
221
|
+
if (index_.empty() == true) {
|
|
222
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
223
|
+
}
|
|
224
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
|
|
225
|
+
});
|
|
226
|
+
}
|
|
227
|
+
else {
|
|
228
|
+
module_.Notify(_T("userupdate"), params, sendIfMethod_);
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
233
|
+
template<typename MODULE>
|
|
234
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const JsonData::Messenger::UserUpdateParamsData& params, const string& client_)
|
|
235
|
+
{
|
|
236
|
+
module_.Notify(_T("userupdate"), params, [&id_, &client_](const string& designator_) -> bool {
|
|
237
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
238
|
+
const size_t _dot = designator_.find('.');
|
|
239
|
+
const string index_ = designator_.substr(0, _dot);
|
|
240
|
+
|
|
241
|
+
if (index_.empty() == true) {
|
|
242
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
243
|
+
}
|
|
244
|
+
return ((_errorCode__ == Core::ERROR_NONE) && ((client_.empty() == true) || (client_ == designator_.substr(_dot + 1))) && (id_ == index_));
|
|
245
|
+
});
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
249
|
+
template<typename MODULE>
|
|
250
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const Core::JSON::String& user, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::userupdate>& action, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
251
|
+
{
|
|
252
|
+
JsonData::Messenger::UserUpdateParamsData params_;
|
|
253
|
+
params_.User = user;
|
|
254
|
+
params_.Action = action;
|
|
255
|
+
|
|
256
|
+
UserUpdate(module_, id_, params_, sendIfMethod_);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
260
|
+
template<typename MODULE>
|
|
261
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const Core::JSON::String& user, const Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::userupdate>& action, const string& client_)
|
|
262
|
+
{
|
|
263
|
+
JsonData::Messenger::UserUpdateParamsData params_;
|
|
264
|
+
params_.User = user;
|
|
265
|
+
params_.Action = action;
|
|
266
|
+
|
|
267
|
+
UserUpdate(module_, id_, params_, client_);
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
271
|
+
template<typename MODULE>
|
|
272
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const string& user, const IMessenger::INotification::userupdate action, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
273
|
+
{
|
|
274
|
+
JsonData::Messenger::UserUpdateParamsData params_;
|
|
275
|
+
params_.User = user;
|
|
276
|
+
params_.Action = action;
|
|
277
|
+
|
|
278
|
+
UserUpdate(module_, id_, params_, sendIfMethod_);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
// Event: 'userupdate' - Notifies of user status changes
|
|
282
|
+
template<typename MODULE>
|
|
283
|
+
static void UserUpdate(const MODULE& module_, const string& id_, const string& user, const IMessenger::INotification::userupdate action, const string& client_)
|
|
284
|
+
{
|
|
285
|
+
JsonData::Messenger::UserUpdateParamsData params_;
|
|
286
|
+
params_.User = user;
|
|
287
|
+
params_.Action = action;
|
|
288
|
+
|
|
289
|
+
UserUpdate(module_, id_, params_, client_);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// Event: 'message' - Notifies of messages sent the the room
|
|
293
|
+
template<typename MODULE>
|
|
294
|
+
static void Message(const MODULE& module_, const string& id_, const JsonData::Messenger::MessageParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
295
|
+
{
|
|
296
|
+
if (sendIfMethod_ == nullptr) {
|
|
297
|
+
module_.Notify(_T("message"), params, [&id_](const string& designator_) -> bool {
|
|
298
|
+
Core::hresult _errorCode__ = Core::ERROR_NONE;
|
|
299
|
+
const string index_ = designator_.substr(0, designator_.find('.'));
|
|
300
|
+
|
|
301
|
+
if (index_.empty() == true) {
|
|
302
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
303
|
+
}
|
|
304
|
+
return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
|
|
305
|
+
});
|
|
306
|
+
}
|
|
307
|
+
else {
|
|
308
|
+
module_.Notify(_T("message"), params, sendIfMethod_);
|
|
309
|
+
}
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
// Event: 'message' - Notifies of messages sent the the room
|
|
313
|
+
template<typename MODULE>
|
|
314
|
+
static void Message(const MODULE& module_, const string& id_, const Core::JSON::String& user, const Core::JSON::String& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
315
|
+
{
|
|
316
|
+
JsonData::Messenger::MessageParamsData params_;
|
|
317
|
+
params_.User = user;
|
|
318
|
+
params_.Message = message;
|
|
319
|
+
|
|
320
|
+
Message(module_, id_, params_, sendIfMethod_);
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
// Event: 'message' - Notifies of messages sent the the room
|
|
324
|
+
template<typename MODULE>
|
|
325
|
+
static void Message(const MODULE& module_, const string& id_, const string& user, const string& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
326
|
+
{
|
|
327
|
+
JsonData::Messenger::MessageParamsData params_;
|
|
328
|
+
params_.User = user;
|
|
329
|
+
params_.Message = message;
|
|
330
|
+
|
|
331
|
+
Message(module_, id_, params_, sendIfMethod_);
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
} // namespace Event
|
|
335
|
+
|
|
336
|
+
POP_WARNING()
|
|
337
|
+
POP_WARNING()
|
|
338
|
+
POP_WARNING()
|
|
339
|
+
|
|
340
|
+
} // namespace JMessenger
|
|
341
|
+
|
|
342
|
+
} // namespace JSONRPC
|
|
343
|
+
|
|
344
|
+
} // namespace Exchange
|
|
345
|
+
|
|
346
|
+
} // namespace Thunder
|
|
347
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Monitor.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Monitor.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JMonitor {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JMonitor
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Netflix.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Netflix.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JNetflix {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JNetflix
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,298 @@
|
|
|
1
|
+
// Generated automatically from 'INetworkControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_NetworkControl.h"
|
|
6
|
+
#include <interfaces/INetworkControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JNetworkControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, INetworkControl* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JNetworkControl"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'flush' - Flush and reload requested interface
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::FlushParamsData, void>(_T("flush"),
|
|
37
|
+
[_implementation__](const JsonData::NetworkControl::FlushParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("flush")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _interface_{params.Interface};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->Flush(_interface_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Property: 'interfaces' - Currently available interfaces (r/o)
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("interfaces"),
|
|
56
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
60
|
+
|
|
61
|
+
_errorCode__ = _implementation__->Interfaces(_result_);
|
|
62
|
+
|
|
63
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
64
|
+
result.Set(true);
|
|
65
|
+
|
|
66
|
+
if (_result_ != nullptr) {
|
|
67
|
+
string _resultItem__{};
|
|
68
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
69
|
+
_result_->Release();
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
return (_errorCode__);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
// Indexed Property: 'status' - Status of requested interface (r/o)
|
|
77
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::INetworkControl::StatusType>, std::function<uint32_t(const string&, Core::JSON::EnumType<Exchange::INetworkControl::StatusType>&)>>(_T("status"),
|
|
78
|
+
[_implementation__](const string& interface, Core::JSON::EnumType<Exchange::INetworkControl::StatusType>& result) -> uint32_t {
|
|
79
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
80
|
+
|
|
81
|
+
if (interface.empty() == true) {
|
|
82
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("status")));
|
|
83
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
87
|
+
Exchange::INetworkControl::StatusType _result_{};
|
|
88
|
+
|
|
89
|
+
_errorCode__ = _implementation__->Status(interface, _result_);
|
|
90
|
+
|
|
91
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
92
|
+
result = _result_;
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
return (_errorCode__);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
// Indexed Property: 'network' - Network info of requested interface
|
|
100
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::NetworkData, Core::JSON::ArrayType<JsonData::NetworkControl::NetworkInfoInfo>, std::function<uint32_t(const string&, const JsonData::NetworkControl::NetworkData&, Core::JSON::ArrayType<JsonData::NetworkControl::NetworkInfoInfo>&)>>(_T("network"),
|
|
101
|
+
[_implementation__](const string& interface, const JsonData::NetworkControl::NetworkData& params, Core::JSON::ArrayType<JsonData::NetworkControl::NetworkInfoInfo>& result) -> uint32_t {
|
|
102
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
103
|
+
|
|
104
|
+
if (interface.empty() == true) {
|
|
105
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("network")));
|
|
106
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
110
|
+
|
|
111
|
+
if (params.IsSet() == false) {
|
|
112
|
+
RPC::IIteratorType<Exchange::INetworkControl::NetworkInfo, Exchange::ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>* _result_{};
|
|
113
|
+
|
|
114
|
+
_errorCode__ = (static_cast<const INetworkControl*>(_implementation__))->Network(interface, _result_);
|
|
115
|
+
|
|
116
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
117
|
+
result.Set(true);
|
|
118
|
+
|
|
119
|
+
if (_result_ != nullptr) {
|
|
120
|
+
Exchange::INetworkControl::NetworkInfo _resultItem__{};
|
|
121
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
122
|
+
_result_->Release();
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
else {
|
|
127
|
+
|
|
128
|
+
if (params.IsDataValid() == false) {
|
|
129
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("network")));
|
|
130
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
131
|
+
}
|
|
132
|
+
else {
|
|
133
|
+
RPC::IIteratorType<Exchange::INetworkControl::NetworkInfo, Exchange::ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>* _value_{};
|
|
134
|
+
std::list<Exchange::INetworkControl::NetworkInfo> _valueElements_{};
|
|
135
|
+
auto _valueIterator_ = params.Value.Elements();
|
|
136
|
+
while (_valueIterator_.Next() == true) { _valueElements_.push_back(_valueIterator_.Current()); }
|
|
137
|
+
using _valueIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<Exchange::INetworkControl::NetworkInfo, Exchange::ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>>;
|
|
138
|
+
_value_ = Core::ServiceType<_valueIteratorImplType_>::Create<RPC::IIteratorType<Exchange::INetworkControl::NetworkInfo, Exchange::ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>>(std::move(_valueElements_));
|
|
139
|
+
ASSERT(_value_ != nullptr);
|
|
140
|
+
|
|
141
|
+
_errorCode__ = _implementation__->Network(interface, static_cast<RPC::IIteratorType<Exchange::INetworkControl::NetworkInfo, Exchange::ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>* const&>(_value_));
|
|
142
|
+
if (_value_ != nullptr) {
|
|
143
|
+
_value_->Release();
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
result.Null(true);
|
|
149
|
+
}
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
return (_errorCode__);
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
// Property: 'dns' - DNS list
|
|
156
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::DNSData, Core::JSON::ArrayType<Core::JSON::String>>(_T("dns"),
|
|
157
|
+
[_implementation__](const JsonData::NetworkControl::DNSData& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
158
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
159
|
+
|
|
160
|
+
if (params.IsSet() == false) {
|
|
161
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
162
|
+
|
|
163
|
+
_errorCode__ = (static_cast<const INetworkControl*>(_implementation__))->DNS(_result_);
|
|
164
|
+
|
|
165
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
166
|
+
result.Set(true);
|
|
167
|
+
|
|
168
|
+
if (_result_ != nullptr) {
|
|
169
|
+
string _resultItem__{};
|
|
170
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
171
|
+
_result_->Release();
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
else {
|
|
176
|
+
|
|
177
|
+
if (params.IsDataValid() == false) {
|
|
178
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("dns")));
|
|
179
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
180
|
+
}
|
|
181
|
+
else {
|
|
182
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _value_{};
|
|
183
|
+
std::list<string> _valueElements_{};
|
|
184
|
+
auto _valueIterator_ = params.Value.Elements();
|
|
185
|
+
while (_valueIterator_.Next() == true) { _valueElements_.push_back(_valueIterator_.Current()); }
|
|
186
|
+
using _valueIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
|
|
187
|
+
_value_ = Core::ServiceType<_valueIteratorImplType_>::Create<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_valueElements_));
|
|
188
|
+
ASSERT(_value_ != nullptr);
|
|
189
|
+
|
|
190
|
+
_errorCode__ = _implementation__->DNS(static_cast<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_value_));
|
|
191
|
+
if (_value_ != nullptr) {
|
|
192
|
+
_value_->Release();
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
result.Null(true);
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
return (_errorCode__);
|
|
201
|
+
});
|
|
202
|
+
|
|
203
|
+
// Indexed Property: 'up' - Provides given requested interface is up or not
|
|
204
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::UpData, Core::JSON::Boolean, std::function<uint32_t(const string&, const JsonData::NetworkControl::UpData&, Core::JSON::Boolean&)>>(_T("up"),
|
|
205
|
+
[_implementation__](const string& interface, const JsonData::NetworkControl::UpData& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
206
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
207
|
+
|
|
208
|
+
if (interface.empty() == true) {
|
|
209
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("up")));
|
|
210
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
214
|
+
|
|
215
|
+
if (params.IsSet() == false) {
|
|
216
|
+
bool _result_{};
|
|
217
|
+
|
|
218
|
+
_errorCode__ = (static_cast<const INetworkControl*>(_implementation__))->Up(interface, _result_);
|
|
219
|
+
|
|
220
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
221
|
+
result = _result_;
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
else {
|
|
225
|
+
|
|
226
|
+
if (params.IsDataValid() == false) {
|
|
227
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("up")));
|
|
228
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
229
|
+
}
|
|
230
|
+
else {
|
|
231
|
+
const bool _value_{params.Value};
|
|
232
|
+
|
|
233
|
+
_errorCode__ = _implementation__->Up(interface, _value_);
|
|
234
|
+
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
result.Null(true);
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
return (_errorCode__);
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
template<typename MODULE>
|
|
247
|
+
static void Unregister(MODULE& _module__)
|
|
248
|
+
{
|
|
249
|
+
// Unregister methods and properties...
|
|
250
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("flush"));
|
|
251
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("interfaces"));
|
|
252
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("status"));
|
|
253
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("network"));
|
|
254
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("dns"));
|
|
255
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("up"));
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
namespace Event {
|
|
259
|
+
|
|
260
|
+
// Event: 'update' - Signal interface update
|
|
261
|
+
template<typename MODULE>
|
|
262
|
+
static void Update(const MODULE& module_, const JsonData::NetworkControl::UpdateParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
263
|
+
{
|
|
264
|
+
module_.Notify(_T("update"), params, sendIfMethod_);
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
// Event: 'update' - Signal interface update
|
|
268
|
+
template<typename MODULE>
|
|
269
|
+
static void Update(const MODULE& module_, const Core::JSON::String& interfaceName, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
270
|
+
{
|
|
271
|
+
JsonData::NetworkControl::UpdateParamsData params_;
|
|
272
|
+
params_.InterfaceName = interfaceName;
|
|
273
|
+
|
|
274
|
+
Update(module_, params_, sendIfMethod_);
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
// Event: 'update' - Signal interface update
|
|
278
|
+
template<typename MODULE>
|
|
279
|
+
static void Update(const MODULE& module_, const string& interfaceName, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
280
|
+
{
|
|
281
|
+
JsonData::NetworkControl::UpdateParamsData params_;
|
|
282
|
+
params_.InterfaceName = interfaceName;
|
|
283
|
+
|
|
284
|
+
Update(module_, params_, sendIfMethod_);
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
} // namespace Event
|
|
288
|
+
|
|
289
|
+
POP_WARNING()
|
|
290
|
+
POP_WARNING()
|
|
291
|
+
POP_WARNING()
|
|
292
|
+
|
|
293
|
+
} // namespace JNetworkControl
|
|
294
|
+
|
|
295
|
+
} // namespace Exchange
|
|
296
|
+
|
|
297
|
+
} // namespace Thunder
|
|
298
|
+
|
|
@@ -0,0 +1,128 @@
|
|
|
1
|
+
// Generated automatically from 'INetworkTools.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_NetworkTools.h"
|
|
6
|
+
#include <interfaces/INetworkTools.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JNetworkTools {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, INetworkTools* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JNetworkTools"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'ping' - Ping the given destination with ICMP packages
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkTools::PingParamsData, void>(_T("ping"),
|
|
37
|
+
[_implementation__](const JsonData::NetworkTools::PingParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkTools"), _T("ping")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _destination_{params.Destination};
|
|
46
|
+
const uint16_t _timeOutInSeconds_{params.TimeOutInSeconds};
|
|
47
|
+
const uint16_t _count_{params.Count};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Ping(_destination_, _timeOutInSeconds_, _count_);
|
|
50
|
+
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
// Method: 'traceRoute' - TraceRoute to the given destination with ICMP packages
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::NetworkTools::TraceRouteParamsData, void>(_T("traceRoute"),
|
|
58
|
+
[_implementation__](const JsonData::NetworkTools::TraceRouteParamsData& params) -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
62
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkTools"), _T("traceRoute")));
|
|
63
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
64
|
+
}
|
|
65
|
+
else {
|
|
66
|
+
const string _destination_{params.Destination};
|
|
67
|
+
const uint16_t _timeOutInSeconds_{params.TimeOutInSeconds};
|
|
68
|
+
|
|
69
|
+
_errorCode__ = _implementation__->TraceRoute(_destination_, _timeOutInSeconds_);
|
|
70
|
+
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
return (_errorCode__);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void Unregister(MODULE& _module__)
|
|
80
|
+
{
|
|
81
|
+
// Unregister methods and properties...
|
|
82
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("ping"));
|
|
83
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("traceRoute"));
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
namespace Event {
|
|
87
|
+
|
|
88
|
+
// Event: 'report' - Signals an message from a given host
|
|
89
|
+
template<typename MODULE>
|
|
90
|
+
static void Report(const MODULE& module_, const JsonData::NetworkTools::ReportParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
91
|
+
{
|
|
92
|
+
module_.Notify(_T("report"), params, sendIfMethod_);
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
// Event: 'report' - Signals an message from a given host
|
|
96
|
+
template<typename MODULE>
|
|
97
|
+
static void Report(const MODULE& module_, const Core::JSON::String& source, const Core::JSON::String& metadata, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
98
|
+
{
|
|
99
|
+
JsonData::NetworkTools::ReportParamsData params_;
|
|
100
|
+
params_.Source = source;
|
|
101
|
+
params_.Metadata = metadata;
|
|
102
|
+
|
|
103
|
+
Report(module_, params_, sendIfMethod_);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
// Event: 'report' - Signals an message from a given host
|
|
107
|
+
template<typename MODULE>
|
|
108
|
+
static void Report(const MODULE& module_, const string& source, const string& metadata, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
109
|
+
{
|
|
110
|
+
JsonData::NetworkTools::ReportParamsData params_;
|
|
111
|
+
params_.Source = source;
|
|
112
|
+
params_.Metadata = metadata;
|
|
113
|
+
|
|
114
|
+
Report(module_, params_, sendIfMethod_);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
} // namespace Event
|
|
118
|
+
|
|
119
|
+
POP_WARNING()
|
|
120
|
+
POP_WARNING()
|
|
121
|
+
POP_WARNING()
|
|
122
|
+
|
|
123
|
+
} // namespace JNetworkTools
|
|
124
|
+
|
|
125
|
+
} // namespace Exchange
|
|
126
|
+
|
|
127
|
+
} // namespace Thunder
|
|
128
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'OCDM.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_OCDM.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JOCDM {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JOCDM
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
// Generated automatically from 'IOCDM.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/IOCDM.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JOpenCDM {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, IOpenCDM* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JOpenCDM"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Property: 'systems' - Supported DRM systems (r/o)
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("systems"),
|
|
36
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
40
|
+
|
|
41
|
+
_errorCode__ = _implementation__->Systems(_result_);
|
|
42
|
+
|
|
43
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
44
|
+
result.Set(true);
|
|
45
|
+
|
|
46
|
+
if (_result_ != nullptr) {
|
|
47
|
+
string _resultItem__{};
|
|
48
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
49
|
+
_result_->Release();
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
// Indexed Property: 'designators' - Designators of a specified DRM system (r/o)
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>, std::function<uint32_t(const string&, Core::JSON::ArrayType<Core::JSON::String>&)>>(_T("designators"),
|
|
58
|
+
[_implementation__](const string& keySystem, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
if (keySystem.empty() == true) {
|
|
62
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JOpenCDM"), _T("designators")));
|
|
63
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
68
|
+
|
|
69
|
+
_errorCode__ = _implementation__->Designators(keySystem, _result_);
|
|
70
|
+
|
|
71
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
72
|
+
result.Set(true);
|
|
73
|
+
|
|
74
|
+
if (_result_ != nullptr) {
|
|
75
|
+
string _resultItem__{};
|
|
76
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
77
|
+
_result_->Release();
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
template<typename MODULE>
|
|
88
|
+
static void Unregister(MODULE& _module__)
|
|
89
|
+
{
|
|
90
|
+
// Unregister methods and properties...
|
|
91
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("systems"));
|
|
92
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("designators"));
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
POP_WARNING()
|
|
96
|
+
POP_WARNING()
|
|
97
|
+
POP_WARNING()
|
|
98
|
+
|
|
99
|
+
} // namespace JOpenCDM
|
|
100
|
+
|
|
101
|
+
} // namespace Exchange
|
|
102
|
+
|
|
103
|
+
} // namespace Thunder
|
|
104
|
+
|
|
@@ -0,0 +1,472 @@
|
|
|
1
|
+
// Generated automatically from 'IPackageManager.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_PackageManager.h"
|
|
6
|
+
#include <interfaces/IPackageManager.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JPackageManager {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IPackageManager* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JPackageManager"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'install' - Download the application bundle
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::InstallParamsData, Core::JSON::String>(_T("install"),
|
|
37
|
+
[_implementation__](const JsonData::PackageManager::InstallParamsData& params, Core::JSON::String& handle) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("install")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _type_{params.Type};
|
|
46
|
+
const string _id_{params.Id};
|
|
47
|
+
const string _version_{params.Version};
|
|
48
|
+
const string _url_{params.Url};
|
|
49
|
+
const string _appName_{params.AppName};
|
|
50
|
+
const string _category_{params.Category};
|
|
51
|
+
string _handle_{};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->Install(_type_, _id_, _version_, _url_, _appName_, _category_, _handle_);
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
handle = _handle_;
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
return (_errorCode__);
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
// Method: 'uninstall' - Uninstall the application
|
|
64
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::UninstallParamsData, Core::JSON::String>(_T("uninstall"),
|
|
65
|
+
[_implementation__](const JsonData::PackageManager::UninstallParamsData& params, Core::JSON::String& handle) -> uint32_t {
|
|
66
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
67
|
+
|
|
68
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
69
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("uninstall")));
|
|
70
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
71
|
+
}
|
|
72
|
+
else {
|
|
73
|
+
const string _type_{params.Type};
|
|
74
|
+
const string _id_{params.Id};
|
|
75
|
+
const string _version_{params.Version};
|
|
76
|
+
const string _uninstallType_{params.UninstallType};
|
|
77
|
+
string _handle_{};
|
|
78
|
+
|
|
79
|
+
_errorCode__ = _implementation__->Uninstall(_type_, _id_, _version_, _uninstallType_, _handle_);
|
|
80
|
+
|
|
81
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
82
|
+
handle = _handle_;
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
return (_errorCode__);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
// Method: 'download' - Download arbitrary application's resource file
|
|
90
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::DownloadParamsData, Core::JSON::String>(_T("download"),
|
|
91
|
+
[_implementation__](const JsonData::PackageManager::DownloadParamsData& params, Core::JSON::String& handle) -> uint32_t {
|
|
92
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
93
|
+
|
|
94
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
95
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("download")));
|
|
96
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
97
|
+
}
|
|
98
|
+
else {
|
|
99
|
+
const string _type_{params.Type};
|
|
100
|
+
const string _id_{params.Id};
|
|
101
|
+
const string _version_{params.Version};
|
|
102
|
+
const string _resKey_{params.ResKey};
|
|
103
|
+
const string _url_{params.Url};
|
|
104
|
+
string _handle_{};
|
|
105
|
+
|
|
106
|
+
_errorCode__ = _implementation__->Download(_type_, _id_, _version_, _resKey_, _url_, _handle_);
|
|
107
|
+
|
|
108
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
109
|
+
handle = _handle_;
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
return (_errorCode__);
|
|
114
|
+
});
|
|
115
|
+
|
|
116
|
+
// Method: 'reset' - Delete persistent data stored locally
|
|
117
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::ResetParamsData, void>(_T("reset"),
|
|
118
|
+
[_implementation__](const JsonData::PackageManager::ResetParamsData& params) -> uint32_t {
|
|
119
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
120
|
+
|
|
121
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
122
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("reset")));
|
|
123
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
124
|
+
}
|
|
125
|
+
else {
|
|
126
|
+
const string _type_{params.Type};
|
|
127
|
+
const string _id_{params.Id};
|
|
128
|
+
const string _version_{params.Version};
|
|
129
|
+
const string _resetType_{params.ResetType};
|
|
130
|
+
|
|
131
|
+
_errorCode__ = _implementation__->Reset(_type_, _id_, _version_, _resetType_);
|
|
132
|
+
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
return (_errorCode__);
|
|
136
|
+
});
|
|
137
|
+
|
|
138
|
+
// Method: 'getStorageDetails' - Information on the storage usage
|
|
139
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::StorageInfoData>(_T("getStorageDetails"),
|
|
140
|
+
[_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::StorageInfoData& storageinfo) -> uint32_t {
|
|
141
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
142
|
+
|
|
143
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
144
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getStorageDetails")));
|
|
145
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
146
|
+
}
|
|
147
|
+
else {
|
|
148
|
+
const string _type_{params.Type};
|
|
149
|
+
const string _id_{params.Id};
|
|
150
|
+
const string _version_{params.Version};
|
|
151
|
+
Exchange::IPackageManager::StorageInfo _storageinfo_{};
|
|
152
|
+
|
|
153
|
+
_errorCode__ = _implementation__->GetStorageDetails(_type_, _id_, _version_, _storageinfo_);
|
|
154
|
+
|
|
155
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
156
|
+
storageinfo.Set(true);
|
|
157
|
+
storageinfo = _storageinfo_;
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
return (_errorCode__);
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
// Method: 'setAuxMetadata' - Set an arbitrary metadata
|
|
165
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::SetAuxMetadataParamsData, void>(_T("setAuxMetadata"),
|
|
166
|
+
[_implementation__](const JsonData::PackageManager::SetAuxMetadataParamsData& params) -> uint32_t {
|
|
167
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
168
|
+
|
|
169
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
170
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("setAuxMetadata")));
|
|
171
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
172
|
+
}
|
|
173
|
+
else {
|
|
174
|
+
const string _type_{params.Type};
|
|
175
|
+
const string _id_{params.Id};
|
|
176
|
+
const string _version_{params.Version};
|
|
177
|
+
const string _key_{params.Key};
|
|
178
|
+
const string _value_{params.Value};
|
|
179
|
+
|
|
180
|
+
_errorCode__ = _implementation__->SetAuxMetadata(_type_, _id_, _version_, _key_, _value_);
|
|
181
|
+
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
return (_errorCode__);
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
// Method: 'clearAuxMetadata' - Clears an arbitrary metadata
|
|
188
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::ClearAuxMetadataParamsData, void>(_T("clearAuxMetadata"),
|
|
189
|
+
[_implementation__](const JsonData::PackageManager::ClearAuxMetadataParamsData& params) -> uint32_t {
|
|
190
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
191
|
+
|
|
192
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
193
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("clearAuxMetadata")));
|
|
194
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
195
|
+
}
|
|
196
|
+
else {
|
|
197
|
+
const string _type_{params.Type};
|
|
198
|
+
const string _id_{params.Id};
|
|
199
|
+
const string _version_{params.Version};
|
|
200
|
+
const string _key_{params.Key};
|
|
201
|
+
|
|
202
|
+
_errorCode__ = _implementation__->ClearAuxMetadata(_type_, _id_, _version_, _key_);
|
|
203
|
+
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
return (_errorCode__);
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
// Method: 'getMetadata' - Get application metadata
|
|
210
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::GetMetadataResultData>(_T("getMetadata"),
|
|
211
|
+
[_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::GetMetadataResultData& result) -> uint32_t {
|
|
212
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
213
|
+
|
|
214
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
215
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getMetadata")));
|
|
216
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
217
|
+
}
|
|
218
|
+
else {
|
|
219
|
+
const string _type_{params.Type};
|
|
220
|
+
const string _id_{params.Id};
|
|
221
|
+
const string _version_{params.Version};
|
|
222
|
+
Exchange::IPackageManager::MetadataPayload _metadata_{};
|
|
223
|
+
RPC::IIteratorType<Exchange::IPackageManager::KeyValue, Exchange::ID_PACKAGEMANAGER_KEY_VALUE_ITERATOR>* _resources_{};
|
|
224
|
+
RPC::IIteratorType<Exchange::IPackageManager::KeyValue, Exchange::ID_PACKAGEMANAGER_KEY_VALUE_ITERATOR>* _auxMetadata_{};
|
|
225
|
+
|
|
226
|
+
_errorCode__ = _implementation__->GetMetadata(_type_, _id_, _version_, _metadata_, _resources_, _auxMetadata_);
|
|
227
|
+
|
|
228
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
229
|
+
result.Metadata.Set(true);
|
|
230
|
+
result.Metadata = _metadata_;
|
|
231
|
+
result.Resources.Set(true);
|
|
232
|
+
|
|
233
|
+
if (_resources_ != nullptr) {
|
|
234
|
+
Exchange::IPackageManager::KeyValue _resourcesItem__{};
|
|
235
|
+
while (_resources_->Next(_resourcesItem__) == true) { result.Resources.Add() = _resourcesItem__; }
|
|
236
|
+
_resources_->Release();
|
|
237
|
+
}
|
|
238
|
+
result.AuxMetadata.Set(true);
|
|
239
|
+
|
|
240
|
+
if (_auxMetadata_ != nullptr) {
|
|
241
|
+
Exchange::IPackageManager::KeyValue _auxMetadataItem__{};
|
|
242
|
+
while (_auxMetadata_->Next(_auxMetadataItem__) == true) { result.AuxMetadata.Add() = _auxMetadataItem__; }
|
|
243
|
+
_auxMetadata_->Release();
|
|
244
|
+
}
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
return (_errorCode__);
|
|
249
|
+
});
|
|
250
|
+
|
|
251
|
+
// Method: 'cancel' - Cancel asynchronous request
|
|
252
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, void>(_T("cancel"),
|
|
253
|
+
[_implementation__](const JsonData::PackageManager::CancelParamsInfo& params) -> uint32_t {
|
|
254
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
255
|
+
|
|
256
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
257
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("cancel")));
|
|
258
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
259
|
+
}
|
|
260
|
+
else {
|
|
261
|
+
const string _handle_{params.Handle};
|
|
262
|
+
|
|
263
|
+
_errorCode__ = _implementation__->Cancel(_handle_);
|
|
264
|
+
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
return (_errorCode__);
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
// Method: 'getProgress' - Estimated progress of a request
|
|
271
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, Core::JSON::DecUInt32>(_T("getProgress"),
|
|
272
|
+
[_implementation__](const JsonData::PackageManager::CancelParamsInfo& params, Core::JSON::DecUInt32& progress) -> uint32_t {
|
|
273
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
274
|
+
|
|
275
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
276
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getProgress")));
|
|
277
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
278
|
+
}
|
|
279
|
+
else {
|
|
280
|
+
const string _handle_{params.Handle};
|
|
281
|
+
uint32_t _progress_{};
|
|
282
|
+
|
|
283
|
+
_errorCode__ = _implementation__->GetProgress(_handle_, _progress_);
|
|
284
|
+
|
|
285
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
286
|
+
progress = _progress_;
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
return (_errorCode__);
|
|
291
|
+
});
|
|
292
|
+
|
|
293
|
+
// Method: 'getList' - List installed applications
|
|
294
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetListParamsData, Core::JSON::ArrayType<JsonData::PackageManager::PackageKeyData>>(_T("getList"),
|
|
295
|
+
[_implementation__](const JsonData::PackageManager::GetListParamsData& params, Core::JSON::ArrayType<JsonData::PackageManager::PackageKeyData>& installedIds) -> uint32_t {
|
|
296
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
297
|
+
|
|
298
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
299
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getList")));
|
|
300
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
301
|
+
}
|
|
302
|
+
else {
|
|
303
|
+
const string _type_{params.Type};
|
|
304
|
+
const string _id_{params.Id};
|
|
305
|
+
const string _version_{params.Version};
|
|
306
|
+
const string _appName_{params.AppName};
|
|
307
|
+
const string _category_{params.Category};
|
|
308
|
+
RPC::IIteratorType<Exchange::IPackageManager::PackageKey, Exchange::ID_PACKAGEMANAGER_PACKAGE_KEY_ITERATOR>* _installedIds_{};
|
|
309
|
+
|
|
310
|
+
_errorCode__ = _implementation__->GetList(_type_, _id_, _version_, _appName_, _category_, _installedIds_);
|
|
311
|
+
|
|
312
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
313
|
+
installedIds.Set(true);
|
|
314
|
+
|
|
315
|
+
if (_installedIds_ != nullptr) {
|
|
316
|
+
Exchange::IPackageManager::PackageKey _resultItem__{};
|
|
317
|
+
while (_installedIds_->Next(_resultItem__) == true) { installedIds.Add() = _resultItem__; }
|
|
318
|
+
_installedIds_->Release();
|
|
319
|
+
}
|
|
320
|
+
}
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
return (_errorCode__);
|
|
324
|
+
});
|
|
325
|
+
|
|
326
|
+
// Method: 'lock' - Lock the application
|
|
327
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::LockParamsData, Core::JSON::String>(_T("lock"),
|
|
328
|
+
[_implementation__](const JsonData::PackageManager::LockParamsData& params, Core::JSON::String& handle) -> uint32_t {
|
|
329
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
330
|
+
|
|
331
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
332
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("lock")));
|
|
333
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
334
|
+
}
|
|
335
|
+
else {
|
|
336
|
+
const string _type_{params.Type};
|
|
337
|
+
const string _id_{params.Id};
|
|
338
|
+
const string _version_{params.Version};
|
|
339
|
+
const string _reason_{params.Reason};
|
|
340
|
+
const string _owner_{params.Owner};
|
|
341
|
+
string _handle_{};
|
|
342
|
+
|
|
343
|
+
_errorCode__ = _implementation__->Lock(_type_, _id_, _version_, _reason_, _owner_, _handle_);
|
|
344
|
+
|
|
345
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
346
|
+
handle = _handle_;
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
return (_errorCode__);
|
|
351
|
+
});
|
|
352
|
+
|
|
353
|
+
// Method: 'unlock' - Unlock application
|
|
354
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, void>(_T("unlock"),
|
|
355
|
+
[_implementation__](const JsonData::PackageManager::CancelParamsInfo& params) -> uint32_t {
|
|
356
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
357
|
+
|
|
358
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
359
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("unlock")));
|
|
360
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
361
|
+
}
|
|
362
|
+
else {
|
|
363
|
+
const string _handle_{params.Handle};
|
|
364
|
+
|
|
365
|
+
_errorCode__ = _implementation__->Unlock(_handle_);
|
|
366
|
+
|
|
367
|
+
}
|
|
368
|
+
|
|
369
|
+
return (_errorCode__);
|
|
370
|
+
});
|
|
371
|
+
|
|
372
|
+
// Method: 'getLockInfo' - Get lock info
|
|
373
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::LockInfoData>(_T("getLockInfo"),
|
|
374
|
+
[_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::LockInfoData& result) -> uint32_t {
|
|
375
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
376
|
+
|
|
377
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
378
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getLockInfo")));
|
|
379
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
380
|
+
}
|
|
381
|
+
else {
|
|
382
|
+
const string _type_{params.Type};
|
|
383
|
+
const string _id_{params.Id};
|
|
384
|
+
const string _version_{params.Version};
|
|
385
|
+
Exchange::IPackageManager::LockInfo _result_{};
|
|
386
|
+
|
|
387
|
+
_errorCode__ = _implementation__->GetLockInfo(_type_, _id_, _version_, _result_);
|
|
388
|
+
|
|
389
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
390
|
+
result.Set(true);
|
|
391
|
+
result = _result_;
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
return (_errorCode__);
|
|
396
|
+
});
|
|
397
|
+
|
|
398
|
+
}
|
|
399
|
+
|
|
400
|
+
template<typename MODULE>
|
|
401
|
+
static void Unregister(MODULE& _module__)
|
|
402
|
+
{
|
|
403
|
+
// Unregister methods and properties...
|
|
404
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("install"));
|
|
405
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("uninstall"));
|
|
406
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("download"));
|
|
407
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("reset"));
|
|
408
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getStorageDetails"));
|
|
409
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setAuxMetadata"));
|
|
410
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("clearAuxMetadata"));
|
|
411
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getMetadata"));
|
|
412
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("cancel"));
|
|
413
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getProgress"));
|
|
414
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getList"));
|
|
415
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("lock"));
|
|
416
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unlock"));
|
|
417
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getLockInfo"));
|
|
418
|
+
}
|
|
419
|
+
|
|
420
|
+
namespace Event {
|
|
421
|
+
|
|
422
|
+
// Event: 'operationStatus' - Completion of asynchronous operation
|
|
423
|
+
template<typename MODULE>
|
|
424
|
+
static void OperationStatus(const MODULE& module_, const JsonData::PackageManager::OperationStatusParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
425
|
+
{
|
|
426
|
+
module_.Notify(_T("operationStatus"), params, sendIfMethod_);
|
|
427
|
+
}
|
|
428
|
+
|
|
429
|
+
// Event: 'operationStatus' - Completion of asynchronous operation
|
|
430
|
+
template<typename MODULE>
|
|
431
|
+
static void OperationStatus(const MODULE& module_, const Core::JSON::String& handle, const Core::JSON::String& operation, const Core::JSON::String& type, const Core::JSON::String& id, const Core::JSON::String& version, const Core::JSON::String& status, const Core::JSON::String& details, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
432
|
+
{
|
|
433
|
+
JsonData::PackageManager::OperationStatusParamsData params_;
|
|
434
|
+
params_.Handle = handle;
|
|
435
|
+
params_.Operation = operation;
|
|
436
|
+
params_.Type = type;
|
|
437
|
+
params_.Id = id;
|
|
438
|
+
params_.Version = version;
|
|
439
|
+
params_.Status = status;
|
|
440
|
+
params_.Details = details;
|
|
441
|
+
|
|
442
|
+
OperationStatus(module_, params_, sendIfMethod_);
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
// Event: 'operationStatus' - Completion of asynchronous operation
|
|
446
|
+
template<typename MODULE>
|
|
447
|
+
static void OperationStatus(const MODULE& module_, const string& handle, const string& operation, const string& type, const string& id, const string& version, const string& status, const string& details, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
448
|
+
{
|
|
449
|
+
JsonData::PackageManager::OperationStatusParamsData params_;
|
|
450
|
+
params_.Handle = handle;
|
|
451
|
+
params_.Operation = operation;
|
|
452
|
+
params_.Type = type;
|
|
453
|
+
params_.Id = id;
|
|
454
|
+
params_.Version = version;
|
|
455
|
+
params_.Status = status;
|
|
456
|
+
params_.Details = details;
|
|
457
|
+
|
|
458
|
+
OperationStatus(module_, params_, sendIfMethod_);
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
} // namespace Event
|
|
462
|
+
|
|
463
|
+
POP_WARNING()
|
|
464
|
+
POP_WARNING()
|
|
465
|
+
POP_WARNING()
|
|
466
|
+
|
|
467
|
+
} // namespace JPackageManager
|
|
468
|
+
|
|
469
|
+
} // namespace Exchange
|
|
470
|
+
|
|
471
|
+
} // namespace Thunder
|
|
472
|
+
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
// Generated automatically from 'IPackager.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Packager.h"
|
|
6
|
+
#include <interfaces/IPackager.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JPackager {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IPackager* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JPackager"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'install' - Install a package given by a name, an URL or a file path
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Packager::InstallParamsData, void>(_T("install"),
|
|
37
|
+
[_implementation__](const JsonData::Packager::InstallParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackager"), _T("install")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _name_{params.Name};
|
|
46
|
+
const string _version_{params.Version};
|
|
47
|
+
const string _arch_{params.Arch};
|
|
48
|
+
|
|
49
|
+
_errorCode__ = _implementation__->Install(_name_, _version_, _arch_);
|
|
50
|
+
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
return (_errorCode__);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
// Method: 'synchronizerepository' - Synchronize repository manifest with a repository
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("synchronizerepository"),
|
|
58
|
+
[_implementation__]() -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
_errorCode__ = _implementation__->SynchronizeRepository();
|
|
62
|
+
|
|
63
|
+
return (_errorCode__);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
_module__.PluginHost::JSONRPC::Register(_T("synchronize"), _T("synchronizerepository"));
|
|
67
|
+
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
template<typename MODULE>
|
|
71
|
+
static void Unregister(MODULE& _module__)
|
|
72
|
+
{
|
|
73
|
+
// Unregister methods and properties...
|
|
74
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("install"));
|
|
75
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("synchronizerepository"));
|
|
76
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("synchronize"));
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
POP_WARNING()
|
|
80
|
+
POP_WARNING()
|
|
81
|
+
POP_WARNING()
|
|
82
|
+
|
|
83
|
+
} // namespace JPackager
|
|
84
|
+
|
|
85
|
+
} // namespace Exchange
|
|
86
|
+
|
|
87
|
+
} // namespace Thunder
|
|
88
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'PerformanceMonitor.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_PerformanceMonitor.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JPerformanceMonitor {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JPerformanceMonitor
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'PersistentStore.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_PersistentStore.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JPersistentStore {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JPersistentStore
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
// Generated automatically from 'IPlayerInfo.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_PlayerProperties.h"
|
|
6
|
+
#include <interfaces/IPlayerInfo.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JPlayerProperties {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IPlayerProperties* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JPlayerProperties"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'audiocodecs' - Query Audio Codecs List (r/o)
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IPlayerProperties::AudioCodec>>>(_T("audiocodecs"),
|
|
37
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IPlayerProperties::AudioCodec>>& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
RPC::IIteratorType<Exchange::IPlayerProperties::AudioCodec, Exchange::ID_PLAYER_PROPERTIES_AUDIO>* _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = _implementation__->AudioCodecs(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result.Set(true);
|
|
46
|
+
|
|
47
|
+
if (_result_ != nullptr) {
|
|
48
|
+
Exchange::IPlayerProperties::AudioCodec _resultItem__{};
|
|
49
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
50
|
+
_result_->Release();
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Property: 'videocodecs' - Query Video Codecs List (r/o)
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IPlayerProperties::VideoCodec>>>(_T("videocodecs"),
|
|
59
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IPlayerProperties::VideoCodec>>& result) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
RPC::IIteratorType<Exchange::IPlayerProperties::VideoCodec, Exchange::ID_PLAYER_PROPERTIES_VIDEO>* _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->VideoCodecs(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result.Set(true);
|
|
68
|
+
|
|
69
|
+
if (_result_ != nullptr) {
|
|
70
|
+
Exchange::IPlayerProperties::VideoCodec _resultItem__{};
|
|
71
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
72
|
+
_result_->Release();
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
return (_errorCode__);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
// Property: 'resolution' - Current Video playback resolution (r/o)
|
|
80
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IPlayerProperties::PlaybackResolution>>(_T("resolution"),
|
|
81
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IPlayerProperties::PlaybackResolution>& result) -> uint32_t {
|
|
82
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
83
|
+
|
|
84
|
+
Exchange::IPlayerProperties::PlaybackResolution _result_{};
|
|
85
|
+
|
|
86
|
+
_errorCode__ = _implementation__->Resolution(_result_);
|
|
87
|
+
|
|
88
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
89
|
+
result = _result_;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
return (_errorCode__);
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
// Property: 'isaudioequivalenceenabled' - Checks Loudness Equivalence in platform (r/o)
|
|
96
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::Boolean>(_T("isaudioequivalenceenabled"),
|
|
97
|
+
[_implementation__](Core::JSON::Boolean& result) -> uint32_t {
|
|
98
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
99
|
+
|
|
100
|
+
bool _result_{};
|
|
101
|
+
|
|
102
|
+
_errorCode__ = _implementation__->IsAudioEquivalenceEnabled(_result_);
|
|
103
|
+
|
|
104
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
105
|
+
result = _result_;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
template<typename MODULE>
|
|
114
|
+
static void Unregister(MODULE& _module__)
|
|
115
|
+
{
|
|
116
|
+
// Unregister methods and properties...
|
|
117
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("audiocodecs"));
|
|
118
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("videocodecs"));
|
|
119
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("resolution"));
|
|
120
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("isaudioequivalenceenabled"));
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
POP_WARNING()
|
|
124
|
+
POP_WARNING()
|
|
125
|
+
POP_WARNING()
|
|
126
|
+
|
|
127
|
+
} // namespace JPlayerProperties
|
|
128
|
+
|
|
129
|
+
} // namespace Exchange
|
|
130
|
+
|
|
131
|
+
} // namespace Thunder
|
|
132
|
+
|
|
@@ -0,0 +1,131 @@
|
|
|
1
|
+
// Generated automatically from 'IPower.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Power.h"
|
|
6
|
+
#include <interfaces/IPower.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JPower {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IPower* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JPower"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'setstate' - Set the power state
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Power::SetStateParamsData, void>(_T("setstate"),
|
|
37
|
+
[_implementation__](const JsonData::Power::SetStateParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPower"), _T("setstate")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const Exchange::IPower::PCState _state_{params.State};
|
|
46
|
+
const uint32_t _waitTime_{params.WaitTime};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->SetState(_state_, _waitTime_);
|
|
49
|
+
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
return (_errorCode__);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
_module__.PluginHost::JSONRPC::Register(_T("set"), _T("setstate"));
|
|
56
|
+
|
|
57
|
+
// Property: 'getstate' - Get the current power state (r/o)
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IPower::PCState>>(_T("getstate"),
|
|
59
|
+
[_implementation__](Core::JSON::EnumType<Exchange::IPower::PCState>& result) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
Exchange::IPower::PCState _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = _implementation__->GetState(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result = _result_;
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
return (_errorCode__);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
_module__.PluginHost::JSONRPC::Register(_T("state"), _T("getstate"));
|
|
74
|
+
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
template<typename MODULE>
|
|
78
|
+
static void Unregister(MODULE& _module__)
|
|
79
|
+
{
|
|
80
|
+
// Unregister methods and properties...
|
|
81
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setstate"));
|
|
82
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("set"));
|
|
83
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getstate"));
|
|
84
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("state"));
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
namespace Event {
|
|
88
|
+
|
|
89
|
+
// Event: 'statechange' - Signals a change in the power state
|
|
90
|
+
template<typename MODULE>
|
|
91
|
+
static void StateChange(const MODULE& module_, const JsonData::Power::StateChangeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
92
|
+
{
|
|
93
|
+
module_.Notify(_T("statechange"), params, sendIfMethod_);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// Event: 'statechange' - Signals a change in the power state
|
|
97
|
+
template<typename MODULE>
|
|
98
|
+
static void StateChange(const MODULE& module_, const Core::JSON::EnumType<Exchange::IPower::PCState>& origin, const Core::JSON::EnumType<Exchange::IPower::PCState>& destination, const Core::JSON::EnumType<Exchange::IPower::PCPhase>& phase, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
99
|
+
{
|
|
100
|
+
JsonData::Power::StateChangeParamsData params_;
|
|
101
|
+
params_.Origin = origin;
|
|
102
|
+
params_.Destination = destination;
|
|
103
|
+
params_.Phase = phase;
|
|
104
|
+
|
|
105
|
+
StateChange(module_, params_, sendIfMethod_);
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
// Event: 'statechange' - Signals a change in the power state
|
|
109
|
+
template<typename MODULE>
|
|
110
|
+
static void StateChange(const MODULE& module_, const IPower::PCState origin, const IPower::PCState destination, const IPower::PCPhase phase, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
111
|
+
{
|
|
112
|
+
JsonData::Power::StateChangeParamsData params_;
|
|
113
|
+
params_.Origin = origin;
|
|
114
|
+
params_.Destination = destination;
|
|
115
|
+
params_.Phase = phase;
|
|
116
|
+
|
|
117
|
+
StateChange(module_, params_, sendIfMethod_);
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
} // namespace Event
|
|
121
|
+
|
|
122
|
+
POP_WARNING()
|
|
123
|
+
POP_WARNING()
|
|
124
|
+
POP_WARNING()
|
|
125
|
+
|
|
126
|
+
} // namespace JPower
|
|
127
|
+
|
|
128
|
+
} // namespace Exchange
|
|
129
|
+
|
|
130
|
+
} // namespace Thunder
|
|
131
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Provisioning.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Provisioning.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JProvisioning {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JProvisioning
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'RemoteControl.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_RemoteControl.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JRemoteControl {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JRemoteControl
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
// Generated automatically from 'IScriptEngine.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ScriptEngine.h"
|
|
6
|
+
#include <interfaces/IScriptEngine.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JScriptEngine {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IScriptEngine* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JScriptEngine"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'url' - Script to be loaded into the engine and to be executed
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ScriptEngine::URLData, Core::JSON::String>(_T("url"),
|
|
37
|
+
[_implementation__](const JsonData::ScriptEngine::URLData& params, Core::JSON::String& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (params.IsSet() == false) {
|
|
41
|
+
string _result_{};
|
|
42
|
+
|
|
43
|
+
_errorCode__ = (static_cast<const IScriptEngine*>(_implementation__))->URL(_result_);
|
|
44
|
+
|
|
45
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
46
|
+
result = _result_;
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
else {
|
|
50
|
+
|
|
51
|
+
if (params.IsDataValid() == false) {
|
|
52
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JScriptEngine"), _T("url")));
|
|
53
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
54
|
+
}
|
|
55
|
+
else {
|
|
56
|
+
const string _value_{params.Value};
|
|
57
|
+
|
|
58
|
+
_errorCode__ = _implementation__->URL(_value_);
|
|
59
|
+
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
result.Null(true);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
return (_errorCode__);
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
template<typename MODULE>
|
|
71
|
+
static void Unregister(MODULE& _module__)
|
|
72
|
+
{
|
|
73
|
+
// Unregister methods and properties...
|
|
74
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("url"));
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
namespace Event {
|
|
78
|
+
|
|
79
|
+
// Event: 'urlchanged' - Signal changes on the subscribed namespace
|
|
80
|
+
template<typename MODULE>
|
|
81
|
+
static void URLChanged(const MODULE& module_, const JsonData::ScriptEngine::URLChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
82
|
+
{
|
|
83
|
+
module_.Notify(_T("urlchanged"), params, sendIfMethod_);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
// Event: 'urlchanged' - Signal changes on the subscribed namespace
|
|
87
|
+
template<typename MODULE>
|
|
88
|
+
static void URLChanged(const MODULE& module_, const Core::JSON::String& URL, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
89
|
+
{
|
|
90
|
+
JsonData::ScriptEngine::URLChangedParamsData params_;
|
|
91
|
+
params_.URL = URL;
|
|
92
|
+
|
|
93
|
+
URLChanged(module_, params_, sendIfMethod_);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// Event: 'urlchanged' - Signal changes on the subscribed namespace
|
|
97
|
+
template<typename MODULE>
|
|
98
|
+
static void URLChanged(const MODULE& module_, const string& URL, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
99
|
+
{
|
|
100
|
+
JsonData::ScriptEngine::URLChangedParamsData params_;
|
|
101
|
+
params_.URL = URL;
|
|
102
|
+
|
|
103
|
+
URLChanged(module_, params_, sendIfMethod_);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
} // namespace Event
|
|
107
|
+
|
|
108
|
+
POP_WARNING()
|
|
109
|
+
POP_WARNING()
|
|
110
|
+
POP_WARNING()
|
|
111
|
+
|
|
112
|
+
} // namespace JScriptEngine
|
|
113
|
+
|
|
114
|
+
} // namespace Exchange
|
|
115
|
+
|
|
116
|
+
} // namespace Thunder
|
|
117
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'SecureShellServer.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SecureShellServer.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JSecureShellServer {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JSecureShellServer
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
// Generated automatically from 'ISecurityAgent.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SecurityAgent.h"
|
|
6
|
+
#include <interfaces/ISecurityAgent.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JSecurityAgent {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ISecurityAgent* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSecurityAgent"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'validate' - Validates a token
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SecurityAgent::ValidateParamsData, Core::JSON::Boolean>(_T("validate"),
|
|
37
|
+
[_implementation__](const JsonData::SecurityAgent::ValidateParamsData& params, Core::JSON::Boolean& valid) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSecurityAgent"), _T("validate")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _token_{params.Token};
|
|
46
|
+
bool _valid_{};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->Validate(_token_, _valid_);
|
|
49
|
+
|
|
50
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
51
|
+
valid = _valid_;
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
return (_errorCode__);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
template<typename MODULE>
|
|
61
|
+
static void Unregister(MODULE& _module__)
|
|
62
|
+
{
|
|
63
|
+
// Unregister methods and properties...
|
|
64
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("validate"));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
POP_WARNING()
|
|
68
|
+
POP_WARNING()
|
|
69
|
+
POP_WARNING()
|
|
70
|
+
|
|
71
|
+
} // namespace JSecurityAgent
|
|
72
|
+
|
|
73
|
+
} // namespace Exchange
|
|
74
|
+
|
|
75
|
+
} // namespace Thunder
|
|
76
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'StateControl.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_StateControl.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JStateControl {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JStateControl
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,202 @@
|
|
|
1
|
+
// Generated automatically from 'IStore2.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Store2.h"
|
|
6
|
+
#include <interfaces/IStore2.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JStore2 {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IStore2* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JStore2"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register alternative notification names...
|
|
34
|
+
_module__.PluginHost::JSONRPC::RegisterEventAlias(_T("onValueChanged"), _T("valueChanged"));
|
|
35
|
+
|
|
36
|
+
// Register methods and properties...
|
|
37
|
+
|
|
38
|
+
// Method: 'setValue'
|
|
39
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Store2::SetValueParamsData, void>(_T("setValue"),
|
|
40
|
+
[_implementation__](const JsonData::Store2::SetValueParamsData& params) -> uint32_t {
|
|
41
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
42
|
+
|
|
43
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
44
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("setValue")));
|
|
45
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
46
|
+
}
|
|
47
|
+
else {
|
|
48
|
+
const Exchange::IStore2::ScopeType _scope_{params.Scope};
|
|
49
|
+
const string _ns_{params.Ns};
|
|
50
|
+
const string _key_{params.Key};
|
|
51
|
+
const string _value_{params.Value};
|
|
52
|
+
const uint32_t _ttl_{params.Ttl};
|
|
53
|
+
|
|
54
|
+
_errorCode__ = _implementation__->SetValue(_scope_, _ns_, _key_, _value_, _ttl_);
|
|
55
|
+
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
return (_errorCode__);
|
|
59
|
+
});
|
|
60
|
+
|
|
61
|
+
_module__.PluginHost::JSONRPC::Register(_T("setValue"), _T("setValue"));
|
|
62
|
+
|
|
63
|
+
// Method: 'getValue'
|
|
64
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Store2::GetValueParamsInfo, JsonData::Store2::GetValueResultData>(_T("getValue"),
|
|
65
|
+
[_implementation__](const JsonData::Store2::GetValueParamsInfo& params, JsonData::Store2::GetValueResultData& result) -> uint32_t {
|
|
66
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
67
|
+
|
|
68
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
69
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("getValue")));
|
|
70
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
71
|
+
}
|
|
72
|
+
else {
|
|
73
|
+
const Exchange::IStore2::ScopeType _scope_{params.Scope};
|
|
74
|
+
const string _ns_{params.Ns};
|
|
75
|
+
const string _key_{params.Key};
|
|
76
|
+
string _value_{};
|
|
77
|
+
uint32_t _ttl_{};
|
|
78
|
+
|
|
79
|
+
_errorCode__ = _implementation__->GetValue(_scope_, _ns_, _key_, _value_, _ttl_);
|
|
80
|
+
|
|
81
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
82
|
+
result.Value = _value_;
|
|
83
|
+
result.Ttl = _ttl_;
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
return (_errorCode__);
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
_module__.PluginHost::JSONRPC::Register(_T("getValue"), _T("getValue"));
|
|
91
|
+
|
|
92
|
+
// Method: 'deleteKey'
|
|
93
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Store2::GetValueParamsInfo, void>(_T("deleteKey"),
|
|
94
|
+
[_implementation__](const JsonData::Store2::GetValueParamsInfo& params) -> uint32_t {
|
|
95
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
96
|
+
|
|
97
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
98
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("deleteKey")));
|
|
99
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
100
|
+
}
|
|
101
|
+
else {
|
|
102
|
+
const Exchange::IStore2::ScopeType _scope_{params.Scope};
|
|
103
|
+
const string _ns_{params.Ns};
|
|
104
|
+
const string _key_{params.Key};
|
|
105
|
+
|
|
106
|
+
_errorCode__ = _implementation__->DeleteKey(_scope_, _ns_, _key_);
|
|
107
|
+
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
return (_errorCode__);
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
_module__.PluginHost::JSONRPC::Register(_T("deleteKey"), _T("deleteKey"));
|
|
114
|
+
|
|
115
|
+
// Method: 'deleteNamespace'
|
|
116
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Store2::DeleteNamespaceParamsData, void>(_T("deleteNamespace"),
|
|
117
|
+
[_implementation__](const JsonData::Store2::DeleteNamespaceParamsData& params) -> uint32_t {
|
|
118
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
119
|
+
|
|
120
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
121
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("deleteNamespace")));
|
|
122
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
123
|
+
}
|
|
124
|
+
else {
|
|
125
|
+
const Exchange::IStore2::ScopeType _scope_{params.Scope};
|
|
126
|
+
const string _ns_{params.Ns};
|
|
127
|
+
|
|
128
|
+
_errorCode__ = _implementation__->DeleteNamespace(_scope_, _ns_);
|
|
129
|
+
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
return (_errorCode__);
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
_module__.PluginHost::JSONRPC::Register(_T("deleteNamespace"), _T("deleteNamespace"));
|
|
136
|
+
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
template<typename MODULE>
|
|
140
|
+
static void Unregister(MODULE& _module__)
|
|
141
|
+
{
|
|
142
|
+
// Unregister methods and properties...
|
|
143
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setValue"));
|
|
144
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("setValue"));
|
|
145
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getValue"));
|
|
146
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("getValue"));
|
|
147
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deleteKey"));
|
|
148
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deleteKey"));
|
|
149
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deleteNamespace"));
|
|
150
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deleteNamespace"));
|
|
151
|
+
|
|
152
|
+
// Unegister alternative notification names...
|
|
153
|
+
_module__.PluginHost::JSONRPC::UnregisterEventAlias(_T("onValueChanged"), _T("valueChanged"));
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
namespace Event {
|
|
157
|
+
|
|
158
|
+
// Event: 'valueChanged'
|
|
159
|
+
template<typename MODULE>
|
|
160
|
+
static void ValueChanged(const MODULE& module_, const JsonData::Store2::ValueChangedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
161
|
+
{
|
|
162
|
+
module_.Notify(_T("valueChanged"), params, sendIfMethod_);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
// Event: 'valueChanged'
|
|
166
|
+
template<typename MODULE>
|
|
167
|
+
static void ValueChanged(const MODULE& module_, const Core::JSON::EnumType<Exchange::IStore2::ScopeType>& scope, const Core::JSON::String& ns, const Core::JSON::String& key, const Core::JSON::String& value, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
168
|
+
{
|
|
169
|
+
JsonData::Store2::ValueChangedParamsData params_;
|
|
170
|
+
params_.Scope = scope;
|
|
171
|
+
params_.Ns = ns;
|
|
172
|
+
params_.Key = key;
|
|
173
|
+
params_.Value = value;
|
|
174
|
+
|
|
175
|
+
ValueChanged(module_, params_, sendIfMethod_);
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
// Event: 'valueChanged'
|
|
179
|
+
template<typename MODULE>
|
|
180
|
+
static void ValueChanged(const MODULE& module_, const IStore2::ScopeType scope, const string& ns, const string& key, const string& value, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
181
|
+
{
|
|
182
|
+
JsonData::Store2::ValueChangedParamsData params_;
|
|
183
|
+
params_.Scope = scope;
|
|
184
|
+
params_.Ns = ns;
|
|
185
|
+
params_.Key = key;
|
|
186
|
+
params_.Value = value;
|
|
187
|
+
|
|
188
|
+
ValueChanged(module_, params_, sendIfMethod_);
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
} // namespace Event
|
|
192
|
+
|
|
193
|
+
POP_WARNING()
|
|
194
|
+
POP_WARNING()
|
|
195
|
+
POP_WARNING()
|
|
196
|
+
|
|
197
|
+
} // namespace JStore2
|
|
198
|
+
|
|
199
|
+
} // namespace Exchange
|
|
200
|
+
|
|
201
|
+
} // namespace Thunder
|
|
202
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'Streamer.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Streamer.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JStreamer {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JStreamer
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
// Generated automatically from 'ISubsystemControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SubsystemControl.h"
|
|
6
|
+
#include <interfaces/ISubsystemControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JSubsystemControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ISubsystemControl* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSubsystemControl"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'activate' - Activates a subsystem
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SubsystemControl::ActivateParamsData, void>(_T("activate"),
|
|
37
|
+
[_implementation__](const JsonData::SubsystemControl::ActivateParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSubsystemControl"), _T("activate")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const PluginHost::ISubSystem::subsystem _subsystem_{params.Subsystem};
|
|
46
|
+
Core::OptionalType<string> _configuration_{};
|
|
47
|
+
if (params.Configuration.IsSet() == true) {
|
|
48
|
+
_configuration_ = params.Configuration;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
_errorCode__ = _implementation__->Activate(_subsystem_, _configuration_);
|
|
52
|
+
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
return (_errorCode__);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
template<typename MODULE>
|
|
61
|
+
static void Unregister(MODULE& _module__)
|
|
62
|
+
{
|
|
63
|
+
// Unregister methods and properties...
|
|
64
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("activate"));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
POP_WARNING()
|
|
68
|
+
POP_WARNING()
|
|
69
|
+
POP_WARNING()
|
|
70
|
+
|
|
71
|
+
} // namespace JSubsystemControl
|
|
72
|
+
|
|
73
|
+
} // namespace Exchange
|
|
74
|
+
|
|
75
|
+
} // namespace Thunder
|
|
76
|
+
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
// Generated automatically from 'ISystemCommands.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_SystemCommands.h"
|
|
6
|
+
#include <interfaces/ISystemCommands.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JSystemCommands {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ISystemCommands* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JSystemCommands"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'usbreset' - Resets a USB device
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::SystemCommands::USBResetParamsData, void>(_T("usbreset"),
|
|
37
|
+
[_implementation__](const JsonData::SystemCommands::USBResetParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystemCommands"), _T("usbreset")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _device_{params.Device};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->USBReset(_device_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
template<typename MODULE>
|
|
57
|
+
static void Unregister(MODULE& _module__)
|
|
58
|
+
{
|
|
59
|
+
// Unregister methods and properties...
|
|
60
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("usbreset"));
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
POP_WARNING()
|
|
64
|
+
POP_WARNING()
|
|
65
|
+
POP_WARNING()
|
|
66
|
+
|
|
67
|
+
} // namespace JSystemCommands
|
|
68
|
+
|
|
69
|
+
} // namespace Exchange
|
|
70
|
+
|
|
71
|
+
} // namespace Thunder
|
|
72
|
+
|
|
@@ -0,0 +1,133 @@
|
|
|
1
|
+
// Generated automatically from 'ITimeSync.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TimeSync.h"
|
|
6
|
+
#include <interfaces/ITimeSync.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JTimeSync {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ITimeSync* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTimeSync"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register alternative notification names...
|
|
34
|
+
_module__.PluginHost::JSONRPC::RegisterEventAlias(_T("timechange"), _T("timechanged"));
|
|
35
|
+
|
|
36
|
+
// Register methods and properties...
|
|
37
|
+
|
|
38
|
+
// Method: 'synchronize' - Synchronizes time (DEPRECATED)
|
|
39
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("synchronize"),
|
|
40
|
+
[_implementation__]() -> uint32_t {
|
|
41
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
42
|
+
|
|
43
|
+
_errorCode__ = _implementation__->Synchronize();
|
|
44
|
+
|
|
45
|
+
return (_errorCode__);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
// Property: 'synctime' - Time of the most recent synchronization (r/o)
|
|
49
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::TimeSync::TimeInfoData>(_T("synctime"),
|
|
50
|
+
[_implementation__](JsonData::TimeSync::TimeInfoData& result) -> uint32_t {
|
|
51
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
52
|
+
|
|
53
|
+
Exchange::ITimeSync::TimeInfo _result_{};
|
|
54
|
+
|
|
55
|
+
_errorCode__ = _implementation__->SyncTime(_result_);
|
|
56
|
+
|
|
57
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
58
|
+
result.Set(true);
|
|
59
|
+
result = _result_;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
return (_errorCode__);
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
// Property: 'time' - Current system time (DEPRECATED)
|
|
66
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TimeSync::TimeData, Core::JSON::String>(_T("time"),
|
|
67
|
+
[_implementation__](const JsonData::TimeSync::TimeData& params, Core::JSON::String& result) -> uint32_t {
|
|
68
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
69
|
+
|
|
70
|
+
if (params.IsSet() == false) {
|
|
71
|
+
Core::Time _result_{};
|
|
72
|
+
|
|
73
|
+
_errorCode__ = (static_cast<const ITimeSync*>(_implementation__))->Time(_result_);
|
|
74
|
+
|
|
75
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
76
|
+
result = _result_.ToISO8601();
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
else {
|
|
80
|
+
|
|
81
|
+
if (params.IsDataValid() == false) {
|
|
82
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTimeSync"), _T("time")));
|
|
83
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
84
|
+
}
|
|
85
|
+
else {
|
|
86
|
+
Core::Time _value_{};
|
|
87
|
+
_value_.FromISO8601(params.Value);
|
|
88
|
+
|
|
89
|
+
_errorCode__ = _implementation__->Time(static_cast<Core::Time const&>(_value_));
|
|
90
|
+
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
result.Null(true);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
return (_errorCode__);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
template<typename MODULE>
|
|
102
|
+
static void Unregister(MODULE& _module__)
|
|
103
|
+
{
|
|
104
|
+
// Unregister methods and properties...
|
|
105
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("synchronize"));
|
|
106
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("synctime"));
|
|
107
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("time"));
|
|
108
|
+
|
|
109
|
+
// Unegister alternative notification names...
|
|
110
|
+
_module__.PluginHost::JSONRPC::UnregisterEventAlias(_T("timechange"), _T("timechanged"));
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
namespace Event {
|
|
114
|
+
|
|
115
|
+
// Event: 'timechanged' - Signals a time change
|
|
116
|
+
template<typename MODULE>
|
|
117
|
+
static void TimeChanged(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
118
|
+
{
|
|
119
|
+
module_.Notify(_T("timechanged"), sendIfMethod_);
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
} // namespace Event
|
|
123
|
+
|
|
124
|
+
POP_WARNING()
|
|
125
|
+
POP_WARNING()
|
|
126
|
+
POP_WARNING()
|
|
127
|
+
|
|
128
|
+
} // namespace JTimeSync
|
|
129
|
+
|
|
130
|
+
} // namespace Exchange
|
|
131
|
+
|
|
132
|
+
} // namespace Thunder
|
|
133
|
+
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
// Generated automatically from 'ITimeZone.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include <interfaces/ITimeZone.h>
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JTimeZone {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
24
|
+
|
|
25
|
+
template<typename MODULE>
|
|
26
|
+
static void Register(MODULE& _module__, ITimeZone* _implementation__)
|
|
27
|
+
{
|
|
28
|
+
ASSERT(_implementation__ != nullptr);
|
|
29
|
+
|
|
30
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTimeZone"), Version::Major, Version::Minor, Version::Patch);
|
|
31
|
+
|
|
32
|
+
// Register methods and properties...
|
|
33
|
+
|
|
34
|
+
// Property: 'timezone' - TimeZone for system
|
|
35
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("timezone"),
|
|
36
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
37
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
38
|
+
|
|
39
|
+
if (params.IsSet() == false) {
|
|
40
|
+
string _result_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = (static_cast<const ITimeZone*>(_implementation__))->TimeZone(_result_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
result = _result_;
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
else {
|
|
49
|
+
const string _params_{params};
|
|
50
|
+
|
|
51
|
+
_errorCode__ = _implementation__->TimeZone(_params_);
|
|
52
|
+
|
|
53
|
+
result.Null(true);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
template<typename MODULE>
|
|
62
|
+
static void Unregister(MODULE& _module__)
|
|
63
|
+
{
|
|
64
|
+
// Unregister methods and properties...
|
|
65
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("timezone"));
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
namespace Event {
|
|
69
|
+
|
|
70
|
+
// Event: 'timezonechanged' - TimeZone was set for the system
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void TimeZoneChanged(const MODULE& module_, const Core::JSON::String& timeZone, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
73
|
+
{
|
|
74
|
+
module_.Notify(_T("timezonechanged"), timeZone, sendIfMethod_);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
// Event: 'timezonechanged' - TimeZone was set for the system
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void TimeZoneChanged(const MODULE& module_, const string& timeZone, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
80
|
+
{
|
|
81
|
+
Core::JSON::String params_;
|
|
82
|
+
params_ = timeZone;
|
|
83
|
+
|
|
84
|
+
TimeZoneChanged(module_, params_, sendIfMethod_);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
} // namespace Event
|
|
88
|
+
|
|
89
|
+
POP_WARNING()
|
|
90
|
+
POP_WARNING()
|
|
91
|
+
POP_WARNING()
|
|
92
|
+
|
|
93
|
+
} // namespace JTimeZone
|
|
94
|
+
|
|
95
|
+
} // namespace Exchange
|
|
96
|
+
|
|
97
|
+
} // namespace Thunder
|
|
98
|
+
|
|
@@ -0,0 +1,189 @@
|
|
|
1
|
+
// Generated automatically from 'IUSBHub.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_USBHub.h"
|
|
6
|
+
#include <interfaces/IUSBHub.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JUSBHub {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IUSBHub* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JUSBHub"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'devices' - Get a string array defning al devices hooked up to this hub
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("devices"),
|
|
37
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& iterator) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _iterator_{};
|
|
41
|
+
|
|
42
|
+
_errorCode__ = _implementation__->Devices(_iterator_);
|
|
43
|
+
|
|
44
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
45
|
+
iterator.Set(true);
|
|
46
|
+
|
|
47
|
+
if (_iterator_ != nullptr) {
|
|
48
|
+
string _resultItem__{};
|
|
49
|
+
while (_iterator_->Next(_resultItem__) == true) { iterator.Add() = _resultItem__; }
|
|
50
|
+
_iterator_->Release();
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Method: 'vendorDevices' - Get a string array defining all devices hooked up to this hub cmpliant to the given VendorId/ProductId
|
|
58
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::USBHub::VendorDevicesParamsData, Core::JSON::ArrayType<Core::JSON::String>>(_T("vendorDevices"),
|
|
59
|
+
[_implementation__](const JsonData::USBHub::VendorDevicesParamsData& params, Core::JSON::ArrayType<Core::JSON::String>& iterator) -> uint32_t {
|
|
60
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
61
|
+
|
|
62
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
63
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JUSBHub"), _T("vendorDevices")));
|
|
64
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
65
|
+
}
|
|
66
|
+
else {
|
|
67
|
+
const uint16_t _vendorId_{params.VendorId};
|
|
68
|
+
const uint16_t _productId_{params.ProductId};
|
|
69
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _iterator_{};
|
|
70
|
+
|
|
71
|
+
_errorCode__ = _implementation__->VendorDevices(_vendorId_, _productId_, _iterator_);
|
|
72
|
+
|
|
73
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
74
|
+
iterator.Set(true);
|
|
75
|
+
|
|
76
|
+
if (_iterator_ != nullptr) {
|
|
77
|
+
string _resultItem__{};
|
|
78
|
+
while (_iterator_->Next(_resultItem__) == true) { iterator.Add() = _resultItem__; }
|
|
79
|
+
_iterator_->Release();
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
return (_errorCode__);
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
// Method: 'device' - Get the metadata information about the name passed in the paramater
|
|
88
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::USBHub::DeviceParamsData, JsonData::USBHub::DeviceMetadataInfo>(_T("device"),
|
|
89
|
+
[_implementation__](const JsonData::USBHub::DeviceParamsData& params, JsonData::USBHub::DeviceMetadataInfo& device) -> uint32_t {
|
|
90
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
91
|
+
|
|
92
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
93
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JUSBHub"), _T("device")));
|
|
94
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
95
|
+
}
|
|
96
|
+
else {
|
|
97
|
+
const string _deviceName_{params.DeviceName};
|
|
98
|
+
Exchange::IUSBHub::DeviceMetadata _device_{};
|
|
99
|
+
|
|
100
|
+
_errorCode__ = _implementation__->Device(_deviceName_, _device_);
|
|
101
|
+
|
|
102
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
103
|
+
device.Set(true);
|
|
104
|
+
device = _device_;
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
template<typename MODULE>
|
|
114
|
+
static void Unregister(MODULE& _module__)
|
|
115
|
+
{
|
|
116
|
+
// Unregister methods and properties...
|
|
117
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("devices"));
|
|
118
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("vendorDevices"));
|
|
119
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("device"));
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
namespace Event {
|
|
123
|
+
|
|
124
|
+
// Event: 'announce' - Device Plugged in on the bus notification
|
|
125
|
+
template<typename MODULE>
|
|
126
|
+
static void Announce(const MODULE& module_, const JsonData::USBHub::AnnounceParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
127
|
+
{
|
|
128
|
+
module_.Notify(_T("announce"), params, sendIfMethod_);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// Event: 'announce' - Device Plugged in on the bus notification
|
|
132
|
+
template<typename MODULE>
|
|
133
|
+
static void Announce(const MODULE& module_, const JsonData::USBHub::DeviceMetadataInfo& device, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
134
|
+
{
|
|
135
|
+
JsonData::USBHub::AnnounceParamsInfo params_;
|
|
136
|
+
params_.Device = device;
|
|
137
|
+
|
|
138
|
+
Announce(module_, params_, sendIfMethod_);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// Event: 'announce' - Device Plugged in on the bus notification
|
|
142
|
+
template<typename MODULE>
|
|
143
|
+
static void Announce(const MODULE& module_, const IUSBHub::DeviceMetadata& device, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
144
|
+
{
|
|
145
|
+
JsonData::USBHub::AnnounceParamsInfo params_;
|
|
146
|
+
params_.Device = device;
|
|
147
|
+
|
|
148
|
+
Announce(module_, params_, sendIfMethod_);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
// Event: 'revoke' - Device removed from the bus notification
|
|
152
|
+
template<typename MODULE>
|
|
153
|
+
static void Revoke(const MODULE& module_, const JsonData::USBHub::AnnounceParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
154
|
+
{
|
|
155
|
+
module_.Notify(_T("revoke"), params, sendIfMethod_);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
// Event: 'revoke' - Device removed from the bus notification
|
|
159
|
+
template<typename MODULE>
|
|
160
|
+
static void Revoke(const MODULE& module_, const JsonData::USBHub::DeviceMetadataInfo& device, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
161
|
+
{
|
|
162
|
+
JsonData::USBHub::AnnounceParamsInfo params_;
|
|
163
|
+
params_.Device = device;
|
|
164
|
+
|
|
165
|
+
Revoke(module_, params_, sendIfMethod_);
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
// Event: 'revoke' - Device removed from the bus notification
|
|
169
|
+
template<typename MODULE>
|
|
170
|
+
static void Revoke(const MODULE& module_, const IUSBHub::DeviceMetadata& device, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
171
|
+
{
|
|
172
|
+
JsonData::USBHub::AnnounceParamsInfo params_;
|
|
173
|
+
params_.Device = device;
|
|
174
|
+
|
|
175
|
+
Revoke(module_, params_, sendIfMethod_);
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
} // namespace Event
|
|
179
|
+
|
|
180
|
+
POP_WARNING()
|
|
181
|
+
POP_WARNING()
|
|
182
|
+
POP_WARNING()
|
|
183
|
+
|
|
184
|
+
} // namespace JUSBHub
|
|
185
|
+
|
|
186
|
+
} // namespace Exchange
|
|
187
|
+
|
|
188
|
+
} // namespace Thunder
|
|
189
|
+
|
|
@@ -0,0 +1,456 @@
|
|
|
1
|
+
// Generated automatically from 'IValuePoint.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ValuePointCatalog.h"
|
|
6
|
+
#include <interfaces/IValuePoint.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace ValuePoint {
|
|
13
|
+
|
|
14
|
+
namespace JCatalog {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, IValuePoint::ICatalog* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
ASSERT(_module__.template Exists<IValuePoint>() == true);
|
|
34
|
+
|
|
35
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JCatalog"), Version::Major, Version::Minor, Version::Patch);
|
|
36
|
+
|
|
37
|
+
// Register methods and properties...
|
|
38
|
+
|
|
39
|
+
// Method: 'resource'
|
|
40
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ValuePoint::Catalog::ResourceParamsInfo, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::ValuePoint::Catalog::ResourceParamsInfo&, Core::JSON::String&)>>(_T("resource"),
|
|
41
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::ValuePoint::Catalog::ResourceParamsInfo& params, Core::JSON::String& interface) -> uint32_t {
|
|
42
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
43
|
+
|
|
44
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
45
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCatalog"), _T("resource")));
|
|
46
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
47
|
+
}
|
|
48
|
+
else {
|
|
49
|
+
const uint32_t _id_{params.Id};
|
|
50
|
+
string _interface_{};
|
|
51
|
+
Exchange::IValuePoint* _real_interface_{};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = _implementation__->Resource(_id_, _real_interface_);
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
_interface_ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(_real_interface_, context_);
|
|
57
|
+
_real_interface_->Release();
|
|
58
|
+
interface = std::move(_interface_);
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
return (_errorCode__);
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
// Method: 'resources'
|
|
66
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::DecUInt32>>(_T("resources"),
|
|
67
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::DecUInt32>& iterator) -> uint32_t {
|
|
68
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
69
|
+
|
|
70
|
+
RPC::IIteratorType<uint32_t, RPC::ID_VALUEITERATOR>* _iterator_{};
|
|
71
|
+
|
|
72
|
+
_errorCode__ = _implementation__->Resources(_iterator_);
|
|
73
|
+
|
|
74
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
75
|
+
iterator.Set(true);
|
|
76
|
+
|
|
77
|
+
if (_iterator_ != nullptr) {
|
|
78
|
+
uint32_t _resultItem__{};
|
|
79
|
+
while (_iterator_->Next(_resultItem__) == true) { iterator.Add() = _resultItem__; }
|
|
80
|
+
_iterator_->Release();
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
return (_errorCode__);
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
// Property: 'valuePoint::identifier' - Each IValuePoint instance has a unique identifier that identifies the instance (r/o)
|
|
88
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::DecUInt32&)>>(_T("valuePoint::identifier"),
|
|
89
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::DecUInt32& result) -> uint32_t {
|
|
90
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
91
|
+
|
|
92
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
93
|
+
|
|
94
|
+
if (_implementation__ != nullptr) {
|
|
95
|
+
uint32_t _result_{};
|
|
96
|
+
|
|
97
|
+
_errorCode__ = _implementation__->Identifier(_result_);
|
|
98
|
+
_implementation__->Release();
|
|
99
|
+
|
|
100
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
101
|
+
result = _result_;
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
else {
|
|
105
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
// Property: 'valuePoint::bundle' - If this IValuePoint belongs to a bundle that has multiple IValuePoints the id that identifies the bundle and the result will be Core::ERROR_NONE (r/o)
|
|
112
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::DecUInt32&)>>(_T("valuePoint::bundle"),
|
|
113
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::DecUInt32& result) -> uint32_t {
|
|
114
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
115
|
+
|
|
116
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
117
|
+
|
|
118
|
+
if (_implementation__ != nullptr) {
|
|
119
|
+
uint32_t _result_{};
|
|
120
|
+
|
|
121
|
+
_errorCode__ = _implementation__->Bundle(_result_);
|
|
122
|
+
_implementation__->Release();
|
|
123
|
+
|
|
124
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
125
|
+
result = _result_;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
else {
|
|
129
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
return (_errorCode__);
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
// Property: 'valuePoint::condition' - Current state/condition of this IValuePoint (r/o)
|
|
136
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::EnumType<Exchange::IValuePoint::condition>, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::EnumType<Exchange::IValuePoint::condition>&)>>(_T("valuePoint::condition"),
|
|
137
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::EnumType<Exchange::IValuePoint::condition>& result) -> uint32_t {
|
|
138
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
139
|
+
|
|
140
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
141
|
+
|
|
142
|
+
if (_implementation__ != nullptr) {
|
|
143
|
+
Exchange::IValuePoint::condition _result_{};
|
|
144
|
+
|
|
145
|
+
_errorCode__ = _implementation__->Condition(_result_);
|
|
146
|
+
_implementation__->Release();
|
|
147
|
+
|
|
148
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
149
|
+
result = _result_;
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
else {
|
|
153
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
return (_errorCode__);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
// Property: 'valuePoint::type' - Characteristics of this IValuePoint(IElement) (r/o)
|
|
160
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::DecUInt32&)>>(_T("valuePoint::type"),
|
|
161
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::DecUInt32& result) -> uint32_t {
|
|
162
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
163
|
+
|
|
164
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
165
|
+
|
|
166
|
+
if (_implementation__ != nullptr) {
|
|
167
|
+
uint32_t _result_{};
|
|
168
|
+
|
|
169
|
+
_errorCode__ = _implementation__->Type(_result_);
|
|
170
|
+
_implementation__->Release();
|
|
171
|
+
|
|
172
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
173
|
+
result = _result_;
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
else {
|
|
177
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
return (_errorCode__);
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
// Property: 'valuePoint::minimum' - The minimum value this IValuePoint(IElement) can reach (r/o)
|
|
184
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecSInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::DecSInt32&)>>(_T("valuePoint::minimum"),
|
|
185
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::DecSInt32& result) -> uint32_t {
|
|
186
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
187
|
+
|
|
188
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
189
|
+
|
|
190
|
+
if (_implementation__ != nullptr) {
|
|
191
|
+
int32_t _result_{};
|
|
192
|
+
|
|
193
|
+
_errorCode__ = _implementation__->Minimum(_result_);
|
|
194
|
+
_implementation__->Release();
|
|
195
|
+
|
|
196
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
197
|
+
result = _result_;
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
else {
|
|
201
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
return (_errorCode__);
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
// Property: 'valuePoint::maximum' - The maximum value this IValuePoint(IElement) can reach (r/o)
|
|
208
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecSInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, Core::JSON::DecSInt32&)>>(_T("valuePoint::maximum"),
|
|
209
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, Core::JSON::DecSInt32& result) -> uint32_t {
|
|
210
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
211
|
+
|
|
212
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
213
|
+
|
|
214
|
+
if (_implementation__ != nullptr) {
|
|
215
|
+
int32_t _result_{};
|
|
216
|
+
|
|
217
|
+
_errorCode__ = _implementation__->Maximum(_result_);
|
|
218
|
+
_implementation__->Release();
|
|
219
|
+
|
|
220
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
221
|
+
result = _result_;
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
else {
|
|
225
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
return (_errorCode__);
|
|
229
|
+
});
|
|
230
|
+
|
|
231
|
+
// Property: 'valuePoint::value' - The current value of this IValuePoint
|
|
232
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ValuePoint::Catalog::ValueData, Core::JSON::DecSInt32, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, const JsonData::ValuePoint::Catalog::ValueData&, Core::JSON::DecSInt32&)>>(_T("valuePoint::value"),
|
|
233
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, const JsonData::ValuePoint::Catalog::ValueData& params, Core::JSON::DecSInt32& result) -> uint32_t {
|
|
234
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
235
|
+
|
|
236
|
+
if (params.IsSet() == false) {
|
|
237
|
+
const IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
238
|
+
|
|
239
|
+
if (_implementation__ != nullptr) {
|
|
240
|
+
int32_t _result_{};
|
|
241
|
+
|
|
242
|
+
_errorCode__ = (static_cast<const IValuePoint*>(_implementation__))->Value(_result_);
|
|
243
|
+
_implementation__->Release();
|
|
244
|
+
|
|
245
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
246
|
+
result = _result_;
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
else {
|
|
250
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
else {
|
|
254
|
+
|
|
255
|
+
if (params.IsDataValid() == false) {
|
|
256
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCatalog"), _T("valuePoint::value")));
|
|
257
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
258
|
+
}
|
|
259
|
+
else {
|
|
260
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
261
|
+
|
|
262
|
+
if (_implementation__ != nullptr) {
|
|
263
|
+
const int32_t _value_{params.Value};
|
|
264
|
+
|
|
265
|
+
_errorCode__ = _implementation__->Value(_value_);
|
|
266
|
+
_implementation__->Release();
|
|
267
|
+
|
|
268
|
+
}
|
|
269
|
+
else {
|
|
270
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
271
|
+
}
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
result.Null(true);
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
return (_errorCode__);
|
|
278
|
+
});
|
|
279
|
+
|
|
280
|
+
// Property: 'valuePoint::metadata' - There most be more than meets the eye, report it as a JSON string (r/o)
|
|
281
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::ValuePoint::Catalog::InfoData, std::function<uint32_t(const Core::JSONRPC::Context&, Core::JSONRPC::instance_id_follows_t, const string&, JsonData::ValuePoint::Catalog::InfoData&)>>(_T("valuePoint::metadata"),
|
|
282
|
+
[_implementation__, &_module__](const Core::JSONRPC::Context& context_, Core::JSONRPC::instance_id_follows_t, const string& instanceId_, JsonData::ValuePoint::Catalog::InfoData& result) -> uint32_t {
|
|
283
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
284
|
+
|
|
285
|
+
IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
|
|
286
|
+
|
|
287
|
+
if (_implementation__ != nullptr) {
|
|
288
|
+
Exchange::IValuePoint::Info _result_{};
|
|
289
|
+
|
|
290
|
+
_errorCode__ = _implementation__->Metadata(_result_);
|
|
291
|
+
_implementation__->Release();
|
|
292
|
+
|
|
293
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
294
|
+
result.Set(true);
|
|
295
|
+
result = _result_;
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
else {
|
|
299
|
+
_errorCode__ = Core::ERROR_UNKNOWN_KEY;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
return (_errorCode__);
|
|
303
|
+
});
|
|
304
|
+
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
template<typename MODULE>
|
|
308
|
+
static void Unregister(MODULE& _module__)
|
|
309
|
+
{
|
|
310
|
+
// Unregister methods and properties...
|
|
311
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("resource"));
|
|
312
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("resources"));
|
|
313
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::identifier"));
|
|
314
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::bundle"));
|
|
315
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::condition"));
|
|
316
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::type"));
|
|
317
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::minimum"));
|
|
318
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::maximum"));
|
|
319
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::value"));
|
|
320
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("valuePoint::metadata"));
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
namespace Event {
|
|
324
|
+
|
|
325
|
+
// Event: 'activated' - Signal a new IValuePoint, with the given Id became actived
|
|
326
|
+
template<typename MODULE>
|
|
327
|
+
static void Activated(const MODULE& module_, const JsonData::ValuePoint::Catalog::ActivatedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
328
|
+
{
|
|
329
|
+
module_.Notify(_T("activated"), params, sendIfMethod_);
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
// Event: 'activated' - Signal a new IValuePoint, with the given Id became actived
|
|
333
|
+
template<typename MODULE>
|
|
334
|
+
static void Activated(const MODULE& module_, const Core::JSON::String& id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
335
|
+
{
|
|
336
|
+
JsonData::ValuePoint::Catalog::ActivatedParamsInfo params_;
|
|
337
|
+
params_.Id = id;
|
|
338
|
+
|
|
339
|
+
Activated(module_, params_, sendIfMethod_);
|
|
340
|
+
}
|
|
341
|
+
|
|
342
|
+
// Event: 'activated' - Signal a new IValuePoint, with the given Id became actived
|
|
343
|
+
template<typename MODULE>
|
|
344
|
+
static void Activated(const MODULE& module_, IValuePoint* const id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
345
|
+
{
|
|
346
|
+
JsonData::ValuePoint::Catalog::ActivatedParamsInfo params_;
|
|
347
|
+
params_.Id = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(id);
|
|
348
|
+
|
|
349
|
+
Activated(module_, params_, sendIfMethod_);
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
// Event: 'deactivated' - Signal a new IValuePoint, with the given Id became deactived
|
|
353
|
+
template<typename MODULE>
|
|
354
|
+
static void Deactivated(const MODULE& module_, const JsonData::ValuePoint::Catalog::ActivatedParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
355
|
+
{
|
|
356
|
+
module_.Notify(_T("deactivated"), params, sendIfMethod_);
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
// Event: 'deactivated' - Signal a new IValuePoint, with the given Id became deactived
|
|
360
|
+
template<typename MODULE>
|
|
361
|
+
static void Deactivated(const MODULE& module_, const Core::JSON::String& id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
362
|
+
{
|
|
363
|
+
JsonData::ValuePoint::Catalog::ActivatedParamsInfo params_;
|
|
364
|
+
params_.Id = id;
|
|
365
|
+
|
|
366
|
+
Deactivated(module_, params_, sendIfMethod_);
|
|
367
|
+
}
|
|
368
|
+
|
|
369
|
+
// Event: 'deactivated' - Signal a new IValuePoint, with the given Id became deactived
|
|
370
|
+
template<typename MODULE>
|
|
371
|
+
static void Deactivated(const MODULE& module_, IValuePoint* const id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
372
|
+
{
|
|
373
|
+
JsonData::ValuePoint::Catalog::ActivatedParamsInfo params_;
|
|
374
|
+
params_.Id = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<Exchange::IValuePoint>(id);
|
|
375
|
+
|
|
376
|
+
Deactivated(module_, params_, sendIfMethod_);
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
// Event: 'valuePoint#ID::update' - Signal event any change in value
|
|
380
|
+
template<typename MODULE>
|
|
381
|
+
static void Update(const MODULE& module_, const IValuePoint* const _obj, const JsonData::ValuePoint::Catalog::ResourceParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
382
|
+
{
|
|
383
|
+
ASSERT(_obj != nullptr);
|
|
384
|
+
|
|
385
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<IValuePoint>(_obj);
|
|
386
|
+
if (_instanceId.empty() == false) {
|
|
387
|
+
module_.Notify(Core::Format(_T("valuePoint#%s::update"), _instanceId.c_str()), params, sendIfMethod_);
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
|
|
391
|
+
// Event: 'valuePoint#ID::update' - Signal event any change in value
|
|
392
|
+
template<typename MODULE>
|
|
393
|
+
static void Update(const MODULE& module_, const IValuePoint* const _obj, const Core::JSON::DecUInt32& id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
394
|
+
{
|
|
395
|
+
JsonData::ValuePoint::Catalog::ResourceParamsInfo params_;
|
|
396
|
+
params_.Id = id;
|
|
397
|
+
|
|
398
|
+
Update(module_, _obj, params_, sendIfMethod_);
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
// Event: 'valuePoint#ID::update' - Signal event any change in value
|
|
402
|
+
template<typename MODULE>
|
|
403
|
+
static void Update(const MODULE& module_, const IValuePoint* const _obj, const uint32_t id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
404
|
+
{
|
|
405
|
+
JsonData::ValuePoint::Catalog::ResourceParamsInfo params_;
|
|
406
|
+
params_.Id = id;
|
|
407
|
+
|
|
408
|
+
Update(module_, _obj, params_, sendIfMethod_);
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
// Event: 'valuePoint#ID::metadata' - Signal event any change in Metadata
|
|
412
|
+
template<typename MODULE>
|
|
413
|
+
static void Metadata(const MODULE& module_, const IValuePoint* const _obj, const JsonData::ValuePoint::Catalog::ResourceParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
414
|
+
{
|
|
415
|
+
ASSERT(_obj != nullptr);
|
|
416
|
+
|
|
417
|
+
const string _instanceId = module_.PluginHost::JSONRPCSupportsObjectLookup::template InstanceId<IValuePoint>(_obj);
|
|
418
|
+
if (_instanceId.empty() == false) {
|
|
419
|
+
module_.Notify(Core::Format(_T("valuePoint#%s::metadata"), _instanceId.c_str()), params, sendIfMethod_);
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
// Event: 'valuePoint#ID::metadata' - Signal event any change in Metadata
|
|
424
|
+
template<typename MODULE>
|
|
425
|
+
static void Metadata(const MODULE& module_, const IValuePoint* const _obj, const Core::JSON::DecUInt32& id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
426
|
+
{
|
|
427
|
+
JsonData::ValuePoint::Catalog::ResourceParamsInfo params_;
|
|
428
|
+
params_.Id = id;
|
|
429
|
+
|
|
430
|
+
Metadata(module_, _obj, params_, sendIfMethod_);
|
|
431
|
+
}
|
|
432
|
+
|
|
433
|
+
// Event: 'valuePoint#ID::metadata' - Signal event any change in Metadata
|
|
434
|
+
template<typename MODULE>
|
|
435
|
+
static void Metadata(const MODULE& module_, const IValuePoint* const _obj, const uint32_t id, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
436
|
+
{
|
|
437
|
+
JsonData::ValuePoint::Catalog::ResourceParamsInfo params_;
|
|
438
|
+
params_.Id = id;
|
|
439
|
+
|
|
440
|
+
Metadata(module_, _obj, params_, sendIfMethod_);
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
} // namespace Event
|
|
444
|
+
|
|
445
|
+
POP_WARNING()
|
|
446
|
+
POP_WARNING()
|
|
447
|
+
POP_WARNING()
|
|
448
|
+
|
|
449
|
+
} // namespace JCatalog
|
|
450
|
+
|
|
451
|
+
} // namespace ValuePoint
|
|
452
|
+
|
|
453
|
+
} // namespace Exchange
|
|
454
|
+
|
|
455
|
+
} // namespace Thunder
|
|
456
|
+
|
|
@@ -0,0 +1,162 @@
|
|
|
1
|
+
// Generated automatically from 'IVolumeControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_VolumeControl.h"
|
|
6
|
+
#include <interfaces/IVolumeControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JVolumeControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IVolumeControl* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JVolumeControl"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Property: 'muted' - Audio mute state
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, Core::JSON::Boolean>(_T("muted"),
|
|
37
|
+
[_implementation__](const Core::JSON::Boolean& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if (params.IsSet() == false) {
|
|
41
|
+
bool _result_{};
|
|
42
|
+
|
|
43
|
+
_errorCode__ = (static_cast<const IVolumeControl*>(_implementation__))->Muted(_result_);
|
|
44
|
+
|
|
45
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
46
|
+
result = _result_;
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
else {
|
|
50
|
+
const bool _params_{params};
|
|
51
|
+
|
|
52
|
+
_errorCode__ = _implementation__->Muted(_params_);
|
|
53
|
+
|
|
54
|
+
result.Null(true);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return (_errorCode__);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
// Property: 'volume' - Audio volume level
|
|
61
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::DecUInt8, Core::JSON::DecUInt8>(_T("volume"),
|
|
62
|
+
[_implementation__](const Core::JSON::DecUInt8& params, Core::JSON::DecUInt8& result) -> uint32_t {
|
|
63
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
64
|
+
|
|
65
|
+
if (params.IsSet() == false) {
|
|
66
|
+
uint8_t _result_{};
|
|
67
|
+
|
|
68
|
+
_errorCode__ = (static_cast<const IVolumeControl*>(_implementation__))->Volume(_result_);
|
|
69
|
+
|
|
70
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
71
|
+
result = _result_;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
else {
|
|
75
|
+
const uint8_t _params_{params};
|
|
76
|
+
|
|
77
|
+
_errorCode__ = _implementation__->Volume(_params_);
|
|
78
|
+
|
|
79
|
+
result.Null(true);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
return (_errorCode__);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
template<typename MODULE>
|
|
88
|
+
static void Unregister(MODULE& _module__)
|
|
89
|
+
{
|
|
90
|
+
// Unregister methods and properties...
|
|
91
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("muted"));
|
|
92
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("volume"));
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
namespace Event {
|
|
96
|
+
|
|
97
|
+
// Event: 'volume' - Signals volume change
|
|
98
|
+
template<typename MODULE>
|
|
99
|
+
static void Volume(const MODULE& module_, const JsonData::VolumeControl::VolumeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
100
|
+
{
|
|
101
|
+
module_.Notify(_T("volume"), params, sendIfMethod_);
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
// Event: 'volume' - Signals volume change
|
|
105
|
+
template<typename MODULE>
|
|
106
|
+
static void Volume(const MODULE& module_, const Core::JSON::DecUInt8& volume, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
107
|
+
{
|
|
108
|
+
JsonData::VolumeControl::VolumeParamsData params_;
|
|
109
|
+
params_.Volume = volume;
|
|
110
|
+
|
|
111
|
+
Volume(module_, params_, sendIfMethod_);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
// Event: 'volume' - Signals volume change
|
|
115
|
+
template<typename MODULE>
|
|
116
|
+
static void Volume(const MODULE& module_, const uint8_t volume, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
117
|
+
{
|
|
118
|
+
JsonData::VolumeControl::VolumeParamsData params_;
|
|
119
|
+
params_.Volume = volume;
|
|
120
|
+
|
|
121
|
+
Volume(module_, params_, sendIfMethod_);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
// Event: 'muted' - Signals mute state change
|
|
125
|
+
template<typename MODULE>
|
|
126
|
+
static void Muted(const MODULE& module_, const JsonData::VolumeControl::MutedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
127
|
+
{
|
|
128
|
+
module_.Notify(_T("muted"), params, sendIfMethod_);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// Event: 'muted' - Signals mute state change
|
|
132
|
+
template<typename MODULE>
|
|
133
|
+
static void Muted(const MODULE& module_, const Core::JSON::Boolean& muted, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
134
|
+
{
|
|
135
|
+
JsonData::VolumeControl::MutedParamsData params_;
|
|
136
|
+
params_.Muted = muted;
|
|
137
|
+
|
|
138
|
+
Muted(module_, params_, sendIfMethod_);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// Event: 'muted' - Signals mute state change
|
|
142
|
+
template<typename MODULE>
|
|
143
|
+
static void Muted(const MODULE& module_, const bool muted, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
144
|
+
{
|
|
145
|
+
JsonData::VolumeControl::MutedParamsData params_;
|
|
146
|
+
params_.Muted = muted;
|
|
147
|
+
|
|
148
|
+
Muted(module_, params_, sendIfMethod_);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
} // namespace Event
|
|
152
|
+
|
|
153
|
+
POP_WARNING()
|
|
154
|
+
POP_WARNING()
|
|
155
|
+
POP_WARNING()
|
|
156
|
+
|
|
157
|
+
} // namespace JVolumeControl
|
|
158
|
+
|
|
159
|
+
} // namespace Exchange
|
|
160
|
+
|
|
161
|
+
} // namespace Thunder
|
|
162
|
+
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
// Generated automatically from 'IWatchDog.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_WatchDog.h"
|
|
6
|
+
#include <interfaces/IWatchDog.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JWatchDog {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IWatchDog* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JWatchDog"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'touch' - Touch the watchdog as a sign of life
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::WatchDog::TouchParamsData, void>(_T("touch"),
|
|
37
|
+
[_implementation__](const JsonData::WatchDog::TouchParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWatchDog"), _T("touch")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _callsign_{params.Callsign};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->Touch(_callsign_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
template<typename MODULE>
|
|
57
|
+
static void Unregister(MODULE& _module__)
|
|
58
|
+
{
|
|
59
|
+
// Unregister methods and properties...
|
|
60
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("touch"));
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
POP_WARNING()
|
|
64
|
+
POP_WARNING()
|
|
65
|
+
POP_WARNING()
|
|
66
|
+
|
|
67
|
+
} // namespace JWatchDog
|
|
68
|
+
|
|
69
|
+
} // namespace Exchange
|
|
70
|
+
|
|
71
|
+
} // namespace Thunder
|
|
72
|
+
|
|
@@ -0,0 +1,430 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_WebBrowser.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JWebBrowser {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IWebBrowser* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JWebBrowser"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'collectgarbage' - Initiate garbage collection
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("collectgarbage"),
|
|
37
|
+
[_implementation__]() -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
_errorCode__ = _implementation__->CollectGarbage();
|
|
41
|
+
|
|
42
|
+
return (_errorCode__);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
// Property: 'url' - Page loaded in the browser
|
|
46
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("url"),
|
|
47
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
48
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
49
|
+
|
|
50
|
+
if (params.IsSet() == false) {
|
|
51
|
+
string _result_{};
|
|
52
|
+
|
|
53
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->URL(_result_);
|
|
54
|
+
|
|
55
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
56
|
+
result = _result_;
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
else {
|
|
60
|
+
const string _params_{params};
|
|
61
|
+
|
|
62
|
+
_errorCode__ = _implementation__->URL(_params_);
|
|
63
|
+
|
|
64
|
+
result.Null(true);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
return (_errorCode__);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
// Property: 'visibility' - Browser window visibility state
|
|
71
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IWebBrowser::VisibilityType>, Core::JSON::EnumType<Exchange::IWebBrowser::VisibilityType>>(_T("visibility"),
|
|
72
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IWebBrowser::VisibilityType>& params, Core::JSON::EnumType<Exchange::IWebBrowser::VisibilityType>& result) -> uint32_t {
|
|
73
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
74
|
+
|
|
75
|
+
if (params.IsSet() == false) {
|
|
76
|
+
Exchange::IWebBrowser::VisibilityType _result_{};
|
|
77
|
+
|
|
78
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->Visibility(_result_);
|
|
79
|
+
|
|
80
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
81
|
+
result = _result_;
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
else {
|
|
85
|
+
const Exchange::IWebBrowser::VisibilityType _params_{params};
|
|
86
|
+
|
|
87
|
+
_errorCode__ = _implementation__->Visibility(_params_);
|
|
88
|
+
|
|
89
|
+
result.Null(true);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
return (_errorCode__);
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
// Property: 'fps' - Current framerate the browser is rendering at (r/o)
|
|
96
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::DecUInt8>(_T("fps"),
|
|
97
|
+
[_implementation__](Core::JSON::DecUInt8& result) -> uint32_t {
|
|
98
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
99
|
+
|
|
100
|
+
uint8_t _result_{};
|
|
101
|
+
|
|
102
|
+
_errorCode__ = _implementation__->FPS(_result_);
|
|
103
|
+
|
|
104
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
105
|
+
result = _result_;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
// Property: 'headers' - Headers to send on all requests that the browser makes
|
|
112
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("headers"),
|
|
113
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
114
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
115
|
+
|
|
116
|
+
if (params.IsSet() == false) {
|
|
117
|
+
string _result_{};
|
|
118
|
+
|
|
119
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->HeaderList(_result_);
|
|
120
|
+
|
|
121
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
122
|
+
|
|
123
|
+
if (_result_.empty() == false) {
|
|
124
|
+
result = _result_;
|
|
125
|
+
result.SetQuoted(false);
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
else {
|
|
130
|
+
const string _params_{params};
|
|
131
|
+
|
|
132
|
+
_errorCode__ = _implementation__->HeaderList(_params_);
|
|
133
|
+
|
|
134
|
+
result.Null(true);
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
return (_errorCode__);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
// Property: 'useragent' - UserAgent string used by the browser
|
|
141
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, Core::JSON::String>(_T("useragent"),
|
|
142
|
+
[_implementation__](const Core::JSON::String& params, Core::JSON::String& result) -> uint32_t {
|
|
143
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
144
|
+
|
|
145
|
+
if (params.IsSet() == false) {
|
|
146
|
+
string _result_{};
|
|
147
|
+
|
|
148
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->UserAgent(_result_);
|
|
149
|
+
|
|
150
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
151
|
+
result = _result_;
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
else {
|
|
155
|
+
const string _params_{params};
|
|
156
|
+
|
|
157
|
+
_errorCode__ = _implementation__->UserAgent(_params_);
|
|
158
|
+
|
|
159
|
+
result.Null(true);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
return (_errorCode__);
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
// Property: 'localstorageenabled' - Controls the local storage availability
|
|
166
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, Core::JSON::Boolean>(_T("localstorageenabled"),
|
|
167
|
+
[_implementation__](const Core::JSON::Boolean& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
168
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
169
|
+
|
|
170
|
+
if (params.IsSet() == false) {
|
|
171
|
+
bool _result_{};
|
|
172
|
+
|
|
173
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->LocalStorageEnabled(_result_);
|
|
174
|
+
|
|
175
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
176
|
+
result = _result_;
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
else {
|
|
180
|
+
const bool _params_{params};
|
|
181
|
+
|
|
182
|
+
_errorCode__ = _implementation__->LocalStorageEnabled(_params_);
|
|
183
|
+
|
|
184
|
+
result.Null(true);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
return (_errorCode__);
|
|
188
|
+
});
|
|
189
|
+
|
|
190
|
+
// Property: 'httpcookieacceptpolicy' - HTTP cookies accept policy
|
|
191
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IWebBrowser::HTTPCookieAcceptPolicyType>, Core::JSON::EnumType<Exchange::IWebBrowser::HTTPCookieAcceptPolicyType>>(_T("httpcookieacceptpolicy"),
|
|
192
|
+
[_implementation__](const Core::JSON::EnumType<Exchange::IWebBrowser::HTTPCookieAcceptPolicyType>& params, Core::JSON::EnumType<Exchange::IWebBrowser::HTTPCookieAcceptPolicyType>& result) -> uint32_t {
|
|
193
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
194
|
+
|
|
195
|
+
if (params.IsSet() == false) {
|
|
196
|
+
Exchange::IWebBrowser::HTTPCookieAcceptPolicyType _result_{};
|
|
197
|
+
|
|
198
|
+
_errorCode__ = (static_cast<const IWebBrowser*>(_implementation__))->HTTPCookieAcceptPolicy(_result_);
|
|
199
|
+
|
|
200
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
201
|
+
result = _result_;
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
else {
|
|
205
|
+
const Exchange::IWebBrowser::HTTPCookieAcceptPolicyType _params_{params};
|
|
206
|
+
|
|
207
|
+
_errorCode__ = _implementation__->HTTPCookieAcceptPolicy(_params_);
|
|
208
|
+
|
|
209
|
+
result.Null(true);
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
return (_errorCode__);
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
// Property: 'bridgereply' - Response for legacy $badger (w/o)
|
|
216
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("bridgereply"),
|
|
217
|
+
[_implementation__](const Core::JSON::String& params) -> uint32_t {
|
|
218
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
219
|
+
|
|
220
|
+
if (params.IsSet() == false) {
|
|
221
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowser"), _T("bridgereply")));
|
|
222
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
223
|
+
}
|
|
224
|
+
else {
|
|
225
|
+
const string _params_{params};
|
|
226
|
+
|
|
227
|
+
_errorCode__ = _implementation__->BridgeReply(_params_);
|
|
228
|
+
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
return (_errorCode__);
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
// Property: 'bridgeevent' - Send legacy $badger event (w/o)
|
|
235
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("bridgeevent"),
|
|
236
|
+
[_implementation__](const Core::JSON::String& params) -> uint32_t {
|
|
237
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
238
|
+
|
|
239
|
+
if (params.IsSet() == false) {
|
|
240
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowser"), _T("bridgeevent")));
|
|
241
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
242
|
+
}
|
|
243
|
+
else {
|
|
244
|
+
const string _params_{params};
|
|
245
|
+
|
|
246
|
+
_errorCode__ = _implementation__->BridgeEvent(_params_);
|
|
247
|
+
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
return (_errorCode__);
|
|
251
|
+
});
|
|
252
|
+
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
template<typename MODULE>
|
|
256
|
+
static void Unregister(MODULE& _module__)
|
|
257
|
+
{
|
|
258
|
+
// Unregister methods and properties...
|
|
259
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("collectgarbage"));
|
|
260
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("url"));
|
|
261
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("visibility"));
|
|
262
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("fps"));
|
|
263
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("headers"));
|
|
264
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("useragent"));
|
|
265
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("localstorageenabled"));
|
|
266
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("httpcookieacceptpolicy"));
|
|
267
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("bridgereply"));
|
|
268
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("bridgeevent"));
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
namespace Event {
|
|
272
|
+
|
|
273
|
+
// Event: 'loadfinished' - Initial HTML document has been completely loaded and parsed
|
|
274
|
+
template<typename MODULE>
|
|
275
|
+
static void LoadFinished(const MODULE& module_, const JsonData::WebBrowser::LoadFinishedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
276
|
+
{
|
|
277
|
+
module_.Notify(_T("loadfinished"), params, sendIfMethod_);
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
// Event: 'loadfinished' - Initial HTML document has been completely loaded and parsed
|
|
281
|
+
template<typename MODULE>
|
|
282
|
+
static void LoadFinished(const MODULE& module_, const Core::JSON::String& URL, const Core::JSON::DecSInt32& httpstatus, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
283
|
+
{
|
|
284
|
+
JsonData::WebBrowser::LoadFinishedParamsData params_;
|
|
285
|
+
params_.URL = URL;
|
|
286
|
+
params_.Httpstatus = httpstatus;
|
|
287
|
+
|
|
288
|
+
LoadFinished(module_, params_, sendIfMethod_);
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
// Event: 'loadfinished' - Initial HTML document has been completely loaded and parsed
|
|
292
|
+
template<typename MODULE>
|
|
293
|
+
static void LoadFinished(const MODULE& module_, const string& URL, const int32_t httpstatus, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
294
|
+
{
|
|
295
|
+
JsonData::WebBrowser::LoadFinishedParamsData params_;
|
|
296
|
+
params_.URL = URL;
|
|
297
|
+
params_.Httpstatus = httpstatus;
|
|
298
|
+
|
|
299
|
+
LoadFinished(module_, params_, sendIfMethod_);
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
// Event: 'loadfailed' - Browser failed to load page
|
|
303
|
+
template<typename MODULE>
|
|
304
|
+
static void LoadFailed(const MODULE& module_, const JsonData::WebBrowser::LoadFailedParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
305
|
+
{
|
|
306
|
+
module_.Notify(_T("loadfailed"), params, sendIfMethod_);
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
// Event: 'loadfailed' - Browser failed to load page
|
|
310
|
+
template<typename MODULE>
|
|
311
|
+
static void LoadFailed(const MODULE& module_, const Core::JSON::String& URL, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
312
|
+
{
|
|
313
|
+
JsonData::WebBrowser::LoadFailedParamsData params_;
|
|
314
|
+
params_.URL = URL;
|
|
315
|
+
|
|
316
|
+
LoadFailed(module_, params_, sendIfMethod_);
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
// Event: 'loadfailed' - Browser failed to load page
|
|
320
|
+
template<typename MODULE>
|
|
321
|
+
static void LoadFailed(const MODULE& module_, const string& URL, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
322
|
+
{
|
|
323
|
+
JsonData::WebBrowser::LoadFailedParamsData params_;
|
|
324
|
+
params_.URL = URL;
|
|
325
|
+
|
|
326
|
+
LoadFailed(module_, params_, sendIfMethod_);
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
// Event: 'urlchange' - Signals a URL change in the browser
|
|
330
|
+
template<typename MODULE>
|
|
331
|
+
static void URLChange(const MODULE& module_, const JsonData::WebBrowser::URLChangeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
332
|
+
{
|
|
333
|
+
module_.Notify(_T("urlchange"), params, sendIfMethod_);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
// Event: 'urlchange' - Signals a URL change in the browser
|
|
337
|
+
template<typename MODULE>
|
|
338
|
+
static void URLChange(const MODULE& module_, const Core::JSON::String& URL, const Core::JSON::Boolean& loaded, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
339
|
+
{
|
|
340
|
+
JsonData::WebBrowser::URLChangeParamsData params_;
|
|
341
|
+
params_.URL = URL;
|
|
342
|
+
params_.Loaded = loaded;
|
|
343
|
+
|
|
344
|
+
URLChange(module_, params_, sendIfMethod_);
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
// Event: 'urlchange' - Signals a URL change in the browser
|
|
348
|
+
template<typename MODULE>
|
|
349
|
+
static void URLChange(const MODULE& module_, const string& URL, const bool loaded, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
350
|
+
{
|
|
351
|
+
JsonData::WebBrowser::URLChangeParamsData params_;
|
|
352
|
+
params_.URL = URL;
|
|
353
|
+
params_.Loaded = loaded;
|
|
354
|
+
|
|
355
|
+
URLChange(module_, params_, sendIfMethod_);
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
// Event: 'visibilitychange' - Signals a visibility change of the browser
|
|
359
|
+
template<typename MODULE>
|
|
360
|
+
static void VisibilityChange(const MODULE& module_, const JsonData::WebBrowser::VisibilityChangeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
361
|
+
{
|
|
362
|
+
module_.Notify(_T("visibilitychange"), params, sendIfMethod_);
|
|
363
|
+
}
|
|
364
|
+
|
|
365
|
+
// Event: 'visibilitychange' - Signals a visibility change of the browser
|
|
366
|
+
template<typename MODULE>
|
|
367
|
+
static void VisibilityChange(const MODULE& module_, const Core::JSON::Boolean& hidden, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
368
|
+
{
|
|
369
|
+
JsonData::WebBrowser::VisibilityChangeParamsData params_;
|
|
370
|
+
params_.Hidden = hidden;
|
|
371
|
+
|
|
372
|
+
VisibilityChange(module_, params_, sendIfMethod_);
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
// Event: 'visibilitychange' - Signals a visibility change of the browser
|
|
376
|
+
template<typename MODULE>
|
|
377
|
+
static void VisibilityChange(const MODULE& module_, const bool hidden, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
378
|
+
{
|
|
379
|
+
JsonData::WebBrowser::VisibilityChangeParamsData params_;
|
|
380
|
+
params_.Hidden = hidden;
|
|
381
|
+
|
|
382
|
+
VisibilityChange(module_, params_, sendIfMethod_);
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
// Event: 'pageclosure' - Notifies that the web page requests to close its window
|
|
386
|
+
template<typename MODULE>
|
|
387
|
+
static void PageClosure(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
388
|
+
{
|
|
389
|
+
module_.Notify(_T("pageclosure"), sendIfMethod_);
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
// Event: 'bridgequery' - A Base64 encoded JSON message from legacy $badger bridge
|
|
393
|
+
template<typename MODULE>
|
|
394
|
+
static void BridgeQuery(const MODULE& module_, const JsonData::WebBrowser::BridgeQueryParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
395
|
+
{
|
|
396
|
+
module_.Notify(_T("bridgequery"), params, sendIfMethod_);
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
// Event: 'bridgequery' - A Base64 encoded JSON message from legacy $badger bridge
|
|
400
|
+
template<typename MODULE>
|
|
401
|
+
static void BridgeQuery(const MODULE& module_, const Core::JSON::String& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
402
|
+
{
|
|
403
|
+
JsonData::WebBrowser::BridgeQueryParamsData params_;
|
|
404
|
+
params_.Message = message;
|
|
405
|
+
|
|
406
|
+
BridgeQuery(module_, params_, sendIfMethod_);
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
// Event: 'bridgequery' - A Base64 encoded JSON message from legacy $badger bridge
|
|
410
|
+
template<typename MODULE>
|
|
411
|
+
static void BridgeQuery(const MODULE& module_, const string& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
412
|
+
{
|
|
413
|
+
JsonData::WebBrowser::BridgeQueryParamsData params_;
|
|
414
|
+
params_.Message = message;
|
|
415
|
+
|
|
416
|
+
BridgeQuery(module_, params_, sendIfMethod_);
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
} // namespace Event
|
|
420
|
+
|
|
421
|
+
POP_WARNING()
|
|
422
|
+
POP_WARNING()
|
|
423
|
+
POP_WARNING()
|
|
424
|
+
|
|
425
|
+
} // namespace JWebBrowser
|
|
426
|
+
|
|
427
|
+
} // namespace Exchange
|
|
428
|
+
|
|
429
|
+
} // namespace Thunder
|
|
430
|
+
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_WebBrowserExt.h"
|
|
6
|
+
#include <interfaces/IBrowser.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JWebBrowserExt {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IWebBrowserExt* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JWebBrowserExt"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'deletedir' - Removes contents of a directory from the persistent storage (DEPRECATED)
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::WebBrowserExt::DeleteDirParamsData, void>(_T("deletedir"),
|
|
37
|
+
[_implementation__](const JsonData::WebBrowserExt::DeleteDirParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowserExt"), _T("deletedir")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _path_{params.Path};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->DeleteDir(_path_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
_module__.PluginHost::JSONRPC::Register(_T("delete"), _T("deletedir"));
|
|
55
|
+
|
|
56
|
+
// Property: 'languages' - User preferred languages
|
|
57
|
+
_module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("languages"),
|
|
58
|
+
[_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
59
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
60
|
+
|
|
61
|
+
if (params.IsSet() == false) {
|
|
62
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
63
|
+
|
|
64
|
+
_errorCode__ = (static_cast<const IWebBrowserExt*>(_implementation__))->Languages(_result_);
|
|
65
|
+
|
|
66
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
67
|
+
result.Set(true);
|
|
68
|
+
|
|
69
|
+
if (_result_ != nullptr) {
|
|
70
|
+
string _resultItem__{};
|
|
71
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
72
|
+
_result_->Release();
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
else {
|
|
77
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
|
|
78
|
+
std::list<string> _paramsElements_{};
|
|
79
|
+
auto _paramsIterator_ = params.Elements();
|
|
80
|
+
while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
|
|
81
|
+
using _paramsIteratorImplType_ = RPC::IteratorType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
|
|
82
|
+
_params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
|
|
83
|
+
ASSERT(_params_ != nullptr);
|
|
84
|
+
|
|
85
|
+
_errorCode__ = _implementation__->Languages(static_cast<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
|
|
86
|
+
if (_params_ != nullptr) {
|
|
87
|
+
_params_->Release();
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
result.Null(true);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
return (_errorCode__);
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
template<typename MODULE>
|
|
99
|
+
static void Unregister(MODULE& _module__)
|
|
100
|
+
{
|
|
101
|
+
// Unregister methods and properties...
|
|
102
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("deletedir"));
|
|
103
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("delete"));
|
|
104
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("languages"));
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
POP_WARNING()
|
|
109
|
+
POP_WARNING()
|
|
110
|
+
|
|
111
|
+
} // namespace JWebBrowserExt
|
|
112
|
+
|
|
113
|
+
} // namespace Exchange
|
|
114
|
+
|
|
115
|
+
} // namespace Thunder
|
|
116
|
+
|
|
@@ -0,0 +1,290 @@
|
|
|
1
|
+
// Generated automatically from 'IWifiControl.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_WifiControl.h"
|
|
6
|
+
#include <interfaces/IWifiControl.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JWifiControl {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IWifiControl* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JWifiControl"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'scan' - Trigger Scanning
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("scan"),
|
|
37
|
+
[_implementation__]() -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
_errorCode__ = _implementation__->Scan();
|
|
41
|
+
|
|
42
|
+
return (_errorCode__);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
// Method: 'abortscan' - Abort Currentlt running scan
|
|
46
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("abortscan"),
|
|
47
|
+
[_implementation__]() -> uint32_t {
|
|
48
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
49
|
+
|
|
50
|
+
_errorCode__ = _implementation__->AbortScan();
|
|
51
|
+
|
|
52
|
+
return (_errorCode__);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
// Method: 'connect' - Connect device to requested SSID
|
|
56
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::WifiControl::ConnectParamsInfo, void>(_T("connect"),
|
|
57
|
+
[_implementation__](const JsonData::WifiControl::ConnectParamsInfo& params) -> uint32_t {
|
|
58
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
59
|
+
|
|
60
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
61
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("connect")));
|
|
62
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
63
|
+
}
|
|
64
|
+
else {
|
|
65
|
+
const string _configSSID_{params.ConfigSSID};
|
|
66
|
+
|
|
67
|
+
_errorCode__ = _implementation__->Connect(_configSSID_);
|
|
68
|
+
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
return (_errorCode__);
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
// Method: 'disconnect' - Disconnect device from requested SSID
|
|
75
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::WifiControl::ConnectParamsInfo, void>(_T("disconnect"),
|
|
76
|
+
[_implementation__](const JsonData::WifiControl::ConnectParamsInfo& params) -> uint32_t {
|
|
77
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
78
|
+
|
|
79
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
80
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("disconnect")));
|
|
81
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
82
|
+
}
|
|
83
|
+
else {
|
|
84
|
+
const string _configSSID_{params.ConfigSSID};
|
|
85
|
+
|
|
86
|
+
_errorCode__ = _implementation__->Disconnect(_configSSID_);
|
|
87
|
+
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
return (_errorCode__);
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
// Method: 'status' - Status of current device, like which SSID is connected and it is in scanning state or not
|
|
94
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::WifiControl::StatusResultData>(_T("status"),
|
|
95
|
+
[_implementation__](JsonData::WifiControl::StatusResultData& result) -> uint32_t {
|
|
96
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
97
|
+
|
|
98
|
+
string _connectedSsid_{};
|
|
99
|
+
bool _isScanning_{};
|
|
100
|
+
|
|
101
|
+
_errorCode__ = _implementation__->Status(_connectedSsid_, _isScanning_);
|
|
102
|
+
|
|
103
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
104
|
+
result.ConnectedSsid = _connectedSsid_;
|
|
105
|
+
result.IsScanning = _isScanning_;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
return (_errorCode__);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
// Property: 'networks' - Provides available networks information (r/o)
|
|
112
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::WifiControl::NetworkInfoData>>(_T("networks"),
|
|
113
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::WifiControl::NetworkInfoData>& result) -> uint32_t {
|
|
114
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
115
|
+
|
|
116
|
+
RPC::IIteratorType<Exchange::IWifiControl::NetworkInfo, Exchange::ID_WIFICONTROL_NETWORK_INFO_ITERATOR>* _result_{};
|
|
117
|
+
|
|
118
|
+
_errorCode__ = _implementation__->Networks(_result_);
|
|
119
|
+
|
|
120
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
121
|
+
result.Set(true);
|
|
122
|
+
|
|
123
|
+
if (_result_ != nullptr) {
|
|
124
|
+
Exchange::IWifiControl::NetworkInfo _resultItem__{};
|
|
125
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
126
|
+
_result_->Release();
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
return (_errorCode__);
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
// Indexed Property: 'securities' - Provides security method of requested SSID (r/o)
|
|
134
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::WifiControl::SecurityInfoData>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::WifiControl::SecurityInfoData>&)>>(_T("securities"),
|
|
135
|
+
[_implementation__](const string& ssid, Core::JSON::ArrayType<JsonData::WifiControl::SecurityInfoData>& result) -> uint32_t {
|
|
136
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
137
|
+
|
|
138
|
+
if (ssid.empty() == true) {
|
|
139
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("securities")));
|
|
140
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
144
|
+
RPC::IIteratorType<Exchange::IWifiControl::SecurityInfo, Exchange::ID_WIFICONTROL_SECURITY_INFO_ITERATOR>* _result_{};
|
|
145
|
+
|
|
146
|
+
_errorCode__ = _implementation__->Securities(ssid, _result_);
|
|
147
|
+
|
|
148
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
149
|
+
result.Set(true);
|
|
150
|
+
|
|
151
|
+
if (_result_ != nullptr) {
|
|
152
|
+
Exchange::IWifiControl::SecurityInfo _resultItem__{};
|
|
153
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
154
|
+
_result_->Release();
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
return (_errorCode__);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
// Property: 'configs' - Provides configs list (r/o)
|
|
163
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("configs"),
|
|
164
|
+
[_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
|
|
165
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
166
|
+
|
|
167
|
+
RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
|
|
168
|
+
|
|
169
|
+
_errorCode__ = _implementation__->Configs(_result_);
|
|
170
|
+
|
|
171
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
172
|
+
result.Set(true);
|
|
173
|
+
|
|
174
|
+
if (_result_ != nullptr) {
|
|
175
|
+
string _resultItem__{};
|
|
176
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
177
|
+
_result_->Release();
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
return (_errorCode__);
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
// Indexed Property: 'config' - Provide config details for requested SSID
|
|
185
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::WifiControl::ConfigData, JsonData::WifiControl::ConfigInfoInfo, std::function<uint32_t(const string&, const JsonData::WifiControl::ConfigData&, JsonData::WifiControl::ConfigInfoInfo&)>>(_T("config"),
|
|
186
|
+
[_implementation__](const string& ssid, const JsonData::WifiControl::ConfigData& params, JsonData::WifiControl::ConfigInfoInfo& result) -> uint32_t {
|
|
187
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
188
|
+
|
|
189
|
+
if (ssid.empty() == true) {
|
|
190
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("config")));
|
|
191
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
195
|
+
|
|
196
|
+
if (params.IsSet() == false) {
|
|
197
|
+
Exchange::IWifiControl::ConfigInfo _result_{};
|
|
198
|
+
|
|
199
|
+
_errorCode__ = (static_cast<const IWifiControl*>(_implementation__))->Config(ssid, _result_);
|
|
200
|
+
|
|
201
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
202
|
+
result.Set(true);
|
|
203
|
+
result = _result_;
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
else {
|
|
207
|
+
|
|
208
|
+
if (params.IsDataValid() == false) {
|
|
209
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("config")));
|
|
210
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
211
|
+
}
|
|
212
|
+
else {
|
|
213
|
+
const Exchange::IWifiControl::ConfigInfo _value_(params.Value);
|
|
214
|
+
|
|
215
|
+
_errorCode__ = _implementation__->Config(ssid, _value_);
|
|
216
|
+
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
result.Null(true);
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
return (_errorCode__);
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
template<typename MODULE>
|
|
229
|
+
static void Unregister(MODULE& _module__)
|
|
230
|
+
{
|
|
231
|
+
// Unregister methods and properties...
|
|
232
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("scan"));
|
|
233
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("abortscan"));
|
|
234
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("connect"));
|
|
235
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("disconnect"));
|
|
236
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("status"));
|
|
237
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("networks"));
|
|
238
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("securities"));
|
|
239
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("configs"));
|
|
240
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("config"));
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
namespace Event {
|
|
244
|
+
|
|
245
|
+
// Event: 'networkchange' - Notifies that Network were added, removed or modified
|
|
246
|
+
template<typename MODULE>
|
|
247
|
+
static void NetworkChange(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
248
|
+
{
|
|
249
|
+
module_.Notify(_T("networkchange"), sendIfMethod_);
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
// Event: 'connectionchange' - Notifies that wifi connection changes
|
|
253
|
+
template<typename MODULE>
|
|
254
|
+
static void ConnectionChange(const MODULE& module_, const JsonData::WifiControl::ConnectionChangeParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
255
|
+
{
|
|
256
|
+
module_.Notify(_T("connectionchange"), params, sendIfMethod_);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
// Event: 'connectionchange' - Notifies that wifi connection changes
|
|
260
|
+
template<typename MODULE>
|
|
261
|
+
static void ConnectionChange(const MODULE& module_, const Core::JSON::String& ssid, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
262
|
+
{
|
|
263
|
+
JsonData::WifiControl::ConnectionChangeParamsData params_;
|
|
264
|
+
params_.Ssid = ssid;
|
|
265
|
+
|
|
266
|
+
ConnectionChange(module_, params_, sendIfMethod_);
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
// Event: 'connectionchange' - Notifies that wifi connection changes
|
|
270
|
+
template<typename MODULE>
|
|
271
|
+
static void ConnectionChange(const MODULE& module_, const string& ssid, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
272
|
+
{
|
|
273
|
+
JsonData::WifiControl::ConnectionChangeParamsData params_;
|
|
274
|
+
params_.Ssid = ssid;
|
|
275
|
+
|
|
276
|
+
ConnectionChange(module_, params_, sendIfMethod_);
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
} // namespace Event
|
|
280
|
+
|
|
281
|
+
POP_WARNING()
|
|
282
|
+
POP_WARNING()
|
|
283
|
+
POP_WARNING()
|
|
284
|
+
|
|
285
|
+
} // namespace JWifiControl
|
|
286
|
+
|
|
287
|
+
} // namespace Exchange
|
|
288
|
+
|
|
289
|
+
} // namespace Thunder
|
|
290
|
+
|
|
@@ -0,0 +1,207 @@
|
|
|
1
|
+
// Generated automatically from 'IZigWave.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ZigWave.h"
|
|
6
|
+
#include <interfaces/IZigWave.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace Exchange {
|
|
11
|
+
|
|
12
|
+
namespace JZigWave {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IZigWave* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JZigWave"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'bind' - Bind the *out* from the soure to the *in* of the destination
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ZigWave::BindParamsInfo, void>(_T("bind"),
|
|
37
|
+
[_implementation__](const JsonData::ZigWave::BindParamsInfo& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("bind")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint32_t _source_{params.Source};
|
|
46
|
+
const uint32_t _destination_{params.Destination};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->Bind(_source_, _destination_);
|
|
49
|
+
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
return (_errorCode__);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
// Method: 'unbind' - Unbind the *out* from the soure to the *in* of the destination
|
|
56
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ZigWave::BindParamsInfo, void>(_T("unbind"),
|
|
57
|
+
[_implementation__](const JsonData::ZigWave::BindParamsInfo& params) -> uint32_t {
|
|
58
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
59
|
+
|
|
60
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
61
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("unbind")));
|
|
62
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
63
|
+
}
|
|
64
|
+
else {
|
|
65
|
+
const uint32_t _source_{params.Source};
|
|
66
|
+
const uint32_t _destination_{params.Destination};
|
|
67
|
+
|
|
68
|
+
_errorCode__ = _implementation__->Unbind(_source_, _destination_);
|
|
69
|
+
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
return (_errorCode__);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
// Method: 'metadata' - Return the Metadata associated with the controller for this instance
|
|
76
|
+
_module__.PluginHost::JSONRPC::template Register<void, JsonData::ZigWave::ControllerData>(_T("metadata"),
|
|
77
|
+
[_implementation__](JsonData::ZigWave::ControllerData& metadata) -> uint32_t {
|
|
78
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
79
|
+
|
|
80
|
+
Exchange::IZigWave::Controller _metadata_{};
|
|
81
|
+
|
|
82
|
+
_errorCode__ = _implementation__->Metadata(_metadata_);
|
|
83
|
+
|
|
84
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
85
|
+
metadata.Set(true);
|
|
86
|
+
metadata = _metadata_;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
return (_errorCode__);
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
// Indexed Property: 'permutable' - To allow new devices to the network, the controller should be placed into an accepting mode
|
|
93
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ZigWave::PermutableData, Core::JSON::Boolean, std::function<uint32_t(const string&, const JsonData::ZigWave::PermutableData&, Core::JSON::Boolean&)>>(_T("permutable"),
|
|
94
|
+
[_implementation__](const string& address, const JsonData::ZigWave::PermutableData& params, Core::JSON::Boolean& result) -> uint32_t {
|
|
95
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
96
|
+
|
|
97
|
+
uint32_t _addressConv__{};
|
|
98
|
+
|
|
99
|
+
if (address.empty() == true) {
|
|
100
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("permutable")));
|
|
101
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
102
|
+
}
|
|
103
|
+
else {
|
|
104
|
+
const bool _addressConvResult__ = Core::FromString(address, _addressConv__);
|
|
105
|
+
|
|
106
|
+
if (_addressConvResult__ == false) {
|
|
107
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("permutable")));
|
|
108
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
113
|
+
|
|
114
|
+
if (params.IsSet() == false) {
|
|
115
|
+
bool _result_{};
|
|
116
|
+
|
|
117
|
+
_errorCode__ = (static_cast<const IZigWave*>(_implementation__))->Permutable(_addressConv__, _result_);
|
|
118
|
+
|
|
119
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
120
|
+
result = _result_;
|
|
121
|
+
}
|
|
122
|
+
}
|
|
123
|
+
else {
|
|
124
|
+
|
|
125
|
+
if (params.IsDataValid() == false) {
|
|
126
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("permutable")));
|
|
127
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
128
|
+
}
|
|
129
|
+
else {
|
|
130
|
+
const bool _value_{params.Value};
|
|
131
|
+
|
|
132
|
+
_errorCode__ = _implementation__->Permutable(_addressConv__, _value_);
|
|
133
|
+
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
result.Null(true);
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
return (_errorCode__);
|
|
141
|
+
});
|
|
142
|
+
|
|
143
|
+
_module__.PluginHost::JSONRPC::Register(_T("accept"), _T("permutable"));
|
|
144
|
+
|
|
145
|
+
// Indexed Property: 'devices' - Get the information of available devices (r/o)
|
|
146
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::ZigWave::DeviceData>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::ZigWave::DeviceData>&)>>(_T("devices"),
|
|
147
|
+
[_implementation__](const string& id, Core::JSON::ArrayType<JsonData::ZigWave::DeviceData>& result) -> uint32_t {
|
|
148
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
149
|
+
|
|
150
|
+
uint32_t _idConv__{};
|
|
151
|
+
|
|
152
|
+
if (id.empty() == true) {
|
|
153
|
+
TRACE_GLOBAL(Trace::Error, (_T("Missing index for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("devices")));
|
|
154
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
155
|
+
}
|
|
156
|
+
else {
|
|
157
|
+
const bool _idConvResult__ = Core::FromString(id, _idConv__);
|
|
158
|
+
|
|
159
|
+
if (_idConvResult__ == false) {
|
|
160
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid index for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("devices")));
|
|
161
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
166
|
+
RPC::IIteratorType<Exchange::IZigWave::Device, Exchange::ID_ZIGWAVE_DEVICE_ITERATOR>* _result_{};
|
|
167
|
+
|
|
168
|
+
_errorCode__ = _implementation__->Devices(_idConv__, _result_);
|
|
169
|
+
|
|
170
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
171
|
+
result.Set(true);
|
|
172
|
+
|
|
173
|
+
if (_result_ != nullptr) {
|
|
174
|
+
Exchange::IZigWave::Device _resultItem__{};
|
|
175
|
+
while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
|
|
176
|
+
_result_->Release();
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
return (_errorCode__);
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
template<typename MODULE>
|
|
187
|
+
static void Unregister(MODULE& _module__)
|
|
188
|
+
{
|
|
189
|
+
// Unregister methods and properties...
|
|
190
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("bind"));
|
|
191
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("unbind"));
|
|
192
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("metadata"));
|
|
193
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("permutable"));
|
|
194
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("accept"));
|
|
195
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("devices"));
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
POP_WARNING()
|
|
199
|
+
POP_WARNING()
|
|
200
|
+
POP_WARNING()
|
|
201
|
+
|
|
202
|
+
} // namespace JZigWave
|
|
203
|
+
|
|
204
|
+
} // namespace Exchange
|
|
205
|
+
|
|
206
|
+
} // namespace Thunder
|
|
207
|
+
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
// C++ types for AVSController API.
|
|
2
|
+
// Generated automatically from 'IAVSClient.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IAVSClient.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace AVSController {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace AVSController
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IAVSController::INotification::dialoguestate)
|
|
30
|
+
|
|
31
|
+
}
|
|
32
|
+
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
// C++ types for Application API.
|
|
2
|
+
// Generated automatically from 'IApplication.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IApplication.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Application {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace Application
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IApplication::resettype)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IApplication::launchpointtype)
|
|
31
|
+
|
|
32
|
+
}
|
|
33
|
+
|
|
@@ -0,0 +1,282 @@
|
|
|
1
|
+
// C++ types for AudioStream API.
|
|
2
|
+
// Generated automatically from 'IAudioStream.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IAudioStream.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace AudioStream {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AudioprofileInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AudioprofileInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AudioprofileInfo(const AudioprofileInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Codec(_other.Codec)
|
|
33
|
+
, CodecParams(_other.CodecParams)
|
|
34
|
+
, Channels(_other.Channels)
|
|
35
|
+
, Resolution(_other.Resolution)
|
|
36
|
+
, SampleRate(_other.SampleRate)
|
|
37
|
+
, BitRate(_other.BitRate)
|
|
38
|
+
{
|
|
39
|
+
_Init();
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
AudioprofileInfo(AudioprofileInfo&& _other) noexcept
|
|
43
|
+
: Core::JSON::Container()
|
|
44
|
+
, Codec(std::move(_other.Codec))
|
|
45
|
+
, CodecParams(std::move(_other.CodecParams))
|
|
46
|
+
, Channels(std::move(_other.Channels))
|
|
47
|
+
, Resolution(std::move(_other.Resolution))
|
|
48
|
+
, SampleRate(std::move(_other.SampleRate))
|
|
49
|
+
, BitRate(std::move(_other.BitRate))
|
|
50
|
+
{
|
|
51
|
+
_Init();
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
AudioprofileInfo(const Exchange::IAudioStream::audioprofile& _other)
|
|
55
|
+
: Core::JSON::Container()
|
|
56
|
+
{
|
|
57
|
+
Codec = _other.codec;
|
|
58
|
+
if (_other.codecParams.IsSet() == true) {
|
|
59
|
+
CodecParams = _other.codecParams.Value();
|
|
60
|
+
}
|
|
61
|
+
Channels = _other.channels;
|
|
62
|
+
Resolution = _other.resolution;
|
|
63
|
+
SampleRate = _other.sampleRate;
|
|
64
|
+
if (_other.bitRate.IsSet() == true) {
|
|
65
|
+
BitRate = _other.bitRate.Value();
|
|
66
|
+
}
|
|
67
|
+
_Init();
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
AudioprofileInfo& operator=(const AudioprofileInfo& _rhs)
|
|
71
|
+
{
|
|
72
|
+
Codec = _rhs.Codec;
|
|
73
|
+
if (_rhs.CodecParams.IsSet() == true) {
|
|
74
|
+
CodecParams = _rhs.CodecParams;
|
|
75
|
+
}
|
|
76
|
+
Channels = _rhs.Channels;
|
|
77
|
+
Resolution = _rhs.Resolution;
|
|
78
|
+
SampleRate = _rhs.SampleRate;
|
|
79
|
+
if (_rhs.BitRate.IsSet() == true) {
|
|
80
|
+
BitRate = _rhs.BitRate;
|
|
81
|
+
}
|
|
82
|
+
return (*this);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
AudioprofileInfo& operator=(AudioprofileInfo&& _rhs) noexcept
|
|
86
|
+
{
|
|
87
|
+
Codec = std::move(_rhs.Codec);
|
|
88
|
+
CodecParams = std::move(_rhs.CodecParams);
|
|
89
|
+
Channels = std::move(_rhs.Channels);
|
|
90
|
+
Resolution = std::move(_rhs.Resolution);
|
|
91
|
+
SampleRate = std::move(_rhs.SampleRate);
|
|
92
|
+
BitRate = std::move(_rhs.BitRate);
|
|
93
|
+
return (*this);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
AudioprofileInfo& operator=(const Exchange::IAudioStream::audioprofile& _rhs)
|
|
97
|
+
{
|
|
98
|
+
Codec = _rhs.codec;
|
|
99
|
+
if (_rhs.codecParams.IsSet() == true) {
|
|
100
|
+
CodecParams = _rhs.codecParams.Value();
|
|
101
|
+
}
|
|
102
|
+
Channels = _rhs.channels;
|
|
103
|
+
Resolution = _rhs.resolution;
|
|
104
|
+
SampleRate = _rhs.sampleRate;
|
|
105
|
+
if (_rhs.bitRate.IsSet() == true) {
|
|
106
|
+
BitRate = _rhs.bitRate.Value();
|
|
107
|
+
}
|
|
108
|
+
return (*this);
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
operator Exchange::IAudioStream::audioprofile() const
|
|
112
|
+
{
|
|
113
|
+
Exchange::IAudioStream::audioprofile _value{};
|
|
114
|
+
_value.codec = Codec;
|
|
115
|
+
if (CodecParams.IsSet() == true) {
|
|
116
|
+
_value.codecParams = CodecParams;
|
|
117
|
+
}
|
|
118
|
+
_value.channels = Channels;
|
|
119
|
+
_value.resolution = Resolution;
|
|
120
|
+
_value.sampleRate = SampleRate;
|
|
121
|
+
if (BitRate.IsSet() == true) {
|
|
122
|
+
_value.bitRate = BitRate;
|
|
123
|
+
}
|
|
124
|
+
return (_value);
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
~AudioprofileInfo() = default;
|
|
128
|
+
|
|
129
|
+
public:
|
|
130
|
+
bool IsDataValid() const
|
|
131
|
+
{
|
|
132
|
+
return ((Codec.IsSet() == true) && (Channels.IsSet() == true) && (Resolution.IsSet() == true) && (SampleRate.IsSet() == true));
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
private:
|
|
136
|
+
void _Init()
|
|
137
|
+
{
|
|
138
|
+
Add(_T("codec"), &Codec);
|
|
139
|
+
Add(_T("codecparams"), &CodecParams);
|
|
140
|
+
CodecParams.SetQuoted(false);
|
|
141
|
+
Add(_T("channels"), &Channels);
|
|
142
|
+
Add(_T("resolution"), &Resolution);
|
|
143
|
+
Add(_T("samplerate"), &SampleRate);
|
|
144
|
+
Add(_T("bitrate"), &BitRate);
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
public:
|
|
148
|
+
Core::JSON::EnumType<Exchange::IAudioStream::codectype> Codec; // Compression method (PCM: uncompressed)
|
|
149
|
+
Core::JSON::String CodecParams; // Additional parameters for codec
|
|
150
|
+
Core::JSON::DecUInt8 Channels; // Number of audio channels
|
|
151
|
+
Core::JSON::DecUInt8 Resolution; // Sample resultion in bits
|
|
152
|
+
Core::JSON::DecUInt32 SampleRate; // Sample rate in hertz
|
|
153
|
+
Core::JSON::DecUInt32 BitRate; // Data rate of the compressed stream in bits per second
|
|
154
|
+
}; // class AudioprofileInfo
|
|
155
|
+
|
|
156
|
+
// Method params/result classes
|
|
157
|
+
//
|
|
158
|
+
|
|
159
|
+
class DataParamsData : public Core::JSON::Container {
|
|
160
|
+
public:
|
|
161
|
+
DataParamsData()
|
|
162
|
+
: Core::JSON::Container()
|
|
163
|
+
{
|
|
164
|
+
Add(_T("seq"), &Seq);
|
|
165
|
+
Add(_T("timestamp"), &Timestamp);
|
|
166
|
+
Add(_T("length"), &Length);
|
|
167
|
+
Add(_T("data"), &Data);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
DataParamsData(const DataParamsData&) = delete;
|
|
171
|
+
DataParamsData(DataParamsData&&) noexcept = delete;
|
|
172
|
+
|
|
173
|
+
DataParamsData& operator=(const DataParamsData&) = delete;
|
|
174
|
+
DataParamsData& operator=(DataParamsData&&) noexcept = delete;
|
|
175
|
+
|
|
176
|
+
~DataParamsData() = default;
|
|
177
|
+
|
|
178
|
+
public:
|
|
179
|
+
bool IsDataValid() const
|
|
180
|
+
{
|
|
181
|
+
return ((Length.IsSet() == true) && (Data.IsSet() == true));
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
public:
|
|
185
|
+
Core::JSON::DecUInt16 Seq; // Frame number in current transmission
|
|
186
|
+
Core::JSON::DecUInt32 Timestamp; // Timestamp of the frame
|
|
187
|
+
Core::JSON::DecUInt16 Length; // Size of the raw data frame in bytes
|
|
188
|
+
Core::JSON::String Data; // Raw audio data, the format of the data is specified in the most recent *audiotransmission* notification
|
|
189
|
+
}; // class DataParamsData
|
|
190
|
+
|
|
191
|
+
class ProfileData : public Core::JSON::Container {
|
|
192
|
+
public:
|
|
193
|
+
ProfileData()
|
|
194
|
+
: Core::JSON::Container()
|
|
195
|
+
{
|
|
196
|
+
Add(_T("value"), &Value);
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
ProfileData(const ProfileData&) = delete;
|
|
200
|
+
ProfileData(ProfileData&&) noexcept = delete;
|
|
201
|
+
|
|
202
|
+
ProfileData& operator=(const ProfileData&) = delete;
|
|
203
|
+
ProfileData& operator=(ProfileData&&) noexcept = delete;
|
|
204
|
+
|
|
205
|
+
~ProfileData() = default;
|
|
206
|
+
|
|
207
|
+
public:
|
|
208
|
+
bool IsDataValid() const
|
|
209
|
+
{
|
|
210
|
+
return ((Value.IsSet() == true) && (Value.IsDataValid() == true));
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
public:
|
|
214
|
+
AudioprofileInfo Value; // Preferred profile of the stream
|
|
215
|
+
}; // class ProfileData
|
|
216
|
+
|
|
217
|
+
class SpeedData : public Core::JSON::Container {
|
|
218
|
+
public:
|
|
219
|
+
SpeedData()
|
|
220
|
+
: Core::JSON::Container()
|
|
221
|
+
{
|
|
222
|
+
Add(_T("value"), &Value);
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
SpeedData(const SpeedData&) = delete;
|
|
226
|
+
SpeedData(SpeedData&&) noexcept = delete;
|
|
227
|
+
|
|
228
|
+
SpeedData& operator=(const SpeedData&) = delete;
|
|
229
|
+
SpeedData& operator=(SpeedData&&) noexcept = delete;
|
|
230
|
+
|
|
231
|
+
~SpeedData() = default;
|
|
232
|
+
|
|
233
|
+
public:
|
|
234
|
+
bool IsDataValid() const
|
|
235
|
+
{
|
|
236
|
+
return (Value.IsSet() == true);
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
public:
|
|
240
|
+
Core::JSON::DecUInt8 Value; // Stream speed
|
|
241
|
+
}; // class SpeedData
|
|
242
|
+
|
|
243
|
+
class StateChangedParamsData : public Core::JSON::Container {
|
|
244
|
+
public:
|
|
245
|
+
StateChangedParamsData()
|
|
246
|
+
: Core::JSON::Container()
|
|
247
|
+
{
|
|
248
|
+
Add(_T("state"), &State);
|
|
249
|
+
Add(_T("profile"), &Profile);
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
StateChangedParamsData(const StateChangedParamsData&) = delete;
|
|
253
|
+
StateChangedParamsData(StateChangedParamsData&&) noexcept = delete;
|
|
254
|
+
|
|
255
|
+
StateChangedParamsData& operator=(const StateChangedParamsData&) = delete;
|
|
256
|
+
StateChangedParamsData& operator=(StateChangedParamsData&&) noexcept = delete;
|
|
257
|
+
|
|
258
|
+
~StateChangedParamsData() = default;
|
|
259
|
+
|
|
260
|
+
public:
|
|
261
|
+
bool IsDataValid() const
|
|
262
|
+
{
|
|
263
|
+
return ((State.IsSet() == true) && ((Profile.IsSet() == false) || (Profile.IsDataValid() == true)));
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
public:
|
|
267
|
+
Core::JSON::EnumType<Exchange::IAudioStream::streamstate> State; // New state of the stream
|
|
268
|
+
AudioprofileInfo Profile; // Details on the format used in the stream
|
|
269
|
+
}; // class StateChangedParamsData
|
|
270
|
+
|
|
271
|
+
} // namespace AudioStream
|
|
272
|
+
|
|
273
|
+
POP_WARNING()
|
|
274
|
+
|
|
275
|
+
} // namespace JsonData
|
|
276
|
+
|
|
277
|
+
// Enum conversion handlers
|
|
278
|
+
ENUM_CONVERSION_HANDLER(Exchange::IAudioStream::streamstate)
|
|
279
|
+
ENUM_CONVERSION_HANDLER(Exchange::IAudioStream::codectype)
|
|
280
|
+
|
|
281
|
+
}
|
|
282
|
+
|
|
@@ -0,0 +1,401 @@
|
|
|
1
|
+
// C++ types for Sink API.
|
|
2
|
+
// Generated automatically from 'IBluetoothAudio.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BluetoothAudio {
|
|
18
|
+
|
|
19
|
+
namespace Sink {
|
|
20
|
+
|
|
21
|
+
// Method params/result classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class AssignParamsData : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
AssignParamsData()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
Add(_T("address"), &Address);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
AssignParamsData(const AssignParamsData&) = delete;
|
|
33
|
+
AssignParamsData(AssignParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
AssignParamsData& operator=(const AssignParamsData&) = delete;
|
|
36
|
+
AssignParamsData& operator=(AssignParamsData&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~AssignParamsData() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return (Address.IsSet() == true);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::String Address; // Address of the bluetooth device to assign
|
|
48
|
+
}; // class AssignParamsData
|
|
49
|
+
|
|
50
|
+
class CodecPropertiesData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
CodecPropertiesData()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
_Init();
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
CodecPropertiesData(const CodecPropertiesData& _other)
|
|
59
|
+
: Core::JSON::Container()
|
|
60
|
+
, Codec(_other.Codec)
|
|
61
|
+
, Settings(_other.Settings)
|
|
62
|
+
{
|
|
63
|
+
_Init();
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
CodecPropertiesData(CodecPropertiesData&& _other) noexcept
|
|
67
|
+
: Core::JSON::Container()
|
|
68
|
+
, Codec(std::move(_other.Codec))
|
|
69
|
+
, Settings(std::move(_other.Settings))
|
|
70
|
+
{
|
|
71
|
+
_Init();
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
CodecPropertiesData(const Exchange::IBluetoothAudio::CodecProperties& _other)
|
|
75
|
+
: Core::JSON::Container()
|
|
76
|
+
{
|
|
77
|
+
Codec = _other.Codec;
|
|
78
|
+
if (_other.Settings.empty() == false) {
|
|
79
|
+
Settings = _other.Settings;
|
|
80
|
+
}
|
|
81
|
+
_Init();
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
CodecPropertiesData& operator=(const CodecPropertiesData& _rhs)
|
|
85
|
+
{
|
|
86
|
+
Codec = _rhs.Codec;
|
|
87
|
+
if (_rhs.Settings.Value().empty() == false) {
|
|
88
|
+
Settings = _rhs.Settings;
|
|
89
|
+
}
|
|
90
|
+
return (*this);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
CodecPropertiesData& operator=(CodecPropertiesData&& _rhs) noexcept
|
|
94
|
+
{
|
|
95
|
+
Codec = std::move(_rhs.Codec);
|
|
96
|
+
Settings = std::move(_rhs.Settings);
|
|
97
|
+
return (*this);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
CodecPropertiesData& operator=(const Exchange::IBluetoothAudio::CodecProperties& _rhs)
|
|
101
|
+
{
|
|
102
|
+
Codec = _rhs.Codec;
|
|
103
|
+
if (_rhs.Settings.empty() == false) {
|
|
104
|
+
Settings = _rhs.Settings;
|
|
105
|
+
}
|
|
106
|
+
return (*this);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
operator Exchange::IBluetoothAudio::CodecProperties() const
|
|
110
|
+
{
|
|
111
|
+
Exchange::IBluetoothAudio::CodecProperties _value{};
|
|
112
|
+
_value.Codec = Codec;
|
|
113
|
+
_value.Settings = Settings;
|
|
114
|
+
return (_value);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
~CodecPropertiesData() = default;
|
|
118
|
+
|
|
119
|
+
public:
|
|
120
|
+
bool IsDataValid() const
|
|
121
|
+
{
|
|
122
|
+
return (Codec.IsSet() == true);
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
private:
|
|
126
|
+
void _Init()
|
|
127
|
+
{
|
|
128
|
+
Add(_T("codec"), &Codec);
|
|
129
|
+
Add(_T("settings"), &Settings);
|
|
130
|
+
Settings.SetQuoted(false);
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
public:
|
|
134
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::audiocodec> Codec; // Audio codec used
|
|
135
|
+
Core::JSON::String Settings; // Codec-specific audio quality preset, compression profile, etc
|
|
136
|
+
}; // class CodecPropertiesData
|
|
137
|
+
|
|
138
|
+
class DRMPropertiesData : public Core::JSON::Container {
|
|
139
|
+
public:
|
|
140
|
+
DRMPropertiesData()
|
|
141
|
+
: Core::JSON::Container()
|
|
142
|
+
{
|
|
143
|
+
_Init();
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
DRMPropertiesData(const DRMPropertiesData& _other)
|
|
147
|
+
: Core::JSON::Container()
|
|
148
|
+
, DRM(_other.DRM)
|
|
149
|
+
, Settings(_other.Settings)
|
|
150
|
+
{
|
|
151
|
+
_Init();
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
DRMPropertiesData(DRMPropertiesData&& _other) noexcept
|
|
155
|
+
: Core::JSON::Container()
|
|
156
|
+
, DRM(std::move(_other.DRM))
|
|
157
|
+
, Settings(std::move(_other.Settings))
|
|
158
|
+
{
|
|
159
|
+
_Init();
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
DRMPropertiesData(const Exchange::IBluetoothAudio::DRMProperties& _other)
|
|
163
|
+
: Core::JSON::Container()
|
|
164
|
+
{
|
|
165
|
+
DRM = _other.DRM;
|
|
166
|
+
if (_other.Settings.empty() == false) {
|
|
167
|
+
Settings = _other.Settings;
|
|
168
|
+
}
|
|
169
|
+
_Init();
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
DRMPropertiesData& operator=(const DRMPropertiesData& _rhs)
|
|
173
|
+
{
|
|
174
|
+
DRM = _rhs.DRM;
|
|
175
|
+
if (_rhs.Settings.Value().empty() == false) {
|
|
176
|
+
Settings = _rhs.Settings;
|
|
177
|
+
}
|
|
178
|
+
return (*this);
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
DRMPropertiesData& operator=(DRMPropertiesData&& _rhs) noexcept
|
|
182
|
+
{
|
|
183
|
+
DRM = std::move(_rhs.DRM);
|
|
184
|
+
Settings = std::move(_rhs.Settings);
|
|
185
|
+
return (*this);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
DRMPropertiesData& operator=(const Exchange::IBluetoothAudio::DRMProperties& _rhs)
|
|
189
|
+
{
|
|
190
|
+
DRM = _rhs.DRM;
|
|
191
|
+
if (_rhs.Settings.empty() == false) {
|
|
192
|
+
Settings = _rhs.Settings;
|
|
193
|
+
}
|
|
194
|
+
return (*this);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
operator Exchange::IBluetoothAudio::DRMProperties() const
|
|
198
|
+
{
|
|
199
|
+
Exchange::IBluetoothAudio::DRMProperties _value{};
|
|
200
|
+
_value.DRM = DRM;
|
|
201
|
+
_value.Settings = Settings;
|
|
202
|
+
return (_value);
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
~DRMPropertiesData() = default;
|
|
206
|
+
|
|
207
|
+
public:
|
|
208
|
+
bool IsDataValid() const
|
|
209
|
+
{
|
|
210
|
+
return (DRM.IsSet() == true);
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
private:
|
|
214
|
+
void _Init()
|
|
215
|
+
{
|
|
216
|
+
Add(_T("drm"), &DRM);
|
|
217
|
+
Add(_T("settings"), &Settings);
|
|
218
|
+
Settings.SetQuoted(false);
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
public:
|
|
222
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::drmscheme> DRM; // Content protection scheme used
|
|
223
|
+
Core::JSON::String Settings; // DRM-specific content protection level, encoding rules, etc
|
|
224
|
+
}; // class DRMPropertiesData
|
|
225
|
+
|
|
226
|
+
class LatencyData : public Core::JSON::Container {
|
|
227
|
+
public:
|
|
228
|
+
LatencyData()
|
|
229
|
+
: Core::JSON::Container()
|
|
230
|
+
{
|
|
231
|
+
Add(_T("value"), &Value);
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
LatencyData(const LatencyData&) = delete;
|
|
235
|
+
LatencyData(LatencyData&&) noexcept = delete;
|
|
236
|
+
|
|
237
|
+
LatencyData& operator=(const LatencyData&) = delete;
|
|
238
|
+
LatencyData& operator=(LatencyData&&) noexcept = delete;
|
|
239
|
+
|
|
240
|
+
~LatencyData() = default;
|
|
241
|
+
|
|
242
|
+
public:
|
|
243
|
+
bool IsDataValid() const
|
|
244
|
+
{
|
|
245
|
+
return (Value.IsSet() == true);
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
public:
|
|
249
|
+
Core::JSON::DecSInt16 Value; // Audio latency in milliseconds
|
|
250
|
+
}; // class LatencyData
|
|
251
|
+
|
|
252
|
+
class StateChangedParamsData : public Core::JSON::Container {
|
|
253
|
+
public:
|
|
254
|
+
StateChangedParamsData()
|
|
255
|
+
: Core::JSON::Container()
|
|
256
|
+
{
|
|
257
|
+
Add(_T("state"), &State);
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
StateChangedParamsData(const StateChangedParamsData&) = delete;
|
|
261
|
+
StateChangedParamsData(StateChangedParamsData&&) noexcept = delete;
|
|
262
|
+
|
|
263
|
+
StateChangedParamsData& operator=(const StateChangedParamsData&) = delete;
|
|
264
|
+
StateChangedParamsData& operator=(StateChangedParamsData&&) noexcept = delete;
|
|
265
|
+
|
|
266
|
+
~StateChangedParamsData() = default;
|
|
267
|
+
|
|
268
|
+
public:
|
|
269
|
+
bool IsDataValid() const
|
|
270
|
+
{
|
|
271
|
+
return (State.IsSet() == true);
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
public:
|
|
275
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::state> State; // Changed BluetoothAudio State
|
|
276
|
+
}; // class StateChangedParamsData
|
|
277
|
+
|
|
278
|
+
class StreamPropertiesData : public Core::JSON::Container {
|
|
279
|
+
public:
|
|
280
|
+
StreamPropertiesData()
|
|
281
|
+
: Core::JSON::Container()
|
|
282
|
+
{
|
|
283
|
+
_Init();
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
StreamPropertiesData(const StreamPropertiesData& _other)
|
|
287
|
+
: Core::JSON::Container()
|
|
288
|
+
, SampleRate(_other.SampleRate)
|
|
289
|
+
, BitRate(_other.BitRate)
|
|
290
|
+
, Channels(_other.Channels)
|
|
291
|
+
, Resolution(_other.Resolution)
|
|
292
|
+
, IsResampled(_other.IsResampled)
|
|
293
|
+
{
|
|
294
|
+
_Init();
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
StreamPropertiesData(StreamPropertiesData&& _other) noexcept
|
|
298
|
+
: Core::JSON::Container()
|
|
299
|
+
, SampleRate(std::move(_other.SampleRate))
|
|
300
|
+
, BitRate(std::move(_other.BitRate))
|
|
301
|
+
, Channels(std::move(_other.Channels))
|
|
302
|
+
, Resolution(std::move(_other.Resolution))
|
|
303
|
+
, IsResampled(std::move(_other.IsResampled))
|
|
304
|
+
{
|
|
305
|
+
_Init();
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
StreamPropertiesData(const Exchange::IBluetoothAudio::StreamProperties& _other)
|
|
309
|
+
: Core::JSON::Container()
|
|
310
|
+
{
|
|
311
|
+
SampleRate = _other.SampleRate;
|
|
312
|
+
BitRate = _other.BitRate;
|
|
313
|
+
Channels = _other.Channels;
|
|
314
|
+
Resolution = _other.Resolution;
|
|
315
|
+
IsResampled = _other.IsResampled;
|
|
316
|
+
_Init();
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
StreamPropertiesData& operator=(const StreamPropertiesData& _rhs)
|
|
320
|
+
{
|
|
321
|
+
SampleRate = _rhs.SampleRate;
|
|
322
|
+
BitRate = _rhs.BitRate;
|
|
323
|
+
Channels = _rhs.Channels;
|
|
324
|
+
Resolution = _rhs.Resolution;
|
|
325
|
+
IsResampled = _rhs.IsResampled;
|
|
326
|
+
return (*this);
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
StreamPropertiesData& operator=(StreamPropertiesData&& _rhs) noexcept
|
|
330
|
+
{
|
|
331
|
+
SampleRate = std::move(_rhs.SampleRate);
|
|
332
|
+
BitRate = std::move(_rhs.BitRate);
|
|
333
|
+
Channels = std::move(_rhs.Channels);
|
|
334
|
+
Resolution = std::move(_rhs.Resolution);
|
|
335
|
+
IsResampled = std::move(_rhs.IsResampled);
|
|
336
|
+
return (*this);
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
StreamPropertiesData& operator=(const Exchange::IBluetoothAudio::StreamProperties& _rhs)
|
|
340
|
+
{
|
|
341
|
+
SampleRate = _rhs.SampleRate;
|
|
342
|
+
BitRate = _rhs.BitRate;
|
|
343
|
+
Channels = _rhs.Channels;
|
|
344
|
+
Resolution = _rhs.Resolution;
|
|
345
|
+
IsResampled = _rhs.IsResampled;
|
|
346
|
+
return (*this);
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
operator Exchange::IBluetoothAudio::StreamProperties() const
|
|
350
|
+
{
|
|
351
|
+
Exchange::IBluetoothAudio::StreamProperties _value{};
|
|
352
|
+
_value.SampleRate = SampleRate;
|
|
353
|
+
_value.BitRate = BitRate;
|
|
354
|
+
_value.Channels = Channels;
|
|
355
|
+
_value.Resolution = Resolution;
|
|
356
|
+
_value.IsResampled = IsResampled;
|
|
357
|
+
return (_value);
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
~StreamPropertiesData() = default;
|
|
361
|
+
|
|
362
|
+
public:
|
|
363
|
+
bool IsDataValid() const
|
|
364
|
+
{
|
|
365
|
+
return ((SampleRate.IsSet() == true) && (BitRate.IsSet() == true) && (Channels.IsSet() == true) && (Resolution.IsSet() == true) && (IsResampled.IsSet() == true));
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
private:
|
|
369
|
+
void _Init()
|
|
370
|
+
{
|
|
371
|
+
Add(_T("samplerate"), &SampleRate);
|
|
372
|
+
Add(_T("bitrate"), &BitRate);
|
|
373
|
+
Add(_T("channels"), &Channels);
|
|
374
|
+
Add(_T("resolution"), &Resolution);
|
|
375
|
+
Add(_T("isresampled"), &IsResampled);
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
public:
|
|
379
|
+
Core::JSON::DecUInt32 SampleRate; // Sample rate in Hz
|
|
380
|
+
Core::JSON::DecUInt32 BitRate; // Target bitrate in bits per second (eg. 320000)
|
|
381
|
+
Core::JSON::DecUInt8 Channels; // Number of audio channels
|
|
382
|
+
Core::JSON::DecUInt8 Resolution; // Sampling resolution in bits per sample
|
|
383
|
+
Core::JSON::Boolean IsResampled; // Indicates if the source stream is being resampled by the stack to match sink capabilities
|
|
384
|
+
}; // class StreamPropertiesData
|
|
385
|
+
|
|
386
|
+
} // namespace Sink
|
|
387
|
+
|
|
388
|
+
} // namespace BluetoothAudio
|
|
389
|
+
|
|
390
|
+
POP_WARNING()
|
|
391
|
+
|
|
392
|
+
} // namespace JsonData
|
|
393
|
+
|
|
394
|
+
// Enum conversion handlers
|
|
395
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::state)
|
|
396
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::ISink::devicetype)
|
|
397
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::audiocodec)
|
|
398
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::drmscheme)
|
|
399
|
+
|
|
400
|
+
}
|
|
401
|
+
|
|
@@ -0,0 +1,350 @@
|
|
|
1
|
+
// C++ types for Source API.
|
|
2
|
+
// Generated automatically from 'IBluetoothAudio.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BluetoothAudio {
|
|
18
|
+
|
|
19
|
+
namespace Source {
|
|
20
|
+
|
|
21
|
+
// Method params/result classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class CodecPropertiesData : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
CodecPropertiesData()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
_Init();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
CodecPropertiesData(const CodecPropertiesData& _other)
|
|
33
|
+
: Core::JSON::Container()
|
|
34
|
+
, Codec(_other.Codec)
|
|
35
|
+
, Settings(_other.Settings)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
CodecPropertiesData(CodecPropertiesData&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, Codec(std::move(_other.Codec))
|
|
43
|
+
, Settings(std::move(_other.Settings))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
CodecPropertiesData(const Exchange::IBluetoothAudio::CodecProperties& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
Codec = _other.Codec;
|
|
52
|
+
if (_other.Settings.empty() == false) {
|
|
53
|
+
Settings = _other.Settings;
|
|
54
|
+
}
|
|
55
|
+
_Init();
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
CodecPropertiesData& operator=(const CodecPropertiesData& _rhs)
|
|
59
|
+
{
|
|
60
|
+
Codec = _rhs.Codec;
|
|
61
|
+
if (_rhs.Settings.Value().empty() == false) {
|
|
62
|
+
Settings = _rhs.Settings;
|
|
63
|
+
}
|
|
64
|
+
return (*this);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
CodecPropertiesData& operator=(CodecPropertiesData&& _rhs) noexcept
|
|
68
|
+
{
|
|
69
|
+
Codec = std::move(_rhs.Codec);
|
|
70
|
+
Settings = std::move(_rhs.Settings);
|
|
71
|
+
return (*this);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
CodecPropertiesData& operator=(const Exchange::IBluetoothAudio::CodecProperties& _rhs)
|
|
75
|
+
{
|
|
76
|
+
Codec = _rhs.Codec;
|
|
77
|
+
if (_rhs.Settings.empty() == false) {
|
|
78
|
+
Settings = _rhs.Settings;
|
|
79
|
+
}
|
|
80
|
+
return (*this);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
operator Exchange::IBluetoothAudio::CodecProperties() const
|
|
84
|
+
{
|
|
85
|
+
Exchange::IBluetoothAudio::CodecProperties _value{};
|
|
86
|
+
_value.Codec = Codec;
|
|
87
|
+
_value.Settings = Settings;
|
|
88
|
+
return (_value);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
~CodecPropertiesData() = default;
|
|
92
|
+
|
|
93
|
+
public:
|
|
94
|
+
bool IsDataValid() const
|
|
95
|
+
{
|
|
96
|
+
return (Codec.IsSet() == true);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
private:
|
|
100
|
+
void _Init()
|
|
101
|
+
{
|
|
102
|
+
Add(_T("codec"), &Codec);
|
|
103
|
+
Add(_T("settings"), &Settings);
|
|
104
|
+
Settings.SetQuoted(false);
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
public:
|
|
108
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::audiocodec> Codec; // Audio codec used
|
|
109
|
+
Core::JSON::String Settings; // Codec-specific audio quality preset, compression profile, etc
|
|
110
|
+
}; // class CodecPropertiesData
|
|
111
|
+
|
|
112
|
+
class DRMPropertiesData : public Core::JSON::Container {
|
|
113
|
+
public:
|
|
114
|
+
DRMPropertiesData()
|
|
115
|
+
: Core::JSON::Container()
|
|
116
|
+
{
|
|
117
|
+
_Init();
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
DRMPropertiesData(const DRMPropertiesData& _other)
|
|
121
|
+
: Core::JSON::Container()
|
|
122
|
+
, DRM(_other.DRM)
|
|
123
|
+
, Settings(_other.Settings)
|
|
124
|
+
{
|
|
125
|
+
_Init();
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
DRMPropertiesData(DRMPropertiesData&& _other) noexcept
|
|
129
|
+
: Core::JSON::Container()
|
|
130
|
+
, DRM(std::move(_other.DRM))
|
|
131
|
+
, Settings(std::move(_other.Settings))
|
|
132
|
+
{
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
DRMPropertiesData(const Exchange::IBluetoothAudio::DRMProperties& _other)
|
|
137
|
+
: Core::JSON::Container()
|
|
138
|
+
{
|
|
139
|
+
DRM = _other.DRM;
|
|
140
|
+
if (_other.Settings.empty() == false) {
|
|
141
|
+
Settings = _other.Settings;
|
|
142
|
+
}
|
|
143
|
+
_Init();
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
DRMPropertiesData& operator=(const DRMPropertiesData& _rhs)
|
|
147
|
+
{
|
|
148
|
+
DRM = _rhs.DRM;
|
|
149
|
+
if (_rhs.Settings.Value().empty() == false) {
|
|
150
|
+
Settings = _rhs.Settings;
|
|
151
|
+
}
|
|
152
|
+
return (*this);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
DRMPropertiesData& operator=(DRMPropertiesData&& _rhs) noexcept
|
|
156
|
+
{
|
|
157
|
+
DRM = std::move(_rhs.DRM);
|
|
158
|
+
Settings = std::move(_rhs.Settings);
|
|
159
|
+
return (*this);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
DRMPropertiesData& operator=(const Exchange::IBluetoothAudio::DRMProperties& _rhs)
|
|
163
|
+
{
|
|
164
|
+
DRM = _rhs.DRM;
|
|
165
|
+
if (_rhs.Settings.empty() == false) {
|
|
166
|
+
Settings = _rhs.Settings;
|
|
167
|
+
}
|
|
168
|
+
return (*this);
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
operator Exchange::IBluetoothAudio::DRMProperties() const
|
|
172
|
+
{
|
|
173
|
+
Exchange::IBluetoothAudio::DRMProperties _value{};
|
|
174
|
+
_value.DRM = DRM;
|
|
175
|
+
_value.Settings = Settings;
|
|
176
|
+
return (_value);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
~DRMPropertiesData() = default;
|
|
180
|
+
|
|
181
|
+
public:
|
|
182
|
+
bool IsDataValid() const
|
|
183
|
+
{
|
|
184
|
+
return (DRM.IsSet() == true);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
private:
|
|
188
|
+
void _Init()
|
|
189
|
+
{
|
|
190
|
+
Add(_T("drm"), &DRM);
|
|
191
|
+
Add(_T("settings"), &Settings);
|
|
192
|
+
Settings.SetQuoted(false);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
public:
|
|
196
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::drmscheme> DRM; // Content protection scheme used
|
|
197
|
+
Core::JSON::String Settings; // DRM-specific content protection level, encoding rules, etc
|
|
198
|
+
}; // class DRMPropertiesData
|
|
199
|
+
|
|
200
|
+
class StateChangedParamsData : public Core::JSON::Container {
|
|
201
|
+
public:
|
|
202
|
+
StateChangedParamsData()
|
|
203
|
+
: Core::JSON::Container()
|
|
204
|
+
{
|
|
205
|
+
Add(_T("state"), &State);
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
StateChangedParamsData(const StateChangedParamsData&) = delete;
|
|
209
|
+
StateChangedParamsData(StateChangedParamsData&&) noexcept = delete;
|
|
210
|
+
|
|
211
|
+
StateChangedParamsData& operator=(const StateChangedParamsData&) = delete;
|
|
212
|
+
StateChangedParamsData& operator=(StateChangedParamsData&&) noexcept = delete;
|
|
213
|
+
|
|
214
|
+
~StateChangedParamsData() = default;
|
|
215
|
+
|
|
216
|
+
public:
|
|
217
|
+
bool IsDataValid() const
|
|
218
|
+
{
|
|
219
|
+
return (State.IsSet() == true);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
public:
|
|
223
|
+
Core::JSON::EnumType<Exchange::IBluetoothAudio::state> State; // Changed BluetoothAudio State
|
|
224
|
+
}; // class StateChangedParamsData
|
|
225
|
+
|
|
226
|
+
class StreamPropertiesData : public Core::JSON::Container {
|
|
227
|
+
public:
|
|
228
|
+
StreamPropertiesData()
|
|
229
|
+
: Core::JSON::Container()
|
|
230
|
+
{
|
|
231
|
+
_Init();
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
StreamPropertiesData(const StreamPropertiesData& _other)
|
|
235
|
+
: Core::JSON::Container()
|
|
236
|
+
, SampleRate(_other.SampleRate)
|
|
237
|
+
, BitRate(_other.BitRate)
|
|
238
|
+
, Channels(_other.Channels)
|
|
239
|
+
, Resolution(_other.Resolution)
|
|
240
|
+
, IsResampled(_other.IsResampled)
|
|
241
|
+
{
|
|
242
|
+
_Init();
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
StreamPropertiesData(StreamPropertiesData&& _other) noexcept
|
|
246
|
+
: Core::JSON::Container()
|
|
247
|
+
, SampleRate(std::move(_other.SampleRate))
|
|
248
|
+
, BitRate(std::move(_other.BitRate))
|
|
249
|
+
, Channels(std::move(_other.Channels))
|
|
250
|
+
, Resolution(std::move(_other.Resolution))
|
|
251
|
+
, IsResampled(std::move(_other.IsResampled))
|
|
252
|
+
{
|
|
253
|
+
_Init();
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
StreamPropertiesData(const Exchange::IBluetoothAudio::StreamProperties& _other)
|
|
257
|
+
: Core::JSON::Container()
|
|
258
|
+
{
|
|
259
|
+
SampleRate = _other.SampleRate;
|
|
260
|
+
BitRate = _other.BitRate;
|
|
261
|
+
Channels = _other.Channels;
|
|
262
|
+
Resolution = _other.Resolution;
|
|
263
|
+
IsResampled = _other.IsResampled;
|
|
264
|
+
_Init();
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
StreamPropertiesData& operator=(const StreamPropertiesData& _rhs)
|
|
268
|
+
{
|
|
269
|
+
SampleRate = _rhs.SampleRate;
|
|
270
|
+
BitRate = _rhs.BitRate;
|
|
271
|
+
Channels = _rhs.Channels;
|
|
272
|
+
Resolution = _rhs.Resolution;
|
|
273
|
+
IsResampled = _rhs.IsResampled;
|
|
274
|
+
return (*this);
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
StreamPropertiesData& operator=(StreamPropertiesData&& _rhs) noexcept
|
|
278
|
+
{
|
|
279
|
+
SampleRate = std::move(_rhs.SampleRate);
|
|
280
|
+
BitRate = std::move(_rhs.BitRate);
|
|
281
|
+
Channels = std::move(_rhs.Channels);
|
|
282
|
+
Resolution = std::move(_rhs.Resolution);
|
|
283
|
+
IsResampled = std::move(_rhs.IsResampled);
|
|
284
|
+
return (*this);
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
StreamPropertiesData& operator=(const Exchange::IBluetoothAudio::StreamProperties& _rhs)
|
|
288
|
+
{
|
|
289
|
+
SampleRate = _rhs.SampleRate;
|
|
290
|
+
BitRate = _rhs.BitRate;
|
|
291
|
+
Channels = _rhs.Channels;
|
|
292
|
+
Resolution = _rhs.Resolution;
|
|
293
|
+
IsResampled = _rhs.IsResampled;
|
|
294
|
+
return (*this);
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
operator Exchange::IBluetoothAudio::StreamProperties() const
|
|
298
|
+
{
|
|
299
|
+
Exchange::IBluetoothAudio::StreamProperties _value{};
|
|
300
|
+
_value.SampleRate = SampleRate;
|
|
301
|
+
_value.BitRate = BitRate;
|
|
302
|
+
_value.Channels = Channels;
|
|
303
|
+
_value.Resolution = Resolution;
|
|
304
|
+
_value.IsResampled = IsResampled;
|
|
305
|
+
return (_value);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
~StreamPropertiesData() = default;
|
|
309
|
+
|
|
310
|
+
public:
|
|
311
|
+
bool IsDataValid() const
|
|
312
|
+
{
|
|
313
|
+
return ((SampleRate.IsSet() == true) && (BitRate.IsSet() == true) && (Channels.IsSet() == true) && (Resolution.IsSet() == true) && (IsResampled.IsSet() == true));
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
private:
|
|
317
|
+
void _Init()
|
|
318
|
+
{
|
|
319
|
+
Add(_T("samplerate"), &SampleRate);
|
|
320
|
+
Add(_T("bitrate"), &BitRate);
|
|
321
|
+
Add(_T("channels"), &Channels);
|
|
322
|
+
Add(_T("resolution"), &Resolution);
|
|
323
|
+
Add(_T("isresampled"), &IsResampled);
|
|
324
|
+
}
|
|
325
|
+
|
|
326
|
+
public:
|
|
327
|
+
Core::JSON::DecUInt32 SampleRate; // Sample rate in Hz
|
|
328
|
+
Core::JSON::DecUInt32 BitRate; // Target bitrate in bits per second (eg. 320000)
|
|
329
|
+
Core::JSON::DecUInt8 Channels; // Number of audio channels
|
|
330
|
+
Core::JSON::DecUInt8 Resolution; // Sampling resolution in bits per sample
|
|
331
|
+
Core::JSON::Boolean IsResampled; // Indicates if the source stream is being resampled by the stack to match sink capabilities
|
|
332
|
+
}; // class StreamPropertiesData
|
|
333
|
+
|
|
334
|
+
} // namespace Source
|
|
335
|
+
|
|
336
|
+
} // namespace BluetoothAudio
|
|
337
|
+
|
|
338
|
+
POP_WARNING()
|
|
339
|
+
|
|
340
|
+
} // namespace JsonData
|
|
341
|
+
|
|
342
|
+
// Enum conversion handlers
|
|
343
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::state)
|
|
344
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::ISink::devicetype)
|
|
345
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::audiocodec)
|
|
346
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::drmscheme)
|
|
347
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBluetoothAudio::ISource::devicetype)
|
|
348
|
+
|
|
349
|
+
}
|
|
350
|
+
|
|
@@ -0,0 +1,884 @@
|
|
|
1
|
+
// C++ types for BluetoothControl API.
|
|
2
|
+
// Generated automatically from 'IBluetooth.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBluetooth.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BluetoothControl {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ConnectParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ConnectParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("address"), &Address);
|
|
28
|
+
Add(_T("type"), &Type);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
ConnectParamsInfo(const ConnectParamsInfo&) = delete;
|
|
32
|
+
ConnectParamsInfo(ConnectParamsInfo&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
ConnectParamsInfo& operator=(const ConnectParamsInfo&) = delete;
|
|
35
|
+
ConnectParamsInfo& operator=(ConnectParamsInfo&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~ConnectParamsInfo() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::String Address; // Connects to a Bluetooth device
|
|
47
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Connects to a Bluetooth device
|
|
48
|
+
}; // class ConnectParamsInfo
|
|
49
|
+
|
|
50
|
+
class ProvidePasskeyParamsInfo : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
ProvidePasskeyParamsInfo()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("address"), &Address);
|
|
56
|
+
Add(_T("type"), &Type);
|
|
57
|
+
Add(_T("secret"), &Secret);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
ProvidePasskeyParamsInfo(const ProvidePasskeyParamsInfo&) = delete;
|
|
61
|
+
ProvidePasskeyParamsInfo(ProvidePasskeyParamsInfo&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
ProvidePasskeyParamsInfo& operator=(const ProvidePasskeyParamsInfo&) = delete;
|
|
64
|
+
ProvidePasskeyParamsInfo& operator=(ProvidePasskeyParamsInfo&&) noexcept = delete;
|
|
65
|
+
|
|
66
|
+
~ProvidePasskeyParamsInfo() = default;
|
|
67
|
+
|
|
68
|
+
public:
|
|
69
|
+
bool IsDataValid() const
|
|
70
|
+
{
|
|
71
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && (((Secret.IsSet() == true) && (Secret.Value() <= 999999))));
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
public:
|
|
75
|
+
Core::JSON::String Address; // Provides a passkey for authentication during a pairing process
|
|
76
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Provides a passkey for authentication during a pairing process
|
|
77
|
+
Core::JSON::DecUInt32 Secret; // A decimal six-digit passkey value
|
|
78
|
+
}; // class ProvidePasskeyParamsInfo
|
|
79
|
+
|
|
80
|
+
class StopDiscoverableParamsInfo : public Core::JSON::Container {
|
|
81
|
+
public:
|
|
82
|
+
StopDiscoverableParamsInfo()
|
|
83
|
+
: Core::JSON::Container()
|
|
84
|
+
{
|
|
85
|
+
Add(_T("type"), &Type);
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
StopDiscoverableParamsInfo(const StopDiscoverableParamsInfo&) = delete;
|
|
89
|
+
StopDiscoverableParamsInfo(StopDiscoverableParamsInfo&&) noexcept = delete;
|
|
90
|
+
|
|
91
|
+
StopDiscoverableParamsInfo& operator=(const StopDiscoverableParamsInfo&) = delete;
|
|
92
|
+
StopDiscoverableParamsInfo& operator=(StopDiscoverableParamsInfo&&) noexcept = delete;
|
|
93
|
+
|
|
94
|
+
~StopDiscoverableParamsInfo() = default;
|
|
95
|
+
|
|
96
|
+
public:
|
|
97
|
+
bool IsDataValid() const
|
|
98
|
+
{
|
|
99
|
+
return (Type.IsSet() == true);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
public:
|
|
103
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype> Type; // Stops LE advertising or BR/EDR inquiry scanning operation
|
|
104
|
+
}; // class StopDiscoverableParamsInfo
|
|
105
|
+
|
|
106
|
+
// Method params/result classes
|
|
107
|
+
//
|
|
108
|
+
|
|
109
|
+
class AdapterinfoData : public Core::JSON::Container {
|
|
110
|
+
public:
|
|
111
|
+
AdapterinfoData()
|
|
112
|
+
: Core::JSON::Container()
|
|
113
|
+
{
|
|
114
|
+
_Init();
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
AdapterinfoData(const AdapterinfoData& _other)
|
|
118
|
+
: Core::JSON::Container()
|
|
119
|
+
, Id(_other.Id)
|
|
120
|
+
, Interface(_other.Interface)
|
|
121
|
+
, Address(_other.Address)
|
|
122
|
+
, Type(_other.Type)
|
|
123
|
+
, Version(_other.Version)
|
|
124
|
+
, Manufacturer(_other.Manufacturer)
|
|
125
|
+
, Cod(_other.Cod)
|
|
126
|
+
, Name(_other.Name)
|
|
127
|
+
, ShortName(_other.ShortName)
|
|
128
|
+
{
|
|
129
|
+
_Init();
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
AdapterinfoData(AdapterinfoData&& _other) noexcept
|
|
133
|
+
: Core::JSON::Container()
|
|
134
|
+
, Id(std::move(_other.Id))
|
|
135
|
+
, Interface(std::move(_other.Interface))
|
|
136
|
+
, Address(std::move(_other.Address))
|
|
137
|
+
, Type(std::move(_other.Type))
|
|
138
|
+
, Version(std::move(_other.Version))
|
|
139
|
+
, Manufacturer(std::move(_other.Manufacturer))
|
|
140
|
+
, Cod(std::move(_other.Cod))
|
|
141
|
+
, Name(std::move(_other.Name))
|
|
142
|
+
, ShortName(std::move(_other.ShortName))
|
|
143
|
+
{
|
|
144
|
+
_Init();
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
AdapterinfoData(const Exchange::JSONRPC::IBluetoothControl::adapterinfo& _other)
|
|
148
|
+
: Core::JSON::Container()
|
|
149
|
+
{
|
|
150
|
+
Id = _other.id;
|
|
151
|
+
Interface = _other.interface;
|
|
152
|
+
Address = _other.address;
|
|
153
|
+
Type = _other.type;
|
|
154
|
+
Version = _other.version;
|
|
155
|
+
if (_other.manufacturer.IsSet() == true) {
|
|
156
|
+
Manufacturer = _other.manufacturer.Value();
|
|
157
|
+
}
|
|
158
|
+
if (_other.cod.IsSet() == true) {
|
|
159
|
+
Cod = _other.cod.Value();
|
|
160
|
+
}
|
|
161
|
+
if (_other.name.IsSet() == true) {
|
|
162
|
+
Name = _other.name.Value();
|
|
163
|
+
}
|
|
164
|
+
if (_other.shortName.IsSet() == true) {
|
|
165
|
+
ShortName = _other.shortName.Value();
|
|
166
|
+
}
|
|
167
|
+
_Init();
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
AdapterinfoData& operator=(const AdapterinfoData& _rhs)
|
|
171
|
+
{
|
|
172
|
+
Id = _rhs.Id;
|
|
173
|
+
Interface = _rhs.Interface;
|
|
174
|
+
Address = _rhs.Address;
|
|
175
|
+
Type = _rhs.Type;
|
|
176
|
+
Version = _rhs.Version;
|
|
177
|
+
if (_rhs.Manufacturer.IsSet() == true) {
|
|
178
|
+
Manufacturer = _rhs.Manufacturer;
|
|
179
|
+
}
|
|
180
|
+
if (_rhs.Cod.IsSet() == true) {
|
|
181
|
+
Cod = _rhs.Cod;
|
|
182
|
+
}
|
|
183
|
+
if (_rhs.Name.IsSet() == true) {
|
|
184
|
+
Name = _rhs.Name;
|
|
185
|
+
}
|
|
186
|
+
if (_rhs.ShortName.IsSet() == true) {
|
|
187
|
+
ShortName = _rhs.ShortName;
|
|
188
|
+
}
|
|
189
|
+
return (*this);
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
AdapterinfoData& operator=(AdapterinfoData&& _rhs) noexcept
|
|
193
|
+
{
|
|
194
|
+
Id = std::move(_rhs.Id);
|
|
195
|
+
Interface = std::move(_rhs.Interface);
|
|
196
|
+
Address = std::move(_rhs.Address);
|
|
197
|
+
Type = std::move(_rhs.Type);
|
|
198
|
+
Version = std::move(_rhs.Version);
|
|
199
|
+
Manufacturer = std::move(_rhs.Manufacturer);
|
|
200
|
+
Cod = std::move(_rhs.Cod);
|
|
201
|
+
Name = std::move(_rhs.Name);
|
|
202
|
+
ShortName = std::move(_rhs.ShortName);
|
|
203
|
+
return (*this);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
AdapterinfoData& operator=(const Exchange::JSONRPC::IBluetoothControl::adapterinfo& _rhs)
|
|
207
|
+
{
|
|
208
|
+
Id = _rhs.id;
|
|
209
|
+
Interface = _rhs.interface;
|
|
210
|
+
Address = _rhs.address;
|
|
211
|
+
Type = _rhs.type;
|
|
212
|
+
Version = _rhs.version;
|
|
213
|
+
if (_rhs.manufacturer.IsSet() == true) {
|
|
214
|
+
Manufacturer = _rhs.manufacturer.Value();
|
|
215
|
+
}
|
|
216
|
+
if (_rhs.cod.IsSet() == true) {
|
|
217
|
+
Cod = _rhs.cod.Value();
|
|
218
|
+
}
|
|
219
|
+
if (_rhs.name.IsSet() == true) {
|
|
220
|
+
Name = _rhs.name.Value();
|
|
221
|
+
}
|
|
222
|
+
if (_rhs.shortName.IsSet() == true) {
|
|
223
|
+
ShortName = _rhs.shortName.Value();
|
|
224
|
+
}
|
|
225
|
+
return (*this);
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
operator Exchange::JSONRPC::IBluetoothControl::adapterinfo() const
|
|
229
|
+
{
|
|
230
|
+
Exchange::JSONRPC::IBluetoothControl::adapterinfo _value{};
|
|
231
|
+
_value.id = Id;
|
|
232
|
+
_value.interface = Interface;
|
|
233
|
+
_value.address = Address;
|
|
234
|
+
_value.type = Type;
|
|
235
|
+
_value.version = Version;
|
|
236
|
+
if (Manufacturer.IsSet() == true) {
|
|
237
|
+
_value.manufacturer = Manufacturer;
|
|
238
|
+
}
|
|
239
|
+
if (Cod.IsSet() == true) {
|
|
240
|
+
_value.cod = Cod;
|
|
241
|
+
}
|
|
242
|
+
if (Name.IsSet() == true) {
|
|
243
|
+
_value.name = Name;
|
|
244
|
+
}
|
|
245
|
+
if (ShortName.IsSet() == true) {
|
|
246
|
+
_value.shortName = ShortName;
|
|
247
|
+
}
|
|
248
|
+
return (_value);
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
~AdapterinfoData() = default;
|
|
252
|
+
|
|
253
|
+
public:
|
|
254
|
+
bool IsDataValid() const
|
|
255
|
+
{
|
|
256
|
+
return ((Id.IsSet() == true) && (Interface.IsSet() == true) && (Address.IsSet() == true) && (Type.IsSet() == true) && (Version.IsSet() == true) && ((Cod.IsSet() == false) || (Cod.Value() <= 16777215)));
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
private:
|
|
260
|
+
void _Init()
|
|
261
|
+
{
|
|
262
|
+
Add(_T("id"), &Id);
|
|
263
|
+
Add(_T("interface"), &Interface);
|
|
264
|
+
Add(_T("address"), &Address);
|
|
265
|
+
Add(_T("type"), &Type);
|
|
266
|
+
Add(_T("version"), &Version);
|
|
267
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
268
|
+
Add(_T("class"), &Cod);
|
|
269
|
+
Add(_T("name"), &Name);
|
|
270
|
+
Add(_T("shortname"), &ShortName);
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
public:
|
|
274
|
+
Core::JSON::DecUInt8 Id; // Adapter ID number
|
|
275
|
+
Core::JSON::String Interface; // Interface name
|
|
276
|
+
Core::JSON::String Address; // Bluetooth address
|
|
277
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::adaptertype> Type; // Adapter type
|
|
278
|
+
Core::JSON::DecUInt8 Version; // Version
|
|
279
|
+
Core::JSON::DecUInt16 Manufacturer; // Company Identification Code (CIC)
|
|
280
|
+
Core::JSON::DecUInt32 Cod; // Class of Device (CoD) value
|
|
281
|
+
Core::JSON::String Name; // Name
|
|
282
|
+
Core::JSON::String ShortName; // Shortened name
|
|
283
|
+
}; // class AdapterinfoData
|
|
284
|
+
|
|
285
|
+
class ConfirmPasskeyParamsData : public Core::JSON::Container {
|
|
286
|
+
public:
|
|
287
|
+
ConfirmPasskeyParamsData()
|
|
288
|
+
: Core::JSON::Container()
|
|
289
|
+
{
|
|
290
|
+
Add(_T("address"), &Address);
|
|
291
|
+
Add(_T("type"), &Type);
|
|
292
|
+
Add(_T("accept"), &Accept);
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
ConfirmPasskeyParamsData(const ConfirmPasskeyParamsData&) = delete;
|
|
296
|
+
ConfirmPasskeyParamsData(ConfirmPasskeyParamsData&&) noexcept = delete;
|
|
297
|
+
|
|
298
|
+
ConfirmPasskeyParamsData& operator=(const ConfirmPasskeyParamsData&) = delete;
|
|
299
|
+
ConfirmPasskeyParamsData& operator=(ConfirmPasskeyParamsData&&) noexcept = delete;
|
|
300
|
+
|
|
301
|
+
~ConfirmPasskeyParamsData() = default;
|
|
302
|
+
|
|
303
|
+
public:
|
|
304
|
+
bool IsDataValid() const
|
|
305
|
+
{
|
|
306
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && (Accept.IsSet() == true));
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
public:
|
|
310
|
+
Core::JSON::String Address; // Confirms a passkey for authentication during a BR/EDR SSP pairing processs
|
|
311
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Confirms a passkey for authentication during a BR/EDR SSP pairing processs
|
|
312
|
+
Core::JSON::Boolean Accept; // Confirm pairing (normally if the presented passkey is correct)
|
|
313
|
+
}; // class ConfirmPasskeyParamsData
|
|
314
|
+
|
|
315
|
+
class DeviceinfoData : public Core::JSON::Container {
|
|
316
|
+
public:
|
|
317
|
+
DeviceinfoData()
|
|
318
|
+
: Core::JSON::Container()
|
|
319
|
+
{
|
|
320
|
+
_Init();
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
DeviceinfoData(const DeviceinfoData& _other)
|
|
324
|
+
: Core::JSON::Container()
|
|
325
|
+
, Address(_other.Address)
|
|
326
|
+
, Type(_other.Type)
|
|
327
|
+
, Name(_other.Name)
|
|
328
|
+
, Cod(_other.Cod)
|
|
329
|
+
, Appearance(_other.Appearance)
|
|
330
|
+
, Services(_other.Services)
|
|
331
|
+
, Paired(_other.Paired)
|
|
332
|
+
, Connected(_other.Connected)
|
|
333
|
+
{
|
|
334
|
+
_Init();
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
DeviceinfoData(DeviceinfoData&& _other) noexcept
|
|
338
|
+
: Core::JSON::Container()
|
|
339
|
+
, Address(std::move(_other.Address))
|
|
340
|
+
, Type(std::move(_other.Type))
|
|
341
|
+
, Name(std::move(_other.Name))
|
|
342
|
+
, Cod(std::move(_other.Cod))
|
|
343
|
+
, Appearance(std::move(_other.Appearance))
|
|
344
|
+
, Services(std::move(_other.Services))
|
|
345
|
+
, Paired(std::move(_other.Paired))
|
|
346
|
+
, Connected(std::move(_other.Connected))
|
|
347
|
+
{
|
|
348
|
+
_Init();
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
DeviceinfoData(const Exchange::JSONRPC::IBluetoothControl::deviceinfo& _other)
|
|
352
|
+
: Core::JSON::Container()
|
|
353
|
+
{
|
|
354
|
+
Address = _other.address;
|
|
355
|
+
Type = _other.type;
|
|
356
|
+
if (_other.name.IsSet() == true) {
|
|
357
|
+
Name = _other.name.Value();
|
|
358
|
+
}
|
|
359
|
+
if (_other.cod.IsSet() == true) {
|
|
360
|
+
Cod = _other.cod.Value();
|
|
361
|
+
}
|
|
362
|
+
if (_other.appearance.IsSet() == true) {
|
|
363
|
+
Appearance = _other.appearance.Value();
|
|
364
|
+
}
|
|
365
|
+
if (_other.services.IsSet() == true) {
|
|
366
|
+
Services = _other.services.Value();
|
|
367
|
+
}
|
|
368
|
+
Paired = _other.paired;
|
|
369
|
+
Connected = _other.connected;
|
|
370
|
+
_Init();
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
DeviceinfoData& operator=(const DeviceinfoData& _rhs)
|
|
374
|
+
{
|
|
375
|
+
Address = _rhs.Address;
|
|
376
|
+
Type = _rhs.Type;
|
|
377
|
+
if (_rhs.Name.IsSet() == true) {
|
|
378
|
+
Name = _rhs.Name;
|
|
379
|
+
}
|
|
380
|
+
if (_rhs.Cod.IsSet() == true) {
|
|
381
|
+
Cod = _rhs.Cod;
|
|
382
|
+
}
|
|
383
|
+
if (_rhs.Appearance.IsSet() == true) {
|
|
384
|
+
Appearance = _rhs.Appearance;
|
|
385
|
+
}
|
|
386
|
+
if (_rhs.Services.IsSet() == true) {
|
|
387
|
+
Services = _rhs.Services;
|
|
388
|
+
}
|
|
389
|
+
Paired = _rhs.Paired;
|
|
390
|
+
Connected = _rhs.Connected;
|
|
391
|
+
return (*this);
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
DeviceinfoData& operator=(DeviceinfoData&& _rhs) noexcept
|
|
395
|
+
{
|
|
396
|
+
Address = std::move(_rhs.Address);
|
|
397
|
+
Type = std::move(_rhs.Type);
|
|
398
|
+
Name = std::move(_rhs.Name);
|
|
399
|
+
Cod = std::move(_rhs.Cod);
|
|
400
|
+
Appearance = std::move(_rhs.Appearance);
|
|
401
|
+
Services = std::move(_rhs.Services);
|
|
402
|
+
Paired = std::move(_rhs.Paired);
|
|
403
|
+
Connected = std::move(_rhs.Connected);
|
|
404
|
+
return (*this);
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
DeviceinfoData& operator=(const Exchange::JSONRPC::IBluetoothControl::deviceinfo& _rhs)
|
|
408
|
+
{
|
|
409
|
+
Address = _rhs.address;
|
|
410
|
+
Type = _rhs.type;
|
|
411
|
+
if (_rhs.name.IsSet() == true) {
|
|
412
|
+
Name = _rhs.name.Value();
|
|
413
|
+
}
|
|
414
|
+
if (_rhs.cod.IsSet() == true) {
|
|
415
|
+
Cod = _rhs.cod.Value();
|
|
416
|
+
}
|
|
417
|
+
if (_rhs.appearance.IsSet() == true) {
|
|
418
|
+
Appearance = _rhs.appearance.Value();
|
|
419
|
+
}
|
|
420
|
+
if (_rhs.services.IsSet() == true) {
|
|
421
|
+
Services = _rhs.services.Value();
|
|
422
|
+
}
|
|
423
|
+
Paired = _rhs.paired;
|
|
424
|
+
Connected = _rhs.connected;
|
|
425
|
+
return (*this);
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
operator Exchange::JSONRPC::IBluetoothControl::deviceinfo() const
|
|
429
|
+
{
|
|
430
|
+
Exchange::JSONRPC::IBluetoothControl::deviceinfo _value{};
|
|
431
|
+
_value.address = Address;
|
|
432
|
+
_value.type = Type;
|
|
433
|
+
if (Name.IsSet() == true) {
|
|
434
|
+
_value.name = Name;
|
|
435
|
+
}
|
|
436
|
+
if (Cod.IsSet() == true) {
|
|
437
|
+
_value.cod = Cod;
|
|
438
|
+
}
|
|
439
|
+
if (Appearance.IsSet() == true) {
|
|
440
|
+
_value.appearance = Appearance;
|
|
441
|
+
}
|
|
442
|
+
if (Services.IsSet() == true) {
|
|
443
|
+
_value.services = Services;
|
|
444
|
+
}
|
|
445
|
+
_value.paired = Paired;
|
|
446
|
+
_value.connected = Connected;
|
|
447
|
+
return (_value);
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
~DeviceinfoData() = default;
|
|
451
|
+
|
|
452
|
+
public:
|
|
453
|
+
bool IsDataValid() const
|
|
454
|
+
{
|
|
455
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && ((Cod.IsSet() == false) || (Cod.Value() <= 16777215)) && (Paired.IsSet() == true) && (Connected.IsSet() == true));
|
|
456
|
+
}
|
|
457
|
+
|
|
458
|
+
private:
|
|
459
|
+
void _Init()
|
|
460
|
+
{
|
|
461
|
+
Add(_T("address"), &Address);
|
|
462
|
+
Add(_T("type"), &Type);
|
|
463
|
+
Add(_T("name"), &Name);
|
|
464
|
+
Add(_T("class"), &Cod);
|
|
465
|
+
Add(_T("appearance"), &Appearance);
|
|
466
|
+
Add(_T("services"), &Services);
|
|
467
|
+
Services.SetQuoted(false);
|
|
468
|
+
Add(_T("paired"), &Paired);
|
|
469
|
+
Add(_T("connected"), &Connected);
|
|
470
|
+
}
|
|
471
|
+
|
|
472
|
+
public:
|
|
473
|
+
Core::JSON::String Address; // Bluetooth address
|
|
474
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Device type
|
|
475
|
+
Core::JSON::String Name; // Device name
|
|
476
|
+
Core::JSON::DecUInt32 Cod; // Class of Device (CoD) value
|
|
477
|
+
Core::JSON::DecUInt16 Appearance; // Appearance value (LE only)
|
|
478
|
+
Core::JSON::String Services; // Array of supported service UUIDs
|
|
479
|
+
Core::JSON::Boolean Paired; // Specifies if the device is currently paired
|
|
480
|
+
Core::JSON::Boolean Connected; // Specifies if the device is currently connected
|
|
481
|
+
}; // class DeviceinfoData
|
|
482
|
+
|
|
483
|
+
class DeviceStateChangedParamsData : public Core::JSON::Container {
|
|
484
|
+
public:
|
|
485
|
+
DeviceStateChangedParamsData()
|
|
486
|
+
: Core::JSON::Container()
|
|
487
|
+
{
|
|
488
|
+
Add(_T("address"), &Address);
|
|
489
|
+
Add(_T("type"), &Type);
|
|
490
|
+
Add(_T("state"), &State);
|
|
491
|
+
Add(_T("disconnectreason"), &DisconnectReason);
|
|
492
|
+
}
|
|
493
|
+
|
|
494
|
+
DeviceStateChangedParamsData(const DeviceStateChangedParamsData&) = delete;
|
|
495
|
+
DeviceStateChangedParamsData(DeviceStateChangedParamsData&&) noexcept = delete;
|
|
496
|
+
|
|
497
|
+
DeviceStateChangedParamsData& operator=(const DeviceStateChangedParamsData&) = delete;
|
|
498
|
+
DeviceStateChangedParamsData& operator=(DeviceStateChangedParamsData&&) noexcept = delete;
|
|
499
|
+
|
|
500
|
+
~DeviceStateChangedParamsData() = default;
|
|
501
|
+
|
|
502
|
+
public:
|
|
503
|
+
bool IsDataValid() const
|
|
504
|
+
{
|
|
505
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && (State.IsSet() == true));
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
public:
|
|
509
|
+
Core::JSON::String Address; // disconnectReason If disconnected specifies the cause of disconnection
|
|
510
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // disconnectReason If disconnected specifies the cause of disconnection
|
|
511
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicestate> State; // disconnectReason If disconnected specifies the cause of disconnection
|
|
512
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::disconnectreason> DisconnectReason; // disconnectReason If disconnected specifies the cause of disconnection
|
|
513
|
+
}; // class DeviceStateChangedParamsData
|
|
514
|
+
|
|
515
|
+
class DiscoverableStartedParamsData : public Core::JSON::Container {
|
|
516
|
+
public:
|
|
517
|
+
DiscoverableStartedParamsData()
|
|
518
|
+
: Core::JSON::Container()
|
|
519
|
+
{
|
|
520
|
+
Add(_T("type"), &Type);
|
|
521
|
+
Add(_T("mode"), &Mode);
|
|
522
|
+
Add(_T("connectable"), &Connectable);
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
DiscoverableStartedParamsData(const DiscoverableStartedParamsData&) = delete;
|
|
526
|
+
DiscoverableStartedParamsData(DiscoverableStartedParamsData&&) noexcept = delete;
|
|
527
|
+
|
|
528
|
+
DiscoverableStartedParamsData& operator=(const DiscoverableStartedParamsData&) = delete;
|
|
529
|
+
DiscoverableStartedParamsData& operator=(DiscoverableStartedParamsData&&) noexcept = delete;
|
|
530
|
+
|
|
531
|
+
~DiscoverableStartedParamsData() = default;
|
|
532
|
+
|
|
533
|
+
public:
|
|
534
|
+
bool IsDataValid() const
|
|
535
|
+
{
|
|
536
|
+
return ((Type.IsSet() == true) && (Mode.IsSet() == true));
|
|
537
|
+
}
|
|
538
|
+
|
|
539
|
+
public:
|
|
540
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype> Type; // Reports entering the discoverable state
|
|
541
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode> Mode; // Advertising or inquiry scanning mode
|
|
542
|
+
Core::JSON::Boolean Connectable; // Specifies if LE advertising reports that the device is connectable (LE-only)
|
|
543
|
+
}; // class DiscoverableStartedParamsData
|
|
544
|
+
|
|
545
|
+
class GetDeviceInfoResultData : public Core::JSON::Container {
|
|
546
|
+
public:
|
|
547
|
+
GetDeviceInfoResultData()
|
|
548
|
+
: Core::JSON::Container()
|
|
549
|
+
{
|
|
550
|
+
Add(_T("address"), &Address);
|
|
551
|
+
Add(_T("type"), &Type);
|
|
552
|
+
Add(_T("name"), &Name);
|
|
553
|
+
Add(_T("version"), &Version);
|
|
554
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
555
|
+
Add(_T("class"), &Cod);
|
|
556
|
+
Add(_T("appearance"), &Appearance);
|
|
557
|
+
Add(_T("services"), &Services);
|
|
558
|
+
Add(_T("paired"), &Paired);
|
|
559
|
+
Add(_T("connected"), &Connected);
|
|
560
|
+
}
|
|
561
|
+
|
|
562
|
+
GetDeviceInfoResultData(const GetDeviceInfoResultData&) = delete;
|
|
563
|
+
GetDeviceInfoResultData(GetDeviceInfoResultData&&) noexcept = delete;
|
|
564
|
+
|
|
565
|
+
GetDeviceInfoResultData& operator=(const GetDeviceInfoResultData&) = delete;
|
|
566
|
+
GetDeviceInfoResultData& operator=(GetDeviceInfoResultData&&) noexcept = delete;
|
|
567
|
+
|
|
568
|
+
~GetDeviceInfoResultData() = default;
|
|
569
|
+
|
|
570
|
+
public:
|
|
571
|
+
bool IsDataValid() const
|
|
572
|
+
{
|
|
573
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && ((Cod.IsSet() == false) || (Cod.Value() <= 16777215)) && (Paired.IsSet() == true) && (Connected.IsSet() == true));
|
|
574
|
+
}
|
|
575
|
+
|
|
576
|
+
public:
|
|
577
|
+
Core::JSON::String Address; // Retrieves detailed information about a known Bluetooth device
|
|
578
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Retrieves detailed information about a known Bluetooth device
|
|
579
|
+
Core::JSON::String Name; // Device local name
|
|
580
|
+
Core::JSON::DecUInt8 Version; // Device version
|
|
581
|
+
Core::JSON::DecUInt16 Manufacturer; // Company Identification Code (CIC)
|
|
582
|
+
Core::JSON::DecUInt32 Cod; // Class of Device (CoD) value
|
|
583
|
+
Core::JSON::DecUInt16 Appearance; // Appearance value (LE-only)
|
|
584
|
+
Core::JSON::ArrayType<Core::JSON::String> Services; // A list of supported service UUIDs
|
|
585
|
+
Core::JSON::Boolean Paired; // Specifies if the device is currently paired
|
|
586
|
+
Core::JSON::Boolean Connected; // Specifies if the device is currently connected
|
|
587
|
+
}; // class GetDeviceInfoResultData
|
|
588
|
+
|
|
589
|
+
class DeviceData : public Core::JSON::Container {
|
|
590
|
+
public:
|
|
591
|
+
DeviceData()
|
|
592
|
+
: Core::JSON::Container()
|
|
593
|
+
{
|
|
594
|
+
_Init();
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
DeviceData(const DeviceData& _other)
|
|
598
|
+
: Core::JSON::Container()
|
|
599
|
+
, Address(_other.Address)
|
|
600
|
+
, Type(_other.Type)
|
|
601
|
+
, Name(_other.Name)
|
|
602
|
+
{
|
|
603
|
+
_Init();
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
DeviceData(DeviceData&& _other) noexcept
|
|
607
|
+
: Core::JSON::Container()
|
|
608
|
+
, Address(std::move(_other.Address))
|
|
609
|
+
, Type(std::move(_other.Type))
|
|
610
|
+
, Name(std::move(_other.Name))
|
|
611
|
+
{
|
|
612
|
+
_Init();
|
|
613
|
+
}
|
|
614
|
+
|
|
615
|
+
DeviceData(const Exchange::JSONRPC::IBluetoothControl::device& _other)
|
|
616
|
+
: Core::JSON::Container()
|
|
617
|
+
{
|
|
618
|
+
Address = _other.address;
|
|
619
|
+
Type = _other.type;
|
|
620
|
+
Name = _other.name;
|
|
621
|
+
_Init();
|
|
622
|
+
}
|
|
623
|
+
|
|
624
|
+
DeviceData& operator=(const DeviceData& _rhs)
|
|
625
|
+
{
|
|
626
|
+
Address = _rhs.Address;
|
|
627
|
+
Type = _rhs.Type;
|
|
628
|
+
Name = _rhs.Name;
|
|
629
|
+
return (*this);
|
|
630
|
+
}
|
|
631
|
+
|
|
632
|
+
DeviceData& operator=(DeviceData&& _rhs) noexcept
|
|
633
|
+
{
|
|
634
|
+
Address = std::move(_rhs.Address);
|
|
635
|
+
Type = std::move(_rhs.Type);
|
|
636
|
+
Name = std::move(_rhs.Name);
|
|
637
|
+
return (*this);
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
DeviceData& operator=(const Exchange::JSONRPC::IBluetoothControl::device& _rhs)
|
|
641
|
+
{
|
|
642
|
+
Address = _rhs.address;
|
|
643
|
+
Type = _rhs.type;
|
|
644
|
+
Name = _rhs.name;
|
|
645
|
+
return (*this);
|
|
646
|
+
}
|
|
647
|
+
|
|
648
|
+
operator Exchange::JSONRPC::IBluetoothControl::device() const
|
|
649
|
+
{
|
|
650
|
+
Exchange::JSONRPC::IBluetoothControl::device _value{};
|
|
651
|
+
_value.address = Address;
|
|
652
|
+
_value.type = Type;
|
|
653
|
+
_value.name = Name;
|
|
654
|
+
return (_value);
|
|
655
|
+
}
|
|
656
|
+
|
|
657
|
+
~DeviceData() = default;
|
|
658
|
+
|
|
659
|
+
public:
|
|
660
|
+
bool IsDataValid() const
|
|
661
|
+
{
|
|
662
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && (Name.IsSet() == true));
|
|
663
|
+
}
|
|
664
|
+
|
|
665
|
+
private:
|
|
666
|
+
void _Init()
|
|
667
|
+
{
|
|
668
|
+
Add(_T("address"), &Address);
|
|
669
|
+
Add(_T("type"), &Type);
|
|
670
|
+
Add(_T("name"), &Name);
|
|
671
|
+
}
|
|
672
|
+
|
|
673
|
+
public:
|
|
674
|
+
Core::JSON::String Address; // Bluetooth address
|
|
675
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Bluetooth device type
|
|
676
|
+
Core::JSON::String Name; // Bluetooth short name
|
|
677
|
+
}; // class DeviceData
|
|
678
|
+
|
|
679
|
+
class PairParamsData : public Core::JSON::Container {
|
|
680
|
+
public:
|
|
681
|
+
PairParamsData()
|
|
682
|
+
: Core::JSON::Container()
|
|
683
|
+
, Capabilities(Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::NO_INPUT_NO_OUTPUT)
|
|
684
|
+
, Timeout(10)
|
|
685
|
+
{
|
|
686
|
+
Add(_T("address"), &Address);
|
|
687
|
+
Add(_T("type"), &Type);
|
|
688
|
+
Add(_T("capabilities"), &Capabilities);
|
|
689
|
+
Add(_T("timeout"), &Timeout);
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
PairParamsData(const PairParamsData&) = delete;
|
|
693
|
+
PairParamsData(PairParamsData&&) noexcept = delete;
|
|
694
|
+
|
|
695
|
+
PairParamsData& operator=(const PairParamsData&) = delete;
|
|
696
|
+
PairParamsData& operator=(PairParamsData&&) noexcept = delete;
|
|
697
|
+
|
|
698
|
+
~PairParamsData() = default;
|
|
699
|
+
|
|
700
|
+
public:
|
|
701
|
+
bool IsDataValid() const
|
|
702
|
+
{
|
|
703
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true));
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
public:
|
|
707
|
+
Core::JSON::String Address; // Pairs a Bluetooth device
|
|
708
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Pairs a Bluetooth device
|
|
709
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::pairingcapabilities> Capabilities; // Host device pairing capabilities
|
|
710
|
+
Core::JSON::DecUInt16 Timeout; // Time allowed for the pairing process to complete
|
|
711
|
+
}; // class PairParamsData
|
|
712
|
+
|
|
713
|
+
class PasskeyConfirmRequestParamsData : public Core::JSON::Container {
|
|
714
|
+
public:
|
|
715
|
+
PasskeyConfirmRequestParamsData()
|
|
716
|
+
: Core::JSON::Container()
|
|
717
|
+
{
|
|
718
|
+
Add(_T("address"), &Address);
|
|
719
|
+
Add(_T("type"), &Type);
|
|
720
|
+
Add(_T("secret"), &Secret);
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
PasskeyConfirmRequestParamsData(const PasskeyConfirmRequestParamsData&) = delete;
|
|
724
|
+
PasskeyConfirmRequestParamsData(PasskeyConfirmRequestParamsData&&) noexcept = delete;
|
|
725
|
+
|
|
726
|
+
PasskeyConfirmRequestParamsData& operator=(const PasskeyConfirmRequestParamsData&) = delete;
|
|
727
|
+
PasskeyConfirmRequestParamsData& operator=(PasskeyConfirmRequestParamsData&&) noexcept = delete;
|
|
728
|
+
|
|
729
|
+
~PasskeyConfirmRequestParamsData() = default;
|
|
730
|
+
|
|
731
|
+
public:
|
|
732
|
+
bool IsDataValid() const
|
|
733
|
+
{
|
|
734
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && ((Secret.IsSet() == false) || (Secret.Value() <= 999999)));
|
|
735
|
+
}
|
|
736
|
+
|
|
737
|
+
public:
|
|
738
|
+
Core::JSON::String Address; // Notifies of a user confirmation request during authenticated BR/EDR SSP pairing process
|
|
739
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Notifies of a user confirmation request during authenticated BR/EDR SSP pairing process
|
|
740
|
+
Core::JSON::DecUInt32 Secret; // A six-digit decimal number sent by the remote device to be presented to the end-user for confirmation on the local device (e.g 123456). The passkey may be omitted for simple yes/no paring.
|
|
741
|
+
}; // class PasskeyConfirmRequestParamsData
|
|
742
|
+
|
|
743
|
+
class ProvidePINCodeParamsData : public Core::JSON::Container {
|
|
744
|
+
public:
|
|
745
|
+
ProvidePINCodeParamsData()
|
|
746
|
+
: Core::JSON::Container()
|
|
747
|
+
{
|
|
748
|
+
Add(_T("address"), &Address);
|
|
749
|
+
Add(_T("type"), &Type);
|
|
750
|
+
Add(_T("secret"), &Secret);
|
|
751
|
+
}
|
|
752
|
+
|
|
753
|
+
ProvidePINCodeParamsData(const ProvidePINCodeParamsData&) = delete;
|
|
754
|
+
ProvidePINCodeParamsData(ProvidePINCodeParamsData&&) noexcept = delete;
|
|
755
|
+
|
|
756
|
+
ProvidePINCodeParamsData& operator=(const ProvidePINCodeParamsData&) = delete;
|
|
757
|
+
ProvidePINCodeParamsData& operator=(ProvidePINCodeParamsData&&) noexcept = delete;
|
|
758
|
+
|
|
759
|
+
~ProvidePINCodeParamsData() = default;
|
|
760
|
+
|
|
761
|
+
public:
|
|
762
|
+
bool IsDataValid() const
|
|
763
|
+
{
|
|
764
|
+
return ((Address.IsSet() == true) && (Type.IsSet() == true) && (((Secret.IsSet() == true) && (Secret.Value().size() <= 16))));
|
|
765
|
+
}
|
|
766
|
+
|
|
767
|
+
public:
|
|
768
|
+
Core::JSON::String Address; // Provides a PIN-code for authentication during a legacy pairing process
|
|
769
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::devicetype> Type; // Provides a PIN-code for authentication during a legacy pairing process
|
|
770
|
+
Core::JSON::String Secret; // A PIN code, typically 4 ASCII digits
|
|
771
|
+
}; // class ProvidePINCodeParamsData
|
|
772
|
+
|
|
773
|
+
class ScanParamsData : public Core::JSON::Container {
|
|
774
|
+
public:
|
|
775
|
+
ScanParamsData()
|
|
776
|
+
: Core::JSON::Container()
|
|
777
|
+
, Mode(Exchange::JSONRPC::IBluetoothControl::scanmode::GENERAL)
|
|
778
|
+
, Duration(12)
|
|
779
|
+
{
|
|
780
|
+
Add(_T("type"), &Type);
|
|
781
|
+
Add(_T("mode"), &Mode);
|
|
782
|
+
Add(_T("duration"), &Duration);
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
ScanParamsData(const ScanParamsData&) = delete;
|
|
786
|
+
ScanParamsData(ScanParamsData&&) noexcept = delete;
|
|
787
|
+
|
|
788
|
+
ScanParamsData& operator=(const ScanParamsData&) = delete;
|
|
789
|
+
ScanParamsData& operator=(ScanParamsData&&) noexcept = delete;
|
|
790
|
+
|
|
791
|
+
~ScanParamsData() = default;
|
|
792
|
+
|
|
793
|
+
public:
|
|
794
|
+
bool IsDataValid() const
|
|
795
|
+
{
|
|
796
|
+
return (Type.IsSet() == true);
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
public:
|
|
800
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype> Type; // Starts LE active discovery or BR/EDR inquiry of nearby Bluetooth devices
|
|
801
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode> Mode; // Discovery or inquiry mode (scan picks up only devices discoverable in paricular mode)
|
|
802
|
+
Core::JSON::DecUInt16 Duration; // Time span of the discovery in seconds
|
|
803
|
+
}; // class ScanParamsData
|
|
804
|
+
|
|
805
|
+
class ScanStartedParamsData : public Core::JSON::Container {
|
|
806
|
+
public:
|
|
807
|
+
ScanStartedParamsData()
|
|
808
|
+
: Core::JSON::Container()
|
|
809
|
+
{
|
|
810
|
+
Add(_T("type"), &Type);
|
|
811
|
+
Add(_T("mode"), &Mode);
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
ScanStartedParamsData(const ScanStartedParamsData&) = delete;
|
|
815
|
+
ScanStartedParamsData(ScanStartedParamsData&&) noexcept = delete;
|
|
816
|
+
|
|
817
|
+
ScanStartedParamsData& operator=(const ScanStartedParamsData&) = delete;
|
|
818
|
+
ScanStartedParamsData& operator=(ScanStartedParamsData&&) noexcept = delete;
|
|
819
|
+
|
|
820
|
+
~ScanStartedParamsData() = default;
|
|
821
|
+
|
|
822
|
+
public:
|
|
823
|
+
bool IsDataValid() const
|
|
824
|
+
{
|
|
825
|
+
return ((Type.IsSet() == true) && (Mode.IsSet() == true));
|
|
826
|
+
}
|
|
827
|
+
|
|
828
|
+
public:
|
|
829
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype> Type; // Reports start of scanning
|
|
830
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode> Mode; // Discovery or inquiry mode
|
|
831
|
+
}; // class ScanStartedParamsData
|
|
832
|
+
|
|
833
|
+
class SetDiscoverableParamsData : public Core::JSON::Container {
|
|
834
|
+
public:
|
|
835
|
+
SetDiscoverableParamsData()
|
|
836
|
+
: Core::JSON::Container()
|
|
837
|
+
, Mode(Exchange::JSONRPC::IBluetoothControl::scanmode::GENERAL)
|
|
838
|
+
, Connectable(true)
|
|
839
|
+
, Duration(30)
|
|
840
|
+
{
|
|
841
|
+
Add(_T("type"), &Type);
|
|
842
|
+
Add(_T("mode"), &Mode);
|
|
843
|
+
Add(_T("connectable"), &Connectable);
|
|
844
|
+
Add(_T("duration"), &Duration);
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
SetDiscoverableParamsData(const SetDiscoverableParamsData&) = delete;
|
|
848
|
+
SetDiscoverableParamsData(SetDiscoverableParamsData&&) noexcept = delete;
|
|
849
|
+
|
|
850
|
+
SetDiscoverableParamsData& operator=(const SetDiscoverableParamsData&) = delete;
|
|
851
|
+
SetDiscoverableParamsData& operator=(SetDiscoverableParamsData&&) noexcept = delete;
|
|
852
|
+
|
|
853
|
+
~SetDiscoverableParamsData() = default;
|
|
854
|
+
|
|
855
|
+
public:
|
|
856
|
+
bool IsDataValid() const
|
|
857
|
+
{
|
|
858
|
+
return (Type.IsSet() == true);
|
|
859
|
+
}
|
|
860
|
+
|
|
861
|
+
public:
|
|
862
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scantype> Type; // Starts LE advertising or BR/EDR inquiry scanning, making the local interface visible for nearby Bluetooth devices
|
|
863
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IBluetoothControl::scanmode> Mode; // Advertising or inquiry scanning mode
|
|
864
|
+
Core::JSON::Boolean Connectable; // Specifies if LE advertising should report the device is connectable (LE-only)
|
|
865
|
+
Core::JSON::DecUInt16 Duration; // Time span of the discoverable state in seconds
|
|
866
|
+
}; // class SetDiscoverableParamsData
|
|
867
|
+
|
|
868
|
+
} // namespace BluetoothControl
|
|
869
|
+
|
|
870
|
+
POP_WARNING()
|
|
871
|
+
|
|
872
|
+
} // namespace JsonData
|
|
873
|
+
|
|
874
|
+
// Enum conversion handlers
|
|
875
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::scantype)
|
|
876
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::scanmode)
|
|
877
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::devicetype)
|
|
878
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::pairingcapabilities)
|
|
879
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::adaptertype)
|
|
880
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::devicestate)
|
|
881
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IBluetoothControl::disconnectreason)
|
|
882
|
+
|
|
883
|
+
}
|
|
884
|
+
|
|
@@ -0,0 +1,264 @@
|
|
|
1
|
+
// C++ types for BluetoothRemoteControl API.
|
|
2
|
+
// Generated automatically from 'IBluetoothRemoteControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBluetoothRemoteControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BluetoothRemoteControl {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AssignParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AssignParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("address"), &Address);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AssignParamsData(const AssignParamsData&) = delete;
|
|
31
|
+
AssignParamsData(AssignParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
AssignParamsData& operator=(const AssignParamsData&) = delete;
|
|
34
|
+
AssignParamsData& operator=(AssignParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~AssignParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Address.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Address; // Address of the Bluetooth device to assign
|
|
46
|
+
}; // class AssignParamsData
|
|
47
|
+
|
|
48
|
+
class BatteryLevelChangeParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
BatteryLevelChangeParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("level"), &Level);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
BatteryLevelChangeParamsData(const BatteryLevelChangeParamsData&) = delete;
|
|
57
|
+
BatteryLevelChangeParamsData(BatteryLevelChangeParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
BatteryLevelChangeParamsData& operator=(const BatteryLevelChangeParamsData&) = delete;
|
|
60
|
+
BatteryLevelChangeParamsData& operator=(BatteryLevelChangeParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~BatteryLevelChangeParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Level.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::DecUInt8 Level; // Battery level in percent
|
|
72
|
+
}; // class BatteryLevelChangeParamsData
|
|
73
|
+
|
|
74
|
+
class UnitmetadataData : public Core::JSON::Container {
|
|
75
|
+
public:
|
|
76
|
+
UnitmetadataData()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
_Init();
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
UnitmetadataData(const UnitmetadataData& _other)
|
|
83
|
+
: Core::JSON::Container()
|
|
84
|
+
, Name(_other.Name)
|
|
85
|
+
, Model(_other.Model)
|
|
86
|
+
, Serial(_other.Serial)
|
|
87
|
+
, Firmware(_other.Firmware)
|
|
88
|
+
, Software(_other.Software)
|
|
89
|
+
, Manufacturer(_other.Manufacturer)
|
|
90
|
+
{
|
|
91
|
+
_Init();
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
UnitmetadataData(UnitmetadataData&& _other) noexcept
|
|
95
|
+
: Core::JSON::Container()
|
|
96
|
+
, Name(std::move(_other.Name))
|
|
97
|
+
, Model(std::move(_other.Model))
|
|
98
|
+
, Serial(std::move(_other.Serial))
|
|
99
|
+
, Firmware(std::move(_other.Firmware))
|
|
100
|
+
, Software(std::move(_other.Software))
|
|
101
|
+
, Manufacturer(std::move(_other.Manufacturer))
|
|
102
|
+
{
|
|
103
|
+
_Init();
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
UnitmetadataData(const Exchange::IBluetoothRemoteControl::unitmetadata& _other)
|
|
107
|
+
: Core::JSON::Container()
|
|
108
|
+
{
|
|
109
|
+
Name = _other.name;
|
|
110
|
+
if (_other.model.IsSet() == true) {
|
|
111
|
+
Model = _other.model.Value();
|
|
112
|
+
}
|
|
113
|
+
if (_other.serial.IsSet() == true) {
|
|
114
|
+
Serial = _other.serial.Value();
|
|
115
|
+
}
|
|
116
|
+
if (_other.firmware.IsSet() == true) {
|
|
117
|
+
Firmware = _other.firmware.Value();
|
|
118
|
+
}
|
|
119
|
+
if (_other.software.IsSet() == true) {
|
|
120
|
+
Software = _other.software.Value();
|
|
121
|
+
}
|
|
122
|
+
if (_other.manufacturer.IsSet() == true) {
|
|
123
|
+
Manufacturer = _other.manufacturer.Value();
|
|
124
|
+
}
|
|
125
|
+
_Init();
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
UnitmetadataData& operator=(const UnitmetadataData& _rhs)
|
|
129
|
+
{
|
|
130
|
+
Name = _rhs.Name;
|
|
131
|
+
if (_rhs.Model.IsSet() == true) {
|
|
132
|
+
Model = _rhs.Model;
|
|
133
|
+
}
|
|
134
|
+
if (_rhs.Serial.IsSet() == true) {
|
|
135
|
+
Serial = _rhs.Serial;
|
|
136
|
+
}
|
|
137
|
+
if (_rhs.Firmware.IsSet() == true) {
|
|
138
|
+
Firmware = _rhs.Firmware;
|
|
139
|
+
}
|
|
140
|
+
if (_rhs.Software.IsSet() == true) {
|
|
141
|
+
Software = _rhs.Software;
|
|
142
|
+
}
|
|
143
|
+
if (_rhs.Manufacturer.IsSet() == true) {
|
|
144
|
+
Manufacturer = _rhs.Manufacturer;
|
|
145
|
+
}
|
|
146
|
+
return (*this);
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
UnitmetadataData& operator=(UnitmetadataData&& _rhs) noexcept
|
|
150
|
+
{
|
|
151
|
+
Name = std::move(_rhs.Name);
|
|
152
|
+
Model = std::move(_rhs.Model);
|
|
153
|
+
Serial = std::move(_rhs.Serial);
|
|
154
|
+
Firmware = std::move(_rhs.Firmware);
|
|
155
|
+
Software = std::move(_rhs.Software);
|
|
156
|
+
Manufacturer = std::move(_rhs.Manufacturer);
|
|
157
|
+
return (*this);
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
UnitmetadataData& operator=(const Exchange::IBluetoothRemoteControl::unitmetadata& _rhs)
|
|
161
|
+
{
|
|
162
|
+
Name = _rhs.name;
|
|
163
|
+
if (_rhs.model.IsSet() == true) {
|
|
164
|
+
Model = _rhs.model.Value();
|
|
165
|
+
}
|
|
166
|
+
if (_rhs.serial.IsSet() == true) {
|
|
167
|
+
Serial = _rhs.serial.Value();
|
|
168
|
+
}
|
|
169
|
+
if (_rhs.firmware.IsSet() == true) {
|
|
170
|
+
Firmware = _rhs.firmware.Value();
|
|
171
|
+
}
|
|
172
|
+
if (_rhs.software.IsSet() == true) {
|
|
173
|
+
Software = _rhs.software.Value();
|
|
174
|
+
}
|
|
175
|
+
if (_rhs.manufacturer.IsSet() == true) {
|
|
176
|
+
Manufacturer = _rhs.manufacturer.Value();
|
|
177
|
+
}
|
|
178
|
+
return (*this);
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
operator Exchange::IBluetoothRemoteControl::unitmetadata() const
|
|
182
|
+
{
|
|
183
|
+
Exchange::IBluetoothRemoteControl::unitmetadata _value{};
|
|
184
|
+
_value.name = Name;
|
|
185
|
+
if (Model.IsSet() == true) {
|
|
186
|
+
_value.model = Model;
|
|
187
|
+
}
|
|
188
|
+
if (Serial.IsSet() == true) {
|
|
189
|
+
_value.serial = Serial;
|
|
190
|
+
}
|
|
191
|
+
if (Firmware.IsSet() == true) {
|
|
192
|
+
_value.firmware = Firmware;
|
|
193
|
+
}
|
|
194
|
+
if (Software.IsSet() == true) {
|
|
195
|
+
_value.software = Software;
|
|
196
|
+
}
|
|
197
|
+
if (Manufacturer.IsSet() == true) {
|
|
198
|
+
_value.manufacturer = Manufacturer;
|
|
199
|
+
}
|
|
200
|
+
return (_value);
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
~UnitmetadataData() = default;
|
|
204
|
+
|
|
205
|
+
public:
|
|
206
|
+
bool IsDataValid() const
|
|
207
|
+
{
|
|
208
|
+
return (Name.IsSet() == true);
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
private:
|
|
212
|
+
void _Init()
|
|
213
|
+
{
|
|
214
|
+
Add(_T("name"), &Name);
|
|
215
|
+
Add(_T("model"), &Model);
|
|
216
|
+
Add(_T("serial"), &Serial);
|
|
217
|
+
Add(_T("firmware"), &Firmware);
|
|
218
|
+
Add(_T("software"), &Software);
|
|
219
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
public:
|
|
223
|
+
Core::JSON::String Name; // Name of the unit
|
|
224
|
+
Core::JSON::String Model; // Model name
|
|
225
|
+
Core::JSON::String Serial; // Serial number
|
|
226
|
+
Core::JSON::String Firmware; // Firmware version
|
|
227
|
+
Core::JSON::String Software; // Software version
|
|
228
|
+
Core::JSON::String Manufacturer; // Vendor/manufacturer name
|
|
229
|
+
}; // class UnitmetadataData
|
|
230
|
+
|
|
231
|
+
class VoiceControlData : public Core::JSON::Container {
|
|
232
|
+
public:
|
|
233
|
+
VoiceControlData()
|
|
234
|
+
: Core::JSON::Container()
|
|
235
|
+
{
|
|
236
|
+
Add(_T("value"), &Value);
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
VoiceControlData(const VoiceControlData&) = delete;
|
|
240
|
+
VoiceControlData(VoiceControlData&&) noexcept = delete;
|
|
241
|
+
|
|
242
|
+
VoiceControlData& operator=(const VoiceControlData&) = delete;
|
|
243
|
+
VoiceControlData& operator=(VoiceControlData&&) noexcept = delete;
|
|
244
|
+
|
|
245
|
+
~VoiceControlData() = default;
|
|
246
|
+
|
|
247
|
+
public:
|
|
248
|
+
bool IsDataValid() const
|
|
249
|
+
{
|
|
250
|
+
return (Value.IsSet() == true);
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
public:
|
|
254
|
+
Core::JSON::Boolean Value; // Toggle voice control
|
|
255
|
+
}; // class VoiceControlData
|
|
256
|
+
|
|
257
|
+
} // namespace BluetoothRemoteControl
|
|
258
|
+
|
|
259
|
+
POP_WARNING()
|
|
260
|
+
|
|
261
|
+
} // namespace JsonData
|
|
262
|
+
|
|
263
|
+
}
|
|
264
|
+
|
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
// C++ types for Browser API.
|
|
2
|
+
// Generated automatically from 'Browser.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Browser {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Current browser visibility
|
|
23
|
+
enum class VisibilityType : uint8_t {
|
|
24
|
+
VISIBLE,
|
|
25
|
+
HIDDEN
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// Method params/result classes
|
|
29
|
+
//
|
|
30
|
+
|
|
31
|
+
class DeleteParamsData : public Core::JSON::Container {
|
|
32
|
+
public:
|
|
33
|
+
DeleteParamsData()
|
|
34
|
+
: Core::JSON::Container()
|
|
35
|
+
{
|
|
36
|
+
Add(_T("path"), &Path);
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
DeleteParamsData(const DeleteParamsData&) = delete;
|
|
40
|
+
DeleteParamsData(DeleteParamsData&&) noexcept = delete;
|
|
41
|
+
|
|
42
|
+
DeleteParamsData& operator=(const DeleteParamsData&) = delete;
|
|
43
|
+
DeleteParamsData& operator=(DeleteParamsData&&) noexcept = delete;
|
|
44
|
+
|
|
45
|
+
~DeleteParamsData() = default;
|
|
46
|
+
|
|
47
|
+
public:
|
|
48
|
+
bool IsDataValid() const
|
|
49
|
+
{
|
|
50
|
+
return (Path.IsSet() == true);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
public:
|
|
54
|
+
Core::JSON::String Path; // Path to directory (within the persistent storage) to delete contents of
|
|
55
|
+
}; // class DeleteParamsData
|
|
56
|
+
|
|
57
|
+
class UrlchangeParamsData : public Core::JSON::Container {
|
|
58
|
+
public:
|
|
59
|
+
UrlchangeParamsData()
|
|
60
|
+
: Core::JSON::Container()
|
|
61
|
+
{
|
|
62
|
+
Add(_T("url"), &Url);
|
|
63
|
+
Add(_T("loaded"), &Loaded);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
UrlchangeParamsData(const UrlchangeParamsData&) = delete;
|
|
67
|
+
UrlchangeParamsData(UrlchangeParamsData&&) noexcept = delete;
|
|
68
|
+
|
|
69
|
+
UrlchangeParamsData& operator=(const UrlchangeParamsData&) = delete;
|
|
70
|
+
UrlchangeParamsData& operator=(UrlchangeParamsData&&) noexcept = delete;
|
|
71
|
+
|
|
72
|
+
~UrlchangeParamsData() = default;
|
|
73
|
+
|
|
74
|
+
public:
|
|
75
|
+
bool IsDataValid() const
|
|
76
|
+
{
|
|
77
|
+
return ((Url.IsSet() == true) && (Loaded.IsSet() == true));
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
public:
|
|
81
|
+
Core::JSON::String Url; // The URL that has been loaded or requested
|
|
82
|
+
Core::JSON::Boolean Loaded; // Determines if the URL has just been loaded (true) or if URL change has been requested (false)
|
|
83
|
+
}; // class UrlchangeParamsData
|
|
84
|
+
|
|
85
|
+
class VisibilitychangeParamsData : public Core::JSON::Container {
|
|
86
|
+
public:
|
|
87
|
+
VisibilitychangeParamsData()
|
|
88
|
+
: Core::JSON::Container()
|
|
89
|
+
{
|
|
90
|
+
Add(_T("hidden"), &Hidden);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
VisibilitychangeParamsData(const VisibilitychangeParamsData&) = delete;
|
|
94
|
+
VisibilitychangeParamsData(VisibilitychangeParamsData&&) noexcept = delete;
|
|
95
|
+
|
|
96
|
+
VisibilitychangeParamsData& operator=(const VisibilitychangeParamsData&) = delete;
|
|
97
|
+
VisibilitychangeParamsData& operator=(VisibilitychangeParamsData&&) noexcept = delete;
|
|
98
|
+
|
|
99
|
+
~VisibilitychangeParamsData() = default;
|
|
100
|
+
|
|
101
|
+
public:
|
|
102
|
+
bool IsDataValid() const
|
|
103
|
+
{
|
|
104
|
+
return (Hidden.IsSet() == true);
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
public:
|
|
108
|
+
Core::JSON::Boolean Hidden; // Determines if the browser has been hidden (true) or made visible (false)
|
|
109
|
+
}; // class VisibilitychangeParamsData
|
|
110
|
+
|
|
111
|
+
} // namespace Browser
|
|
112
|
+
|
|
113
|
+
POP_WARNING()
|
|
114
|
+
|
|
115
|
+
} // namespace JsonData
|
|
116
|
+
|
|
117
|
+
// Enum conversion handlers
|
|
118
|
+
ENUM_CONVERSION_HANDLER(JsonData::Browser::VisibilityType)
|
|
119
|
+
|
|
120
|
+
}
|
|
121
|
+
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
// C++ types for BrowserCookieJar API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BrowserCookieJar {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ConfigData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ConfigData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ConfigData(const ConfigData& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Version(_other.Version)
|
|
33
|
+
, Checksum(_other.Checksum)
|
|
34
|
+
, Payload(_other.Payload)
|
|
35
|
+
{
|
|
36
|
+
_Init();
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
ConfigData(ConfigData&& _other) noexcept
|
|
40
|
+
: Core::JSON::Container()
|
|
41
|
+
, Version(std::move(_other.Version))
|
|
42
|
+
, Checksum(std::move(_other.Checksum))
|
|
43
|
+
, Payload(std::move(_other.Payload))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
ConfigData(const Exchange::IBrowserCookieJar::Config& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
Version = _other.version;
|
|
52
|
+
Checksum = _other.checksum;
|
|
53
|
+
Payload = _other.payload;
|
|
54
|
+
_Init();
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
ConfigData& operator=(const ConfigData& _rhs)
|
|
58
|
+
{
|
|
59
|
+
Version = _rhs.Version;
|
|
60
|
+
Checksum = _rhs.Checksum;
|
|
61
|
+
Payload = _rhs.Payload;
|
|
62
|
+
return (*this);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
ConfigData& operator=(ConfigData&& _rhs) noexcept
|
|
66
|
+
{
|
|
67
|
+
Version = std::move(_rhs.Version);
|
|
68
|
+
Checksum = std::move(_rhs.Checksum);
|
|
69
|
+
Payload = std::move(_rhs.Payload);
|
|
70
|
+
return (*this);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
ConfigData& operator=(const Exchange::IBrowserCookieJar::Config& _rhs)
|
|
74
|
+
{
|
|
75
|
+
Version = _rhs.version;
|
|
76
|
+
Checksum = _rhs.checksum;
|
|
77
|
+
Payload = _rhs.payload;
|
|
78
|
+
return (*this);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
operator Exchange::IBrowserCookieJar::Config() const
|
|
82
|
+
{
|
|
83
|
+
Exchange::IBrowserCookieJar::Config _value{};
|
|
84
|
+
_value.version = Version;
|
|
85
|
+
_value.checksum = Checksum;
|
|
86
|
+
_value.payload = Payload;
|
|
87
|
+
return (_value);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
~ConfigData() = default;
|
|
91
|
+
|
|
92
|
+
public:
|
|
93
|
+
bool IsDataValid() const
|
|
94
|
+
{
|
|
95
|
+
return ((Version.IsSet() == true) && (Checksum.IsSet() == true) && (Payload.IsSet() == true));
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
private:
|
|
99
|
+
void _Init()
|
|
100
|
+
{
|
|
101
|
+
Add(_T("version"), &Version);
|
|
102
|
+
Add(_T("checksum"), &Checksum);
|
|
103
|
+
Add(_T("payload"), &Payload);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
public:
|
|
107
|
+
Core::JSON::DecUInt32 Version; // Version of payload format
|
|
108
|
+
Core::JSON::DecUInt32 Checksum; // The checksum of the string used for payload creation
|
|
109
|
+
Core::JSON::String Payload; // Base64 string representation of compressed and encrypted cookies
|
|
110
|
+
}; // class ConfigData
|
|
111
|
+
|
|
112
|
+
} // namespace BrowserCookieJar
|
|
113
|
+
|
|
114
|
+
POP_WARNING()
|
|
115
|
+
|
|
116
|
+
} // namespace JsonData
|
|
117
|
+
|
|
118
|
+
// Enum conversion handlers
|
|
119
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
120
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
121
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBrowserSecurity::MixedContentPolicyType)
|
|
122
|
+
|
|
123
|
+
}
|
|
124
|
+
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
// C++ types for BrowserResources API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BrowserResources {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace BrowserResources
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
31
|
+
|
|
32
|
+
}
|
|
33
|
+
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
// C++ types for BrowserScripting API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BrowserScripting {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AddUserScriptParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AddUserScriptParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("script"), &Script);
|
|
28
|
+
Add(_T("topframeonly"), &TopFrameOnly);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
AddUserScriptParamsData(const AddUserScriptParamsData&) = delete;
|
|
32
|
+
AddUserScriptParamsData(AddUserScriptParamsData&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
AddUserScriptParamsData& operator=(const AddUserScriptParamsData&) = delete;
|
|
35
|
+
AddUserScriptParamsData& operator=(AddUserScriptParamsData&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~AddUserScriptParamsData() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((Script.IsSet() == true) && (TopFrameOnly.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::String Script; // Utf8 encoded JS code string.
|
|
47
|
+
Core::JSON::Boolean TopFrameOnly; // Enable only top frame
|
|
48
|
+
}; // class AddUserScriptParamsData
|
|
49
|
+
|
|
50
|
+
class RunJavaScriptParamsData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
RunJavaScriptParamsData()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("script"), &Script);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
RunJavaScriptParamsData(const RunJavaScriptParamsData&) = delete;
|
|
59
|
+
RunJavaScriptParamsData(RunJavaScriptParamsData&&) noexcept = delete;
|
|
60
|
+
|
|
61
|
+
RunJavaScriptParamsData& operator=(const RunJavaScriptParamsData&) = delete;
|
|
62
|
+
RunJavaScriptParamsData& operator=(RunJavaScriptParamsData&&) noexcept = delete;
|
|
63
|
+
|
|
64
|
+
~RunJavaScriptParamsData() = default;
|
|
65
|
+
|
|
66
|
+
public:
|
|
67
|
+
bool IsDataValid() const
|
|
68
|
+
{
|
|
69
|
+
return (Script.IsSet() == true);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
public:
|
|
73
|
+
Core::JSON::String Script; // Utf8 encoded JS code string.
|
|
74
|
+
}; // class RunJavaScriptParamsData
|
|
75
|
+
|
|
76
|
+
} // namespace BrowserScripting
|
|
77
|
+
|
|
78
|
+
POP_WARNING()
|
|
79
|
+
|
|
80
|
+
} // namespace JsonData
|
|
81
|
+
|
|
82
|
+
// Enum conversion handlers
|
|
83
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
84
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
85
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBrowserSecurity::MixedContentPolicyType)
|
|
86
|
+
|
|
87
|
+
}
|
|
88
|
+
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
// C++ types for BrowserSecurity API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace BrowserSecurity {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace BrowserSecurity
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
31
|
+
ENUM_CONVERSION_HANDLER(Exchange::IBrowserSecurity::MixedContentPolicyType)
|
|
32
|
+
|
|
33
|
+
}
|
|
34
|
+
|
|
@@ -0,0 +1,218 @@
|
|
|
1
|
+
// C++ types for Butler API.
|
|
2
|
+
// Generated automatically from 'IButler.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IButler.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Butler {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AddedParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AddedParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("element"), &Element);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AddedParamsInfo(const AddedParamsInfo&) = delete;
|
|
31
|
+
AddedParamsInfo(AddedParamsInfo&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
AddedParamsInfo& operator=(const AddedParamsInfo&) = delete;
|
|
34
|
+
AddedParamsInfo& operator=(AddedParamsInfo&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~AddedParamsInfo() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Element.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Element;
|
|
46
|
+
}; // class AddedParamsInfo
|
|
47
|
+
|
|
48
|
+
class BranchParamsInfo : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
BranchParamsInfo()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("path"), &Path);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
BranchParamsInfo(const BranchParamsInfo&) = delete;
|
|
57
|
+
BranchParamsInfo(BranchParamsInfo&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
BranchParamsInfo& operator=(const BranchParamsInfo&) = delete;
|
|
60
|
+
BranchParamsInfo& operator=(BranchParamsInfo&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~BranchParamsInfo() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Path.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String Path;
|
|
72
|
+
}; // class BranchParamsInfo
|
|
73
|
+
|
|
74
|
+
class IdentifierParamsInfo : public Core::JSON::Container {
|
|
75
|
+
public:
|
|
76
|
+
IdentifierParamsInfo()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
Add(_T("id"), &Id);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
IdentifierParamsInfo(const IdentifierParamsInfo&) = delete;
|
|
83
|
+
IdentifierParamsInfo(IdentifierParamsInfo&&) noexcept = delete;
|
|
84
|
+
|
|
85
|
+
IdentifierParamsInfo& operator=(const IdentifierParamsInfo&) = delete;
|
|
86
|
+
IdentifierParamsInfo& operator=(IdentifierParamsInfo&&) noexcept = delete;
|
|
87
|
+
|
|
88
|
+
~IdentifierParamsInfo() = default;
|
|
89
|
+
|
|
90
|
+
public:
|
|
91
|
+
bool IsDataValid() const
|
|
92
|
+
{
|
|
93
|
+
return (Id.IsSet() == true);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
public:
|
|
97
|
+
Core::JSON::DecUInt32 Id;
|
|
98
|
+
}; // class IdentifierParamsInfo
|
|
99
|
+
|
|
100
|
+
// Method params/result classes
|
|
101
|
+
//
|
|
102
|
+
|
|
103
|
+
class LinkParamsData : public Core::JSON::Container {
|
|
104
|
+
public:
|
|
105
|
+
LinkParamsData()
|
|
106
|
+
: Core::JSON::Container()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("name"), &Name);
|
|
109
|
+
Add(_T("id"), &Id);
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
LinkParamsData(const LinkParamsData&) = delete;
|
|
113
|
+
LinkParamsData(LinkParamsData&&) noexcept = delete;
|
|
114
|
+
|
|
115
|
+
LinkParamsData& operator=(const LinkParamsData&) = delete;
|
|
116
|
+
LinkParamsData& operator=(LinkParamsData&&) noexcept = delete;
|
|
117
|
+
|
|
118
|
+
~LinkParamsData() = default;
|
|
119
|
+
|
|
120
|
+
public:
|
|
121
|
+
bool IsDataValid() const
|
|
122
|
+
{
|
|
123
|
+
return ((Name.IsSet() == true) && (Id.IsSet() == true));
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
public:
|
|
127
|
+
Core::JSON::String Name;
|
|
128
|
+
Core::JSON::DecUInt32 Id;
|
|
129
|
+
}; // class LinkParamsData
|
|
130
|
+
|
|
131
|
+
class MoveParamsData : public Core::JSON::Container {
|
|
132
|
+
public:
|
|
133
|
+
MoveParamsData()
|
|
134
|
+
: Core::JSON::Container()
|
|
135
|
+
{
|
|
136
|
+
Add(_T("path"), &Path);
|
|
137
|
+
Add(_T("newName"), &NewName);
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
MoveParamsData(const MoveParamsData&) = delete;
|
|
141
|
+
MoveParamsData(MoveParamsData&&) noexcept = delete;
|
|
142
|
+
|
|
143
|
+
MoveParamsData& operator=(const MoveParamsData&) = delete;
|
|
144
|
+
MoveParamsData& operator=(MoveParamsData&&) noexcept = delete;
|
|
145
|
+
|
|
146
|
+
~MoveParamsData() = default;
|
|
147
|
+
|
|
148
|
+
public:
|
|
149
|
+
bool IsDataValid() const
|
|
150
|
+
{
|
|
151
|
+
return ((Path.IsSet() == true) && (NewName.IsSet() == true));
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
public:
|
|
155
|
+
Core::JSON::String Path;
|
|
156
|
+
Core::JSON::String NewName;
|
|
157
|
+
}; // class MoveParamsData
|
|
158
|
+
|
|
159
|
+
class NameParamsData : public Core::JSON::Container {
|
|
160
|
+
public:
|
|
161
|
+
NameParamsData()
|
|
162
|
+
: Core::JSON::Container()
|
|
163
|
+
{
|
|
164
|
+
Add(_T("name"), &Name);
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
NameParamsData(const NameParamsData&) = delete;
|
|
168
|
+
NameParamsData(NameParamsData&&) noexcept = delete;
|
|
169
|
+
|
|
170
|
+
NameParamsData& operator=(const NameParamsData&) = delete;
|
|
171
|
+
NameParamsData& operator=(NameParamsData&&) noexcept = delete;
|
|
172
|
+
|
|
173
|
+
~NameParamsData() = default;
|
|
174
|
+
|
|
175
|
+
public:
|
|
176
|
+
bool IsDataValid() const
|
|
177
|
+
{
|
|
178
|
+
return (Name.IsSet() == true);
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
public:
|
|
182
|
+
Core::JSON::String Name;
|
|
183
|
+
}; // class NameParamsData
|
|
184
|
+
|
|
185
|
+
class OrphansParamsData : public Core::JSON::Container {
|
|
186
|
+
public:
|
|
187
|
+
OrphansParamsData()
|
|
188
|
+
: Core::JSON::Container()
|
|
189
|
+
{
|
|
190
|
+
Add(_T("module"), &Module);
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
OrphansParamsData(const OrphansParamsData&) = delete;
|
|
194
|
+
OrphansParamsData(OrphansParamsData&&) noexcept = delete;
|
|
195
|
+
|
|
196
|
+
OrphansParamsData& operator=(const OrphansParamsData&) = delete;
|
|
197
|
+
OrphansParamsData& operator=(OrphansParamsData&&) noexcept = delete;
|
|
198
|
+
|
|
199
|
+
~OrphansParamsData() = default;
|
|
200
|
+
|
|
201
|
+
public:
|
|
202
|
+
bool IsDataValid() const
|
|
203
|
+
{
|
|
204
|
+
return (Module.IsSet() == true);
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
public:
|
|
208
|
+
Core::JSON::DecUInt8 Module;
|
|
209
|
+
}; // class OrphansParamsData
|
|
210
|
+
|
|
211
|
+
} // namespace Butler
|
|
212
|
+
|
|
213
|
+
POP_WARNING()
|
|
214
|
+
|
|
215
|
+
} // namespace JsonData
|
|
216
|
+
|
|
217
|
+
}
|
|
218
|
+
|
|
@@ -0,0 +1,154 @@
|
|
|
1
|
+
// C++ types for Compositor API.
|
|
2
|
+
// Generated automatically from 'Compositor.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Compositor {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Brightness of SDR graphics in HDR display
|
|
23
|
+
enum class BrightnessType : uint8_t {
|
|
24
|
+
DEFAULT,
|
|
25
|
+
MATCH_VIDEO,
|
|
26
|
+
MAX
|
|
27
|
+
};
|
|
28
|
+
|
|
29
|
+
// Screen resolution
|
|
30
|
+
enum class ResolutionType : uint8_t {
|
|
31
|
+
UNKNOWN,
|
|
32
|
+
E480I,
|
|
33
|
+
E480P,
|
|
34
|
+
E720P50,
|
|
35
|
+
E720P60,
|
|
36
|
+
E1080P24,
|
|
37
|
+
E1080I50,
|
|
38
|
+
E1080P50,
|
|
39
|
+
E1080P60,
|
|
40
|
+
E2160P50,
|
|
41
|
+
E2160P60
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
// Client surface visibility
|
|
45
|
+
enum class VisiblityType : uint8_t {
|
|
46
|
+
VISIBLE,
|
|
47
|
+
HIDDEN
|
|
48
|
+
};
|
|
49
|
+
|
|
50
|
+
// Common classes
|
|
51
|
+
//
|
|
52
|
+
|
|
53
|
+
class PutontopParamsInfo : public Core::JSON::Container {
|
|
54
|
+
public:
|
|
55
|
+
PutontopParamsInfo()
|
|
56
|
+
: Core::JSON::Container()
|
|
57
|
+
{
|
|
58
|
+
Add(_T("client"), &Client);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
PutontopParamsInfo(const PutontopParamsInfo&) = delete;
|
|
62
|
+
PutontopParamsInfo(PutontopParamsInfo&&) noexcept = delete;
|
|
63
|
+
|
|
64
|
+
PutontopParamsInfo& operator=(const PutontopParamsInfo&) = delete;
|
|
65
|
+
PutontopParamsInfo& operator=(PutontopParamsInfo&&) noexcept = delete;
|
|
66
|
+
|
|
67
|
+
~PutontopParamsInfo() = default;
|
|
68
|
+
|
|
69
|
+
public:
|
|
70
|
+
bool IsDataValid() const
|
|
71
|
+
{
|
|
72
|
+
return (Client.IsSet() == true);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
public:
|
|
76
|
+
Core::JSON::String Client; // Client name
|
|
77
|
+
}; // class PutontopParamsInfo
|
|
78
|
+
|
|
79
|
+
// Method params/result classes
|
|
80
|
+
//
|
|
81
|
+
|
|
82
|
+
class GeometryData : public Core::JSON::Container {
|
|
83
|
+
public:
|
|
84
|
+
GeometryData()
|
|
85
|
+
: Core::JSON::Container()
|
|
86
|
+
{
|
|
87
|
+
Add(_T("x"), &X);
|
|
88
|
+
Add(_T("y"), &Y);
|
|
89
|
+
Add(_T("width"), &Width);
|
|
90
|
+
Add(_T("height"), &Height);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
GeometryData(const GeometryData&) = delete;
|
|
94
|
+
GeometryData(GeometryData&&) noexcept = delete;
|
|
95
|
+
|
|
96
|
+
GeometryData& operator=(const GeometryData&) = delete;
|
|
97
|
+
GeometryData& operator=(GeometryData&&) noexcept = delete;
|
|
98
|
+
|
|
99
|
+
~GeometryData() = default;
|
|
100
|
+
|
|
101
|
+
public:
|
|
102
|
+
bool IsDataValid() const
|
|
103
|
+
{
|
|
104
|
+
return ((X.IsSet() == true) && (Y.IsSet() == true) && (Width.IsSet() == true) && (Height.IsSet() == true));
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
public:
|
|
108
|
+
Core::JSON::DecUInt32 X; // Horizontal coordinate of the surface
|
|
109
|
+
Core::JSON::DecUInt32 Y; // Vertical coordinate of the surface
|
|
110
|
+
Core::JSON::DecUInt32 Width; // Surface width
|
|
111
|
+
Core::JSON::DecUInt32 Height; // Surface height
|
|
112
|
+
}; // class GeometryData
|
|
113
|
+
|
|
114
|
+
class PutbelowParamsData : public Core::JSON::Container {
|
|
115
|
+
public:
|
|
116
|
+
PutbelowParamsData()
|
|
117
|
+
: Core::JSON::Container()
|
|
118
|
+
{
|
|
119
|
+
Add(_T("client"), &Client);
|
|
120
|
+
Add(_T("relative"), &Relative);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
PutbelowParamsData(const PutbelowParamsData&) = delete;
|
|
124
|
+
PutbelowParamsData(PutbelowParamsData&&) noexcept = delete;
|
|
125
|
+
|
|
126
|
+
PutbelowParamsData& operator=(const PutbelowParamsData&) = delete;
|
|
127
|
+
PutbelowParamsData& operator=(PutbelowParamsData&&) noexcept = delete;
|
|
128
|
+
|
|
129
|
+
~PutbelowParamsData() = default;
|
|
130
|
+
|
|
131
|
+
public:
|
|
132
|
+
bool IsDataValid() const
|
|
133
|
+
{
|
|
134
|
+
return ((Client.IsSet() == true) && (Relative.IsSet() == true));
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
public:
|
|
138
|
+
Core::JSON::String Client; // Client name to change z-order position
|
|
139
|
+
Core::JSON::String Relative; // Client to put the other surface below
|
|
140
|
+
}; // class PutbelowParamsData
|
|
141
|
+
|
|
142
|
+
} // namespace Compositor
|
|
143
|
+
|
|
144
|
+
POP_WARNING()
|
|
145
|
+
|
|
146
|
+
} // namespace JsonData
|
|
147
|
+
|
|
148
|
+
// Enum conversion handlers
|
|
149
|
+
ENUM_CONVERSION_HANDLER(JsonData::Compositor::ResolutionType)
|
|
150
|
+
ENUM_CONVERSION_HANDLER(JsonData::Compositor::BrightnessType)
|
|
151
|
+
ENUM_CONVERSION_HANDLER(JsonData::Compositor::VisiblityType)
|
|
152
|
+
|
|
153
|
+
}
|
|
154
|
+
|
|
@@ -0,0 +1,113 @@
|
|
|
1
|
+
// C++ types for ConnectionProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDisplayInfo.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ConnectionProperties {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class EDIDParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
EDIDParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("length"), &Length);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
EDIDParamsData(const EDIDParamsData&) = delete;
|
|
31
|
+
EDIDParamsData(EDIDParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
EDIDParamsData& operator=(const EDIDParamsData&) = delete;
|
|
34
|
+
EDIDParamsData& operator=(EDIDParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~EDIDParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Length.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecUInt16 Length; // Length of EDID byte string
|
|
46
|
+
}; // class EDIDParamsData
|
|
47
|
+
|
|
48
|
+
class EDIDResultData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
EDIDResultData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("length"), &Length);
|
|
54
|
+
Add(_T("data"), &Data);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
EDIDResultData(const EDIDResultData&) = delete;
|
|
58
|
+
EDIDResultData(EDIDResultData&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
EDIDResultData& operator=(const EDIDResultData&) = delete;
|
|
61
|
+
EDIDResultData& operator=(EDIDResultData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~EDIDResultData() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return ((Length.IsSet() == true) && (Data.IsSet() == true));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::DecUInt16 Length; // Length of EDID byte string
|
|
73
|
+
Core::JSON::String Data; // EDID byte string
|
|
74
|
+
}; // class EDIDResultData
|
|
75
|
+
|
|
76
|
+
class UpdatedParamsData : public Core::JSON::Container {
|
|
77
|
+
public:
|
|
78
|
+
UpdatedParamsData()
|
|
79
|
+
: Core::JSON::Container()
|
|
80
|
+
{
|
|
81
|
+
Add(_T("event"), &Event);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
UpdatedParamsData(const UpdatedParamsData&) = delete;
|
|
85
|
+
UpdatedParamsData(UpdatedParamsData&&) noexcept = delete;
|
|
86
|
+
|
|
87
|
+
UpdatedParamsData& operator=(const UpdatedParamsData&) = delete;
|
|
88
|
+
UpdatedParamsData& operator=(UpdatedParamsData&&) noexcept = delete;
|
|
89
|
+
|
|
90
|
+
~UpdatedParamsData() = default;
|
|
91
|
+
|
|
92
|
+
public:
|
|
93
|
+
bool IsDataValid() const
|
|
94
|
+
{
|
|
95
|
+
return (Event.IsSet() == true);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
Core::JSON::EnumType<Exchange::IConnectionProperties::INotification::Source> Event; // Source of this event
|
|
100
|
+
}; // class UpdatedParamsData
|
|
101
|
+
|
|
102
|
+
} // namespace ConnectionProperties
|
|
103
|
+
|
|
104
|
+
POP_WARNING()
|
|
105
|
+
|
|
106
|
+
} // namespace JsonData
|
|
107
|
+
|
|
108
|
+
// Enum conversion handlers
|
|
109
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::HDCPProtectionType)
|
|
110
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::INotification::Source)
|
|
111
|
+
|
|
112
|
+
}
|
|
113
|
+
|
|
@@ -0,0 +1,200 @@
|
|
|
1
|
+
// C++ types for Process Containers.
|
|
2
|
+
// Generated automatically from 'Containers.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Containers {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class CpuData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
CpuData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("total"), &Total);
|
|
27
|
+
Add(_T("cores"), &Cores);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
CpuData(const CpuData&) = delete;
|
|
31
|
+
CpuData(CpuData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
CpuData& operator=(const CpuData&) = delete;
|
|
34
|
+
CpuData& operator=(CpuData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~CpuData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return ((Total.IsSet() == true) && (Cores.IsSet() == true));
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecUInt64 Total; // CPU-time spent on container, in nanoseconds
|
|
46
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt64> Cores; // Time spent on each cpu core, in nanoseconds
|
|
47
|
+
}; // class CpuData
|
|
48
|
+
|
|
49
|
+
class MemoryData : public Core::JSON::Container {
|
|
50
|
+
public:
|
|
51
|
+
MemoryData()
|
|
52
|
+
: Core::JSON::Container()
|
|
53
|
+
{
|
|
54
|
+
Add(_T("allocated"), &Allocated);
|
|
55
|
+
Add(_T("resident"), &Resident);
|
|
56
|
+
Add(_T("shared"), &Shared);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
MemoryData(const MemoryData&) = delete;
|
|
60
|
+
MemoryData(MemoryData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
MemoryData& operator=(const MemoryData&) = delete;
|
|
63
|
+
MemoryData& operator=(MemoryData&&) noexcept = delete;
|
|
64
|
+
|
|
65
|
+
~MemoryData() = default;
|
|
66
|
+
|
|
67
|
+
public:
|
|
68
|
+
bool IsDataValid() const
|
|
69
|
+
{
|
|
70
|
+
return ((Allocated.IsSet() == true) && (Resident.IsSet() == true) && (Shared.IsSet() == true));
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
Core::JSON::DecUInt64 Allocated; // Memory allocated by container
|
|
75
|
+
Core::JSON::DecUInt64 Resident; // Resident memory of the container
|
|
76
|
+
Core::JSON::DecUInt64 Shared; // Shared memory in the container
|
|
77
|
+
}; // class MemoryData
|
|
78
|
+
|
|
79
|
+
class NetworksResultDataElem : public Core::JSON::Container {
|
|
80
|
+
public:
|
|
81
|
+
NetworksResultDataElem()
|
|
82
|
+
: Core::JSON::Container()
|
|
83
|
+
{
|
|
84
|
+
_Init();
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
NetworksResultDataElem(const NetworksResultDataElem& _other)
|
|
88
|
+
: Core::JSON::Container()
|
|
89
|
+
, Interface(_other.Interface)
|
|
90
|
+
, Ips(_other.Ips)
|
|
91
|
+
{
|
|
92
|
+
_Init();
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
NetworksResultDataElem(NetworksResultDataElem&& _other) noexcept
|
|
96
|
+
: Core::JSON::Container()
|
|
97
|
+
, Interface(std::move(_other.Interface))
|
|
98
|
+
, Ips(std::move(_other.Ips))
|
|
99
|
+
{
|
|
100
|
+
_Init();
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
NetworksResultDataElem& operator=(const NetworksResultDataElem& _rhs)
|
|
104
|
+
{
|
|
105
|
+
Interface = _rhs.Interface;
|
|
106
|
+
Ips = _rhs.Ips;
|
|
107
|
+
return (*this);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
NetworksResultDataElem& operator=(NetworksResultDataElem&& _rhs) noexcept
|
|
111
|
+
{
|
|
112
|
+
Interface = std::move(_rhs.Interface);
|
|
113
|
+
Ips = std::move(_rhs.Ips);
|
|
114
|
+
return (*this);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
~NetworksResultDataElem() = default;
|
|
118
|
+
|
|
119
|
+
public:
|
|
120
|
+
bool IsDataValid() const
|
|
121
|
+
{
|
|
122
|
+
return ((Interface.IsSet() == true) && (Ips.IsSet() == true));
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
private:
|
|
126
|
+
void _Init()
|
|
127
|
+
{
|
|
128
|
+
Add(_T("interface"), &Interface);
|
|
129
|
+
Add(_T("ips"), &Ips);
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
public:
|
|
133
|
+
Core::JSON::String Interface; // Interface name
|
|
134
|
+
Core::JSON::ArrayType<Core::JSON::String> Ips; // List of ip addresses
|
|
135
|
+
}; // class NetworksResultDataElem
|
|
136
|
+
|
|
137
|
+
class StartParamsData : public Core::JSON::Container {
|
|
138
|
+
public:
|
|
139
|
+
StartParamsData()
|
|
140
|
+
: Core::JSON::Container()
|
|
141
|
+
{
|
|
142
|
+
Add(_T("name"), &Name);
|
|
143
|
+
Add(_T("command"), &Command);
|
|
144
|
+
Add(_T("parameters"), &Parameters);
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
StartParamsData(const StartParamsData&) = delete;
|
|
148
|
+
StartParamsData(StartParamsData&&) noexcept = delete;
|
|
149
|
+
|
|
150
|
+
StartParamsData& operator=(const StartParamsData&) = delete;
|
|
151
|
+
StartParamsData& operator=(StartParamsData&&) noexcept = delete;
|
|
152
|
+
|
|
153
|
+
~StartParamsData() = default;
|
|
154
|
+
|
|
155
|
+
public:
|
|
156
|
+
bool IsDataValid() const
|
|
157
|
+
{
|
|
158
|
+
return ((Name.IsSet() == true) && (Command.IsSet() == true) && (Parameters.IsSet() == true));
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
public:
|
|
162
|
+
Core::JSON::String Name; // Name of container
|
|
163
|
+
Core::JSON::String Command; // Command that will be started in the container
|
|
164
|
+
Core::JSON::ArrayType<Core::JSON::String> Parameters; // List of parameters supplied to command
|
|
165
|
+
}; // class StartParamsData
|
|
166
|
+
|
|
167
|
+
class StopParamsData : public Core::JSON::Container {
|
|
168
|
+
public:
|
|
169
|
+
StopParamsData()
|
|
170
|
+
: Core::JSON::Container()
|
|
171
|
+
{
|
|
172
|
+
Add(_T("name"), &Name);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
StopParamsData(const StopParamsData&) = delete;
|
|
176
|
+
StopParamsData(StopParamsData&&) noexcept = delete;
|
|
177
|
+
|
|
178
|
+
StopParamsData& operator=(const StopParamsData&) = delete;
|
|
179
|
+
StopParamsData& operator=(StopParamsData&&) noexcept = delete;
|
|
180
|
+
|
|
181
|
+
~StopParamsData() = default;
|
|
182
|
+
|
|
183
|
+
public:
|
|
184
|
+
bool IsDataValid() const
|
|
185
|
+
{
|
|
186
|
+
return (Name.IsSet() == true);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
public:
|
|
190
|
+
Core::JSON::String Name; // Name of container
|
|
191
|
+
}; // class StopParamsData
|
|
192
|
+
|
|
193
|
+
} // namespace Containers
|
|
194
|
+
|
|
195
|
+
POP_WARNING()
|
|
196
|
+
|
|
197
|
+
} // namespace JsonData
|
|
198
|
+
|
|
199
|
+
}
|
|
200
|
+
|
|
@@ -0,0 +1,351 @@
|
|
|
1
|
+
// C++ types for ContentProtection API.
|
|
2
|
+
// Generated automatically from 'IContentProtection.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IContentProtection.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ContentProtection {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class CloseDrmSessionParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
CloseDrmSessionParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("sessionId"), &SessionId);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
CloseDrmSessionParamsData(const CloseDrmSessionParamsData&) = delete;
|
|
31
|
+
CloseDrmSessionParamsData(CloseDrmSessionParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
CloseDrmSessionParamsData& operator=(const CloseDrmSessionParamsData&) = delete;
|
|
34
|
+
CloseDrmSessionParamsData& operator=(CloseDrmSessionParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~CloseDrmSessionParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (SessionId.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String SessionId; // sec manager generated playback session id
|
|
46
|
+
}; // class CloseDrmSessionParamsData
|
|
47
|
+
|
|
48
|
+
class OpenDrmSessionParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
OpenDrmSessionParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("clientId"), &ClientId);
|
|
54
|
+
Add(_T("appId"), &AppId);
|
|
55
|
+
Add(_T("keySystem"), &KeySystem);
|
|
56
|
+
Add(_T("licenseRequest"), &LicenseRequest);
|
|
57
|
+
Add(_T("initData"), &InitData);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
OpenDrmSessionParamsData(const OpenDrmSessionParamsData&) = delete;
|
|
61
|
+
OpenDrmSessionParamsData(OpenDrmSessionParamsData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
OpenDrmSessionParamsData& operator=(const OpenDrmSessionParamsData&) = delete;
|
|
64
|
+
OpenDrmSessionParamsData& operator=(OpenDrmSessionParamsData&&) noexcept = delete;
|
|
65
|
+
|
|
66
|
+
~OpenDrmSessionParamsData() = default;
|
|
67
|
+
|
|
68
|
+
public:
|
|
69
|
+
bool IsDataValid() const
|
|
70
|
+
{
|
|
71
|
+
return ((ClientId.IsSet() == true) && (AppId.IsSet() == true) && (KeySystem.IsSet() == true) && (LicenseRequest.IsSet() == true) && (InitData.IsSet() == true));
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
public:
|
|
75
|
+
Core::JSON::String ClientId; // client that establishes the playback session
|
|
76
|
+
Core::JSON::String AppId; // application requesting the new watermarking session
|
|
77
|
+
Core::JSON::EnumType<Exchange::IContentProtection::KeySystem> KeySystem;
|
|
78
|
+
Core::JSON::String LicenseRequest; // base64-encoded DRM license request
|
|
79
|
+
Core::JSON::String InitData; // video platform specific init data
|
|
80
|
+
}; // class OpenDrmSessionParamsData
|
|
81
|
+
|
|
82
|
+
class OpenDrmSessionResultData : public Core::JSON::Container {
|
|
83
|
+
public:
|
|
84
|
+
OpenDrmSessionResultData()
|
|
85
|
+
: Core::JSON::Container()
|
|
86
|
+
{
|
|
87
|
+
Add(_T("sessionId"), &SessionId);
|
|
88
|
+
Add(_T("openSessionResponse"), &Response);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
OpenDrmSessionResultData(const OpenDrmSessionResultData&) = delete;
|
|
92
|
+
OpenDrmSessionResultData(OpenDrmSessionResultData&&) noexcept = delete;
|
|
93
|
+
|
|
94
|
+
OpenDrmSessionResultData& operator=(const OpenDrmSessionResultData&) = delete;
|
|
95
|
+
OpenDrmSessionResultData& operator=(OpenDrmSessionResultData&&) noexcept = delete;
|
|
96
|
+
|
|
97
|
+
~OpenDrmSessionResultData() = default;
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
bool IsDataValid() const
|
|
101
|
+
{
|
|
102
|
+
return ((SessionId.IsSet() == true) && (Response.IsSet() == true));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
public:
|
|
106
|
+
Core::JSON::String SessionId; // generated by SecManager to track sessions
|
|
107
|
+
Core::JSON::String Response; // video platform specific response data
|
|
108
|
+
}; // class OpenDrmSessionResultData
|
|
109
|
+
|
|
110
|
+
class SetDrmSessionStateParamsData : public Core::JSON::Container {
|
|
111
|
+
public:
|
|
112
|
+
SetDrmSessionStateParamsData()
|
|
113
|
+
: Core::JSON::Container()
|
|
114
|
+
{
|
|
115
|
+
Add(_T("sessionId"), &SessionId);
|
|
116
|
+
Add(_T("sessionState"), &SessionState);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
SetDrmSessionStateParamsData(const SetDrmSessionStateParamsData&) = delete;
|
|
120
|
+
SetDrmSessionStateParamsData(SetDrmSessionStateParamsData&&) noexcept = delete;
|
|
121
|
+
|
|
122
|
+
SetDrmSessionStateParamsData& operator=(const SetDrmSessionStateParamsData&) = delete;
|
|
123
|
+
SetDrmSessionStateParamsData& operator=(SetDrmSessionStateParamsData&&) noexcept = delete;
|
|
124
|
+
|
|
125
|
+
~SetDrmSessionStateParamsData() = default;
|
|
126
|
+
|
|
127
|
+
public:
|
|
128
|
+
bool IsDataValid() const
|
|
129
|
+
{
|
|
130
|
+
return ((SessionId.IsSet() == true) && (SessionState.IsSet() == true));
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
public:
|
|
134
|
+
Core::JSON::String SessionId; // sec manager generated playback session id
|
|
135
|
+
Core::JSON::EnumType<Exchange::IContentProtection::State> SessionState;
|
|
136
|
+
}; // class SetDrmSessionStateParamsData
|
|
137
|
+
|
|
138
|
+
class SetPlaybackPositionParamsData : public Core::JSON::Container {
|
|
139
|
+
public:
|
|
140
|
+
SetPlaybackPositionParamsData()
|
|
141
|
+
: Core::JSON::Container()
|
|
142
|
+
{
|
|
143
|
+
Add(_T("sessionId"), &SessionId);
|
|
144
|
+
Add(_T("speed"), &Speed);
|
|
145
|
+
Add(_T("position"), &Position);
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
SetPlaybackPositionParamsData(const SetPlaybackPositionParamsData&) = delete;
|
|
149
|
+
SetPlaybackPositionParamsData(SetPlaybackPositionParamsData&&) noexcept = delete;
|
|
150
|
+
|
|
151
|
+
SetPlaybackPositionParamsData& operator=(const SetPlaybackPositionParamsData&) = delete;
|
|
152
|
+
SetPlaybackPositionParamsData& operator=(SetPlaybackPositionParamsData&&) noexcept = delete;
|
|
153
|
+
|
|
154
|
+
~SetPlaybackPositionParamsData() = default;
|
|
155
|
+
|
|
156
|
+
public:
|
|
157
|
+
bool IsDataValid() const
|
|
158
|
+
{
|
|
159
|
+
return ((SessionId.IsSet() == true) && (Speed.IsSet() == true) && (Position.IsSet() == true));
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
public:
|
|
163
|
+
Core::JSON::String SessionId; // sec manager generated playback session id
|
|
164
|
+
Core::JSON::DecSInt32 Speed; // current playback speed
|
|
165
|
+
Core::JSON::DecSInt32 Position; // current playback position
|
|
166
|
+
}; // class SetPlaybackPositionParamsData
|
|
167
|
+
|
|
168
|
+
class ShowWatermarkParamsData : public Core::JSON::Container {
|
|
169
|
+
public:
|
|
170
|
+
ShowWatermarkParamsData()
|
|
171
|
+
: Core::JSON::Container()
|
|
172
|
+
{
|
|
173
|
+
Add(_T("sessionId"), &SessionId);
|
|
174
|
+
Add(_T("show"), &Show);
|
|
175
|
+
Add(_T("opacityLevel"), &OpacityLevel);
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
ShowWatermarkParamsData(const ShowWatermarkParamsData&) = delete;
|
|
179
|
+
ShowWatermarkParamsData(ShowWatermarkParamsData&&) noexcept = delete;
|
|
180
|
+
|
|
181
|
+
ShowWatermarkParamsData& operator=(const ShowWatermarkParamsData&) = delete;
|
|
182
|
+
ShowWatermarkParamsData& operator=(ShowWatermarkParamsData&&) noexcept = delete;
|
|
183
|
+
|
|
184
|
+
~ShowWatermarkParamsData() = default;
|
|
185
|
+
|
|
186
|
+
public:
|
|
187
|
+
bool IsDataValid() const
|
|
188
|
+
{
|
|
189
|
+
return ((SessionId.IsSet() == true) && (Show.IsSet() == true) && (((OpacityLevel.IsSet() == true) && (OpacityLevel.Value() <= 100))));
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
public:
|
|
193
|
+
Core::JSON::String SessionId; // id returned on a call to openDrmSession
|
|
194
|
+
Core::JSON::Boolean Show; // true when watermark has to be presented
|
|
195
|
+
Core::JSON::DecUInt8 OpacityLevel;
|
|
196
|
+
}; // class ShowWatermarkParamsData
|
|
197
|
+
|
|
198
|
+
class UpdateDrmSessionParamsData : public Core::JSON::Container {
|
|
199
|
+
public:
|
|
200
|
+
UpdateDrmSessionParamsData()
|
|
201
|
+
: Core::JSON::Container()
|
|
202
|
+
{
|
|
203
|
+
Add(_T("sessionId"), &SessionId);
|
|
204
|
+
Add(_T("licenseRequest"), &LicenseRequest);
|
|
205
|
+
Add(_T("initData"), &InitData);
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
UpdateDrmSessionParamsData(const UpdateDrmSessionParamsData&) = delete;
|
|
209
|
+
UpdateDrmSessionParamsData(UpdateDrmSessionParamsData&&) noexcept = delete;
|
|
210
|
+
|
|
211
|
+
UpdateDrmSessionParamsData& operator=(const UpdateDrmSessionParamsData&) = delete;
|
|
212
|
+
UpdateDrmSessionParamsData& operator=(UpdateDrmSessionParamsData&&) noexcept = delete;
|
|
213
|
+
|
|
214
|
+
~UpdateDrmSessionParamsData() = default;
|
|
215
|
+
|
|
216
|
+
public:
|
|
217
|
+
bool IsDataValid() const
|
|
218
|
+
{
|
|
219
|
+
return ((SessionId.IsSet() == true) && (LicenseRequest.IsSet() == true) && (InitData.IsSet() == true));
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
public:
|
|
223
|
+
Core::JSON::String SessionId; // sec manager generated playback session id
|
|
224
|
+
Core::JSON::String LicenseRequest; // base64-encoded DRM license request
|
|
225
|
+
Core::JSON::String InitData; // video platform specific init data
|
|
226
|
+
}; // class UpdateDrmSessionParamsData
|
|
227
|
+
|
|
228
|
+
class WatermarkStatusChangedParamsData : public Core::JSON::Container {
|
|
229
|
+
public:
|
|
230
|
+
class StatusData : public Core::JSON::Container {
|
|
231
|
+
public:
|
|
232
|
+
StatusData()
|
|
233
|
+
: Core::JSON::Container()
|
|
234
|
+
{
|
|
235
|
+
_Init();
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
StatusData(const StatusData& _other)
|
|
239
|
+
: Core::JSON::Container()
|
|
240
|
+
, State(_other.State)
|
|
241
|
+
, FailureReason(_other.FailureReason)
|
|
242
|
+
{
|
|
243
|
+
_Init();
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
StatusData(StatusData&& _other) noexcept
|
|
247
|
+
: Core::JSON::Container()
|
|
248
|
+
, State(std::move(_other.State))
|
|
249
|
+
, FailureReason(std::move(_other.FailureReason))
|
|
250
|
+
{
|
|
251
|
+
_Init();
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
StatusData(const Exchange::IContentProtection::INotification::Status& _other)
|
|
255
|
+
: Core::JSON::Container()
|
|
256
|
+
{
|
|
257
|
+
State = _other.state;
|
|
258
|
+
FailureReason = _other.failureReason;
|
|
259
|
+
_Init();
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
StatusData& operator=(const StatusData& _rhs)
|
|
263
|
+
{
|
|
264
|
+
State = _rhs.State;
|
|
265
|
+
FailureReason = _rhs.FailureReason;
|
|
266
|
+
return (*this);
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
StatusData& operator=(StatusData&& _rhs) noexcept
|
|
270
|
+
{
|
|
271
|
+
State = std::move(_rhs.State);
|
|
272
|
+
FailureReason = std::move(_rhs.FailureReason);
|
|
273
|
+
return (*this);
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
StatusData& operator=(const Exchange::IContentProtection::INotification::Status& _rhs)
|
|
277
|
+
{
|
|
278
|
+
State = _rhs.state;
|
|
279
|
+
FailureReason = _rhs.failureReason;
|
|
280
|
+
return (*this);
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
operator Exchange::IContentProtection::INotification::Status() const
|
|
284
|
+
{
|
|
285
|
+
Exchange::IContentProtection::INotification::Status _value{};
|
|
286
|
+
_value.state = State;
|
|
287
|
+
_value.failureReason = FailureReason;
|
|
288
|
+
return (_value);
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
~StatusData() = default;
|
|
292
|
+
|
|
293
|
+
public:
|
|
294
|
+
bool IsDataValid() const
|
|
295
|
+
{
|
|
296
|
+
return ((State.IsSet() == true) && (FailureReason.IsSet() == true));
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
private:
|
|
300
|
+
void _Init()
|
|
301
|
+
{
|
|
302
|
+
Add(_T("state"), &State);
|
|
303
|
+
Add(_T("failureReason"), &FailureReason);
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
public:
|
|
307
|
+
Core::JSON::EnumType<Exchange::IContentProtection::INotification::Status::State> State;
|
|
308
|
+
Core::JSON::DecSInt32 FailureReason; // same as that returned by the SecManager. For other cases greater than 20000
|
|
309
|
+
}; // class StatusData
|
|
310
|
+
|
|
311
|
+
WatermarkStatusChangedParamsData()
|
|
312
|
+
: Core::JSON::Container()
|
|
313
|
+
{
|
|
314
|
+
Add(_T("sessionId"), &SessionId);
|
|
315
|
+
Add(_T("appId"), &AppId);
|
|
316
|
+
Add(_T("status"), &Status);
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
WatermarkStatusChangedParamsData(const WatermarkStatusChangedParamsData&) = delete;
|
|
320
|
+
WatermarkStatusChangedParamsData(WatermarkStatusChangedParamsData&&) noexcept = delete;
|
|
321
|
+
|
|
322
|
+
WatermarkStatusChangedParamsData& operator=(const WatermarkStatusChangedParamsData&) = delete;
|
|
323
|
+
WatermarkStatusChangedParamsData& operator=(WatermarkStatusChangedParamsData&&) noexcept = delete;
|
|
324
|
+
|
|
325
|
+
~WatermarkStatusChangedParamsData() = default;
|
|
326
|
+
|
|
327
|
+
public:
|
|
328
|
+
bool IsDataValid() const
|
|
329
|
+
{
|
|
330
|
+
return ((SessionId.IsSet() == true) && (AppId.IsSet() == true) && ((Status.IsSet() == true) && (Status.IsDataValid() == true)));
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
public:
|
|
334
|
+
Core::JSON::String SessionId; // session id for the content protection session
|
|
335
|
+
Core::JSON::String AppId; // application that should receive the notification
|
|
336
|
+
WatermarkStatusChangedParamsData::StatusData Status;
|
|
337
|
+
}; // class WatermarkStatusChangedParamsData
|
|
338
|
+
|
|
339
|
+
} // namespace ContentProtection
|
|
340
|
+
|
|
341
|
+
POP_WARNING()
|
|
342
|
+
|
|
343
|
+
} // namespace JsonData
|
|
344
|
+
|
|
345
|
+
// Enum conversion handlers
|
|
346
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::KeySystem)
|
|
347
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::State)
|
|
348
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::INotification::Status::State)
|
|
349
|
+
|
|
350
|
+
}
|
|
351
|
+
|
|
@@ -0,0 +1,211 @@
|
|
|
1
|
+
// C++ types for DHCP Server API.
|
|
2
|
+
// Generated automatically from 'DHCPServer.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace DHCPServer {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class ActivateParamsInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
ActivateParamsInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("interface"), &Interface);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
ActivateParamsInfo(const ActivateParamsInfo&) = delete;
|
|
30
|
+
ActivateParamsInfo(ActivateParamsInfo&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
ActivateParamsInfo& operator=(const ActivateParamsInfo&) = delete;
|
|
33
|
+
ActivateParamsInfo& operator=(ActivateParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~ActivateParamsInfo() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (Interface.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Interface; // Network interface name
|
|
45
|
+
}; // class ActivateParamsInfo
|
|
46
|
+
|
|
47
|
+
// Method params/result classes
|
|
48
|
+
//
|
|
49
|
+
|
|
50
|
+
class ServerData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
class LeaseData : public Core::JSON::Container {
|
|
53
|
+
public:
|
|
54
|
+
LeaseData()
|
|
55
|
+
: Core::JSON::Container()
|
|
56
|
+
{
|
|
57
|
+
_Init();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
LeaseData(const LeaseData& _other)
|
|
61
|
+
: Core::JSON::Container()
|
|
62
|
+
, Name(_other.Name)
|
|
63
|
+
, Ip(_other.Ip)
|
|
64
|
+
, Expires(_other.Expires)
|
|
65
|
+
{
|
|
66
|
+
_Init();
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
LeaseData(LeaseData&& _other) noexcept
|
|
70
|
+
: Core::JSON::Container()
|
|
71
|
+
, Name(std::move(_other.Name))
|
|
72
|
+
, Ip(std::move(_other.Ip))
|
|
73
|
+
, Expires(std::move(_other.Expires))
|
|
74
|
+
{
|
|
75
|
+
_Init();
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
LeaseData& operator=(const LeaseData& _rhs)
|
|
79
|
+
{
|
|
80
|
+
Name = _rhs.Name;
|
|
81
|
+
Ip = _rhs.Ip;
|
|
82
|
+
if (_rhs.Expires.Value().empty() == false) {
|
|
83
|
+
Expires = _rhs.Expires;
|
|
84
|
+
}
|
|
85
|
+
return (*this);
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
LeaseData& operator=(LeaseData&& _rhs) noexcept
|
|
89
|
+
{
|
|
90
|
+
Name = std::move(_rhs.Name);
|
|
91
|
+
Ip = std::move(_rhs.Ip);
|
|
92
|
+
Expires = std::move(_rhs.Expires);
|
|
93
|
+
return (*this);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
~LeaseData() = default;
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
bool IsDataValid() const
|
|
100
|
+
{
|
|
101
|
+
return ((Name.IsSet() == true) && (Ip.IsSet() == true));
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
private:
|
|
105
|
+
void _Init()
|
|
106
|
+
{
|
|
107
|
+
Add(_T("name"), &Name);
|
|
108
|
+
Add(_T("ip"), &Ip);
|
|
109
|
+
Add(_T("expires"), &Expires);
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
public:
|
|
113
|
+
Core::JSON::String Name; // Client identifier (or client hardware address if identifier is absent)
|
|
114
|
+
Core::JSON::String Ip; // Client IP address
|
|
115
|
+
Core::JSON::String Expires; // Client IP expiration time (in ISO8601 format, empty: never expires)
|
|
116
|
+
}; // class LeaseData
|
|
117
|
+
|
|
118
|
+
ServerData()
|
|
119
|
+
: Core::JSON::Container()
|
|
120
|
+
{
|
|
121
|
+
_Init();
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
ServerData(const ServerData& _other)
|
|
125
|
+
: Core::JSON::Container()
|
|
126
|
+
, Interface(_other.Interface)
|
|
127
|
+
, Active(_other.Active)
|
|
128
|
+
, Begin(_other.Begin)
|
|
129
|
+
, End(_other.End)
|
|
130
|
+
, Router(_other.Router)
|
|
131
|
+
, Leases(_other.Leases)
|
|
132
|
+
{
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
ServerData(ServerData&& _other) noexcept
|
|
137
|
+
: Core::JSON::Container()
|
|
138
|
+
, Interface(std::move(_other.Interface))
|
|
139
|
+
, Active(std::move(_other.Active))
|
|
140
|
+
, Begin(std::move(_other.Begin))
|
|
141
|
+
, End(std::move(_other.End))
|
|
142
|
+
, Router(std::move(_other.Router))
|
|
143
|
+
, Leases(std::move(_other.Leases))
|
|
144
|
+
{
|
|
145
|
+
_Init();
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
ServerData& operator=(const ServerData& _rhs)
|
|
149
|
+
{
|
|
150
|
+
Interface = _rhs.Interface;
|
|
151
|
+
Active = _rhs.Active;
|
|
152
|
+
if (_rhs.Begin.Value().empty() == false) {
|
|
153
|
+
Begin = _rhs.Begin;
|
|
154
|
+
}
|
|
155
|
+
if (_rhs.End.Value().empty() == false) {
|
|
156
|
+
End = _rhs.End;
|
|
157
|
+
}
|
|
158
|
+
if (_rhs.Router.Value().empty() == false) {
|
|
159
|
+
Router = _rhs.Router;
|
|
160
|
+
}
|
|
161
|
+
Leases = _rhs.Leases;
|
|
162
|
+
return (*this);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
ServerData& operator=(ServerData&& _rhs) noexcept
|
|
166
|
+
{
|
|
167
|
+
Interface = std::move(_rhs.Interface);
|
|
168
|
+
Active = std::move(_rhs.Active);
|
|
169
|
+
Begin = std::move(_rhs.Begin);
|
|
170
|
+
End = std::move(_rhs.End);
|
|
171
|
+
Router = std::move(_rhs.Router);
|
|
172
|
+
Leases = std::move(_rhs.Leases);
|
|
173
|
+
return (*this);
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
~ServerData() = default;
|
|
177
|
+
|
|
178
|
+
public:
|
|
179
|
+
bool IsDataValid() const
|
|
180
|
+
{
|
|
181
|
+
return ((Interface.IsSet() == true) && (Active.IsSet() == true));
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
private:
|
|
185
|
+
void _Init()
|
|
186
|
+
{
|
|
187
|
+
Add(_T("interface"), &Interface);
|
|
188
|
+
Add(_T("active"), &Active);
|
|
189
|
+
Add(_T("begin"), &Begin);
|
|
190
|
+
Add(_T("end"), &End);
|
|
191
|
+
Add(_T("router"), &Router);
|
|
192
|
+
Add(_T("leases"), &Leases);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
public:
|
|
196
|
+
Core::JSON::String Interface; // Network interface name
|
|
197
|
+
Core::JSON::Boolean Active; // Denotes if server is currently active
|
|
198
|
+
Core::JSON::String Begin; // IP address pool start
|
|
199
|
+
Core::JSON::String End; // IP address pool end
|
|
200
|
+
Core::JSON::String Router; // Router IP address
|
|
201
|
+
Core::JSON::ArrayType<ServerData::LeaseData> Leases; // List of IP address leases
|
|
202
|
+
}; // class ServerData
|
|
203
|
+
|
|
204
|
+
} // namespace DHCPServer
|
|
205
|
+
|
|
206
|
+
POP_WARNING()
|
|
207
|
+
|
|
208
|
+
} // namespace JsonData
|
|
209
|
+
|
|
210
|
+
}
|
|
211
|
+
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
// C++ types for DIAL Server API.
|
|
2
|
+
// Generated automatically from 'DIALServer.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DIALServer {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Current application running state
|
|
23
|
+
enum class StateType : uint8_t {
|
|
24
|
+
STOPPED,
|
|
25
|
+
STARTED,
|
|
26
|
+
HIDDEN
|
|
27
|
+
};
|
|
28
|
+
|
|
29
|
+
// Common classes
|
|
30
|
+
//
|
|
31
|
+
|
|
32
|
+
class HideParamsInfo : public Core::JSON::Container {
|
|
33
|
+
public:
|
|
34
|
+
HideParamsInfo()
|
|
35
|
+
: Core::JSON::Container()
|
|
36
|
+
{
|
|
37
|
+
Add(_T("application"), &Application);
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
HideParamsInfo(const HideParamsInfo&) = delete;
|
|
41
|
+
HideParamsInfo(HideParamsInfo&&) noexcept = delete;
|
|
42
|
+
|
|
43
|
+
HideParamsInfo& operator=(const HideParamsInfo&) = delete;
|
|
44
|
+
HideParamsInfo& operator=(HideParamsInfo&&) noexcept = delete;
|
|
45
|
+
|
|
46
|
+
~HideParamsInfo() = default;
|
|
47
|
+
|
|
48
|
+
public:
|
|
49
|
+
bool IsDataValid() const
|
|
50
|
+
{
|
|
51
|
+
return (Application.IsSet() == true);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
public:
|
|
55
|
+
Core::JSON::String Application; // Application name
|
|
56
|
+
}; // class HideParamsInfo
|
|
57
|
+
|
|
58
|
+
// Method params/result classes
|
|
59
|
+
//
|
|
60
|
+
|
|
61
|
+
class StartParamsData : public Core::JSON::Container {
|
|
62
|
+
public:
|
|
63
|
+
StartParamsData()
|
|
64
|
+
: Core::JSON::Container()
|
|
65
|
+
{
|
|
66
|
+
Add(_T("application"), &Application);
|
|
67
|
+
Add(_T("parameters"), &Parameters);
|
|
68
|
+
Add(_T("payload"), &Payload);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
StartParamsData(const StartParamsData&) = delete;
|
|
72
|
+
StartParamsData(StartParamsData&&) noexcept = delete;
|
|
73
|
+
|
|
74
|
+
StartParamsData& operator=(const StartParamsData&) = delete;
|
|
75
|
+
StartParamsData& operator=(StartParamsData&&) noexcept = delete;
|
|
76
|
+
|
|
77
|
+
~StartParamsData() = default;
|
|
78
|
+
|
|
79
|
+
public:
|
|
80
|
+
bool IsDataValid() const
|
|
81
|
+
{
|
|
82
|
+
return (Application.IsSet() == true);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
public:
|
|
86
|
+
Core::JSON::String Application; // Application name
|
|
87
|
+
Core::JSON::String Parameters; // Additional application-specific parameters
|
|
88
|
+
Core::JSON::String Payload; // Additional application-specific payload
|
|
89
|
+
}; // class StartParamsData
|
|
90
|
+
|
|
91
|
+
class StopParamsData : public Core::JSON::Container {
|
|
92
|
+
public:
|
|
93
|
+
StopParamsData()
|
|
94
|
+
: Core::JSON::Container()
|
|
95
|
+
{
|
|
96
|
+
Add(_T("application"), &Application);
|
|
97
|
+
Add(_T("parameters"), &Parameters);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
StopParamsData(const StopParamsData&) = delete;
|
|
101
|
+
StopParamsData(StopParamsData&&) noexcept = delete;
|
|
102
|
+
|
|
103
|
+
StopParamsData& operator=(const StopParamsData&) = delete;
|
|
104
|
+
StopParamsData& operator=(StopParamsData&&) noexcept = delete;
|
|
105
|
+
|
|
106
|
+
~StopParamsData() = default;
|
|
107
|
+
|
|
108
|
+
public:
|
|
109
|
+
bool IsDataValid() const
|
|
110
|
+
{
|
|
111
|
+
return (Application.IsSet() == true);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
public:
|
|
115
|
+
Core::JSON::String Application; // Application name
|
|
116
|
+
Core::JSON::String Parameters; // Additional application-specific parameters
|
|
117
|
+
}; // class StopParamsData
|
|
118
|
+
|
|
119
|
+
} // namespace DIALServer
|
|
120
|
+
|
|
121
|
+
POP_WARNING()
|
|
122
|
+
|
|
123
|
+
} // namespace JsonData
|
|
124
|
+
|
|
125
|
+
// Enum conversion handlers
|
|
126
|
+
ENUM_CONVERSION_HANDLER(JsonData::DIALServer::StateType)
|
|
127
|
+
|
|
128
|
+
}
|
|
129
|
+
|
|
@@ -0,0 +1,281 @@
|
|
|
1
|
+
// C++ types for DNSServer API.
|
|
2
|
+
// Generated automatically from 'IDNSServer.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDNSServer.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DNSServer {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class RecordInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
RecordInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
RecordInfo(const RecordInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Type(_other.Type)
|
|
33
|
+
, Key(_other.Key)
|
|
34
|
+
, Value(_other.Value)
|
|
35
|
+
, TTL(_other.TTL)
|
|
36
|
+
, Priority(_other.Priority)
|
|
37
|
+
{
|
|
38
|
+
_Init();
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
RecordInfo(RecordInfo&& _other) noexcept
|
|
42
|
+
: Core::JSON::Container()
|
|
43
|
+
, Type(std::move(_other.Type))
|
|
44
|
+
, Key(std::move(_other.Key))
|
|
45
|
+
, Value(std::move(_other.Value))
|
|
46
|
+
, TTL(std::move(_other.TTL))
|
|
47
|
+
, Priority(std::move(_other.Priority))
|
|
48
|
+
{
|
|
49
|
+
_Init();
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
RecordInfo(const Exchange::IDNSServer::Record& _other)
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Type = _other.Type;
|
|
56
|
+
Key = _other.Key;
|
|
57
|
+
Value = _other.Value;
|
|
58
|
+
TTL = _other.TTL;
|
|
59
|
+
Priority = _other.Priority;
|
|
60
|
+
_Init();
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
RecordInfo& operator=(const RecordInfo& _rhs)
|
|
64
|
+
{
|
|
65
|
+
Type = _rhs.Type;
|
|
66
|
+
Key = _rhs.Key;
|
|
67
|
+
Value = _rhs.Value;
|
|
68
|
+
TTL = _rhs.TTL;
|
|
69
|
+
Priority = _rhs.Priority;
|
|
70
|
+
return (*this);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
RecordInfo& operator=(RecordInfo&& _rhs) noexcept
|
|
74
|
+
{
|
|
75
|
+
Type = std::move(_rhs.Type);
|
|
76
|
+
Key = std::move(_rhs.Key);
|
|
77
|
+
Value = std::move(_rhs.Value);
|
|
78
|
+
TTL = std::move(_rhs.TTL);
|
|
79
|
+
Priority = std::move(_rhs.Priority);
|
|
80
|
+
return (*this);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
RecordInfo& operator=(const Exchange::IDNSServer::Record& _rhs)
|
|
84
|
+
{
|
|
85
|
+
Type = _rhs.Type;
|
|
86
|
+
Key = _rhs.Key;
|
|
87
|
+
Value = _rhs.Value;
|
|
88
|
+
TTL = _rhs.TTL;
|
|
89
|
+
Priority = _rhs.Priority;
|
|
90
|
+
return (*this);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
operator Exchange::IDNSServer::Record() const
|
|
94
|
+
{
|
|
95
|
+
Exchange::IDNSServer::Record _value{};
|
|
96
|
+
_value.Type = Type;
|
|
97
|
+
_value.Key = Key;
|
|
98
|
+
_value.Value = Value;
|
|
99
|
+
_value.TTL = TTL;
|
|
100
|
+
_value.Priority = Priority;
|
|
101
|
+
return (_value);
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
~RecordInfo() = default;
|
|
105
|
+
|
|
106
|
+
public:
|
|
107
|
+
bool IsDataValid() const
|
|
108
|
+
{
|
|
109
|
+
return ((Type.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true) && (TTL.IsSet() == true) && (Priority.IsSet() == true));
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
private:
|
|
113
|
+
void _Init()
|
|
114
|
+
{
|
|
115
|
+
Add(_T("type"), &Type);
|
|
116
|
+
Add(_T("key"), &Key);
|
|
117
|
+
Add(_T("value"), &Value);
|
|
118
|
+
Add(_T("ttl"), &TTL);
|
|
119
|
+
Add(_T("priority"), &Priority);
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
public:
|
|
123
|
+
Core::JSON::EnumType<Exchange::IDNSServer::Record::type> Type;
|
|
124
|
+
Core::JSON::String Key;
|
|
125
|
+
Core::JSON::String Value;
|
|
126
|
+
Core::JSON::DecUInt32 TTL;
|
|
127
|
+
Core::JSON::DecUInt8 Priority;
|
|
128
|
+
}; // class RecordInfo
|
|
129
|
+
|
|
130
|
+
// Method params/result classes
|
|
131
|
+
//
|
|
132
|
+
|
|
133
|
+
class AddParamsData : public Core::JSON::Container {
|
|
134
|
+
public:
|
|
135
|
+
AddParamsData()
|
|
136
|
+
: Core::JSON::Container()
|
|
137
|
+
{
|
|
138
|
+
Add(_T("entry"), &Entry);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
AddParamsData(const AddParamsData&) = delete;
|
|
142
|
+
AddParamsData(AddParamsData&&) noexcept = delete;
|
|
143
|
+
|
|
144
|
+
AddParamsData& operator=(const AddParamsData&) = delete;
|
|
145
|
+
AddParamsData& operator=(AddParamsData&&) noexcept = delete;
|
|
146
|
+
|
|
147
|
+
~AddParamsData() = default;
|
|
148
|
+
|
|
149
|
+
public:
|
|
150
|
+
bool IsDataValid() const
|
|
151
|
+
{
|
|
152
|
+
return ((Entry.IsSet() == true) && (Entry.IsDataValid() == true));
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
public:
|
|
156
|
+
RecordInfo Entry;
|
|
157
|
+
}; // class AddParamsData
|
|
158
|
+
|
|
159
|
+
class CountByTypeParamsData : public Core::JSON::Container {
|
|
160
|
+
public:
|
|
161
|
+
CountByTypeParamsData()
|
|
162
|
+
: Core::JSON::Container()
|
|
163
|
+
{
|
|
164
|
+
Add(_T("designator"), &Designator);
|
|
165
|
+
Add(_T("kind"), &Kind);
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
CountByTypeParamsData(const CountByTypeParamsData&) = delete;
|
|
169
|
+
CountByTypeParamsData(CountByTypeParamsData&&) noexcept = delete;
|
|
170
|
+
|
|
171
|
+
CountByTypeParamsData& operator=(const CountByTypeParamsData&) = delete;
|
|
172
|
+
CountByTypeParamsData& operator=(CountByTypeParamsData&&) noexcept = delete;
|
|
173
|
+
|
|
174
|
+
~CountByTypeParamsData() = default;
|
|
175
|
+
|
|
176
|
+
public:
|
|
177
|
+
bool IsDataValid() const
|
|
178
|
+
{
|
|
179
|
+
return ((Designator.IsSet() == true) && (Kind.IsSet() == true));
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
public:
|
|
183
|
+
Core::JSON::String Designator;
|
|
184
|
+
Core::JSON::EnumType<Exchange::IDNSServer::Record::type> Kind;
|
|
185
|
+
}; // class CountByTypeParamsData
|
|
186
|
+
|
|
187
|
+
class FindByKeyParamsData : public Core::JSON::Container {
|
|
188
|
+
public:
|
|
189
|
+
FindByKeyParamsData()
|
|
190
|
+
: Core::JSON::Container()
|
|
191
|
+
{
|
|
192
|
+
Add(_T("designator"), &Designator);
|
|
193
|
+
Add(_T("key"), &Key);
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
FindByKeyParamsData(const FindByKeyParamsData&) = delete;
|
|
197
|
+
FindByKeyParamsData(FindByKeyParamsData&&) noexcept = delete;
|
|
198
|
+
|
|
199
|
+
FindByKeyParamsData& operator=(const FindByKeyParamsData&) = delete;
|
|
200
|
+
FindByKeyParamsData& operator=(FindByKeyParamsData&&) noexcept = delete;
|
|
201
|
+
|
|
202
|
+
~FindByKeyParamsData() = default;
|
|
203
|
+
|
|
204
|
+
public:
|
|
205
|
+
bool IsDataValid() const
|
|
206
|
+
{
|
|
207
|
+
return ((Designator.IsSet() == true) && (Key.IsSet() == true));
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
public:
|
|
211
|
+
Core::JSON::String Designator;
|
|
212
|
+
Core::JSON::String Key;
|
|
213
|
+
}; // class FindByKeyParamsData
|
|
214
|
+
|
|
215
|
+
class FindByTypeParamsData : public Core::JSON::Container {
|
|
216
|
+
public:
|
|
217
|
+
FindByTypeParamsData()
|
|
218
|
+
: Core::JSON::Container()
|
|
219
|
+
{
|
|
220
|
+
Add(_T("designator"), &Designator);
|
|
221
|
+
Add(_T("kind"), &Kind);
|
|
222
|
+
Add(_T("index"), &Index);
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
FindByTypeParamsData(const FindByTypeParamsData&) = delete;
|
|
226
|
+
FindByTypeParamsData(FindByTypeParamsData&&) noexcept = delete;
|
|
227
|
+
|
|
228
|
+
FindByTypeParamsData& operator=(const FindByTypeParamsData&) = delete;
|
|
229
|
+
FindByTypeParamsData& operator=(FindByTypeParamsData&&) noexcept = delete;
|
|
230
|
+
|
|
231
|
+
~FindByTypeParamsData() = default;
|
|
232
|
+
|
|
233
|
+
public:
|
|
234
|
+
bool IsDataValid() const
|
|
235
|
+
{
|
|
236
|
+
return ((Designator.IsSet() == true) && (Kind.IsSet() == true) && (Index.IsSet() == true));
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
public:
|
|
240
|
+
Core::JSON::String Designator;
|
|
241
|
+
Core::JSON::EnumType<Exchange::IDNSServer::Record::type> Kind;
|
|
242
|
+
Core::JSON::DecUInt8 Index;
|
|
243
|
+
}; // class FindByTypeParamsData
|
|
244
|
+
|
|
245
|
+
class RemoveParamsData : public Core::JSON::Container {
|
|
246
|
+
public:
|
|
247
|
+
RemoveParamsData()
|
|
248
|
+
: Core::JSON::Container()
|
|
249
|
+
{
|
|
250
|
+
Add(_T("record"), &Record);
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
RemoveParamsData(const RemoveParamsData&) = delete;
|
|
254
|
+
RemoveParamsData(RemoveParamsData&&) noexcept = delete;
|
|
255
|
+
|
|
256
|
+
RemoveParamsData& operator=(const RemoveParamsData&) = delete;
|
|
257
|
+
RemoveParamsData& operator=(RemoveParamsData&&) noexcept = delete;
|
|
258
|
+
|
|
259
|
+
~RemoveParamsData() = default;
|
|
260
|
+
|
|
261
|
+
public:
|
|
262
|
+
bool IsDataValid() const
|
|
263
|
+
{
|
|
264
|
+
return ((Record.IsSet() == true) && (Record.IsDataValid() == true));
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
public:
|
|
268
|
+
RecordInfo Record;
|
|
269
|
+
}; // class RemoveParamsData
|
|
270
|
+
|
|
271
|
+
} // namespace DNSServer
|
|
272
|
+
|
|
273
|
+
POP_WARNING()
|
|
274
|
+
|
|
275
|
+
} // namespace JsonData
|
|
276
|
+
|
|
277
|
+
// Enum conversion handlers
|
|
278
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDNSServer::Record::type)
|
|
279
|
+
|
|
280
|
+
}
|
|
281
|
+
|
|
@@ -0,0 +1,1591 @@
|
|
|
1
|
+
// C++ types for DTV API.
|
|
2
|
+
// Generated automatically from 'DTV.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DTV {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Video or audio codec type
|
|
23
|
+
enum class CodecType : uint8_t {
|
|
24
|
+
MPEG2,
|
|
25
|
+
H264,
|
|
26
|
+
H265,
|
|
27
|
+
AVS,
|
|
28
|
+
MPEG1,
|
|
29
|
+
AAC,
|
|
30
|
+
HEAAC,
|
|
31
|
+
HEAACV2,
|
|
32
|
+
AC3,
|
|
33
|
+
EAC3
|
|
34
|
+
};
|
|
35
|
+
|
|
36
|
+
// Diseqc cswitch
|
|
37
|
+
enum class Diseqc_cswitchType : uint8_t {
|
|
38
|
+
OFF,
|
|
39
|
+
A,
|
|
40
|
+
B,
|
|
41
|
+
C,
|
|
42
|
+
D
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
// Diseqc Tone
|
|
46
|
+
enum class Diseqc_toneType : uint8_t {
|
|
47
|
+
OFF,
|
|
48
|
+
A,
|
|
49
|
+
B
|
|
50
|
+
};
|
|
51
|
+
|
|
52
|
+
// DVB C Modulation supported by the platform
|
|
53
|
+
enum class DvbcmodulationType : uint8_t {
|
|
54
|
+
AUTO,
|
|
55
|
+
E4QAM,
|
|
56
|
+
E8QAM,
|
|
57
|
+
E16QAM,
|
|
58
|
+
E32QAM,
|
|
59
|
+
E64QAM,
|
|
60
|
+
E128QAM,
|
|
61
|
+
E256QAM
|
|
62
|
+
};
|
|
63
|
+
|
|
64
|
+
// DVB S Modulation supported by the platform
|
|
65
|
+
enum class DvbsmodulationType : uint8_t {
|
|
66
|
+
AUTO,
|
|
67
|
+
QPSK,
|
|
68
|
+
E8PSK,
|
|
69
|
+
E16QAM
|
|
70
|
+
};
|
|
71
|
+
|
|
72
|
+
// Channel bandwidth
|
|
73
|
+
enum class DvbtbandwidthType : uint8_t {
|
|
74
|
+
E5MHZ,
|
|
75
|
+
E6MHZ,
|
|
76
|
+
E7MHZ,
|
|
77
|
+
E8MHZ,
|
|
78
|
+
E10MHZ,
|
|
79
|
+
UNDEFINED
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
// Event type that's sent as an asynchronous notification
|
|
83
|
+
enum class EventtypeType : uint8_t {
|
|
84
|
+
SERVICESEARCHSTATUS,
|
|
85
|
+
SERVICEUPDATED,
|
|
86
|
+
SERVICEADDED,
|
|
87
|
+
SERVICEDELETED,
|
|
88
|
+
VIDEOCHANGED,
|
|
89
|
+
AUDIOCHANGED,
|
|
90
|
+
SUBTITLESCHANGED,
|
|
91
|
+
EVENTCHANGED
|
|
92
|
+
};
|
|
93
|
+
|
|
94
|
+
// Forward error correction setting
|
|
95
|
+
enum class FecType : uint8_t {
|
|
96
|
+
FECAUTO,
|
|
97
|
+
FEC1_2,
|
|
98
|
+
FEC2_3,
|
|
99
|
+
FEC3_4,
|
|
100
|
+
FEC5_6,
|
|
101
|
+
FEC7_8,
|
|
102
|
+
FEC1_4,
|
|
103
|
+
FEC1_3,
|
|
104
|
+
FEC2_5,
|
|
105
|
+
FEC8_9,
|
|
106
|
+
FEC9_10,
|
|
107
|
+
FEC3_5,
|
|
108
|
+
FEC4_5
|
|
109
|
+
};
|
|
110
|
+
|
|
111
|
+
// LNB power values
|
|
112
|
+
enum class LnbpowerType : uint8_t {
|
|
113
|
+
OFF,
|
|
114
|
+
ON,
|
|
115
|
+
AUTO
|
|
116
|
+
};
|
|
117
|
+
|
|
118
|
+
// LNB type
|
|
119
|
+
enum class LnbtypeType : uint8_t {
|
|
120
|
+
SINGLE,
|
|
121
|
+
UNIVERSAL,
|
|
122
|
+
UNICABLE
|
|
123
|
+
};
|
|
124
|
+
|
|
125
|
+
// OFDM mode
|
|
126
|
+
enum class OfdmmodeType : uint8_t {
|
|
127
|
+
OFDM_1K,
|
|
128
|
+
OFDM_2K,
|
|
129
|
+
OFDM_4K,
|
|
130
|
+
OFDM_8K,
|
|
131
|
+
OFDM_16K,
|
|
132
|
+
OFDM_32K,
|
|
133
|
+
UNDEFINED
|
|
134
|
+
};
|
|
135
|
+
|
|
136
|
+
// Polarity setting
|
|
137
|
+
enum class PolarityType : uint8_t {
|
|
138
|
+
HORIZONTAL,
|
|
139
|
+
VERTICAL,
|
|
140
|
+
LEFT,
|
|
141
|
+
RIGHT
|
|
142
|
+
};
|
|
143
|
+
|
|
144
|
+
// (Version 2) The running status as given by the service descriptor in the SDT
|
|
145
|
+
enum class RunningstatusType : uint8_t {
|
|
146
|
+
UNDEFINED,
|
|
147
|
+
NOTRUNNING,
|
|
148
|
+
STARTSSOON,
|
|
149
|
+
PAUSING,
|
|
150
|
+
RUNNING,
|
|
151
|
+
OFFAIR
|
|
152
|
+
};
|
|
153
|
+
|
|
154
|
+
// (Version 2) Service type as given by the service descriptor in the SDT
|
|
155
|
+
enum class ServicetypeType : uint8_t {
|
|
156
|
+
TV,
|
|
157
|
+
RADIO,
|
|
158
|
+
TELETEXT,
|
|
159
|
+
NVOD,
|
|
160
|
+
NVOD_TIMESHIFT,
|
|
161
|
+
MOSAIC,
|
|
162
|
+
AVC_RADIO,
|
|
163
|
+
AVC_MOSAIC,
|
|
164
|
+
DATA,
|
|
165
|
+
MPEG2_HD,
|
|
166
|
+
AVC_SD_TV,
|
|
167
|
+
AVC_SD_NVOD_TIMESHIFT,
|
|
168
|
+
AVC_SD_NVOD,
|
|
169
|
+
HD_TV,
|
|
170
|
+
AVC_HD_NVOD_TIMESHIFT,
|
|
171
|
+
AVC_HD_NVOD,
|
|
172
|
+
UHD_TV,
|
|
173
|
+
UNKNOWN
|
|
174
|
+
};
|
|
175
|
+
|
|
176
|
+
// Tuner type
|
|
177
|
+
enum class TunertypeType : uint8_t {
|
|
178
|
+
NONE = 0,
|
|
179
|
+
DVBS = 1,
|
|
180
|
+
DVBT = 2,
|
|
181
|
+
DVBC = 4
|
|
182
|
+
};
|
|
183
|
+
|
|
184
|
+
// Common classes
|
|
185
|
+
//
|
|
186
|
+
|
|
187
|
+
class DvbctuningparamsInfo : public Core::JSON::Container {
|
|
188
|
+
public:
|
|
189
|
+
DvbctuningparamsInfo()
|
|
190
|
+
: Core::JSON::Container()
|
|
191
|
+
{
|
|
192
|
+
Add(_T("frequency"), &Frequency);
|
|
193
|
+
Add(_T("symbolrate"), &Symbolrate);
|
|
194
|
+
Add(_T("modulation"), &Modulation);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
DvbctuningparamsInfo(const DvbctuningparamsInfo&) = delete;
|
|
198
|
+
DvbctuningparamsInfo(DvbctuningparamsInfo&&) noexcept = delete;
|
|
199
|
+
|
|
200
|
+
DvbctuningparamsInfo& operator=(const DvbctuningparamsInfo&) = delete;
|
|
201
|
+
DvbctuningparamsInfo& operator=(DvbctuningparamsInfo&&) noexcept = delete;
|
|
202
|
+
|
|
203
|
+
~DvbctuningparamsInfo() = default;
|
|
204
|
+
|
|
205
|
+
public:
|
|
206
|
+
bool IsDataValid() const
|
|
207
|
+
{
|
|
208
|
+
return ((Frequency.IsSet() == true) && (Symbolrate.IsSet() == true) && (Modulation.IsSet() == true));
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
public:
|
|
212
|
+
Core::JSON::DecUInt32 Frequency; // Frequency of the transport, in Hz
|
|
213
|
+
Core::JSON::DecUInt16 Symbolrate; // Symbol rate in Ksymb/sec
|
|
214
|
+
Core::JSON::EnumType<DvbcmodulationType> Modulation; // DVB C Modulation supported by the platform
|
|
215
|
+
}; // class DvbctuningparamsInfo
|
|
216
|
+
|
|
217
|
+
class DvbstuningparamsInfo : public Core::JSON::Container {
|
|
218
|
+
public:
|
|
219
|
+
DvbstuningparamsInfo()
|
|
220
|
+
: Core::JSON::Container()
|
|
221
|
+
{
|
|
222
|
+
Add(_T("satellite"), &Satellite);
|
|
223
|
+
Add(_T("frequency"), &Frequency);
|
|
224
|
+
Add(_T("polarity"), &Polarity);
|
|
225
|
+
Add(_T("symbolrate"), &Symbolrate);
|
|
226
|
+
Add(_T("fec"), &Fec);
|
|
227
|
+
Add(_T("modulation"), &Modulation);
|
|
228
|
+
Add(_T("dvbs2"), &Dvbs2);
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
DvbstuningparamsInfo(const DvbstuningparamsInfo&) = delete;
|
|
232
|
+
DvbstuningparamsInfo(DvbstuningparamsInfo&&) noexcept = delete;
|
|
233
|
+
|
|
234
|
+
DvbstuningparamsInfo& operator=(const DvbstuningparamsInfo&) = delete;
|
|
235
|
+
DvbstuningparamsInfo& operator=(DvbstuningparamsInfo&&) noexcept = delete;
|
|
236
|
+
|
|
237
|
+
~DvbstuningparamsInfo() = default;
|
|
238
|
+
|
|
239
|
+
public:
|
|
240
|
+
bool IsDataValid() const
|
|
241
|
+
{
|
|
242
|
+
return ((Satellite.IsSet() == true) && (Frequency.IsSet() == true) && (Polarity.IsSet() == true) && (Symbolrate.IsSet() == true) && (Fec.IsSet() == true) && (Modulation.IsSet() == true) && (Dvbs2.IsSet() == true));
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
public:
|
|
246
|
+
Core::JSON::String Satellite; // Name of the satellite settings to be used
|
|
247
|
+
Core::JSON::DecUInt32 Frequency; // Frequency of the transponder, in kHz
|
|
248
|
+
Core::JSON::EnumType<PolarityType> Polarity; // Polarity setting
|
|
249
|
+
Core::JSON::DecUInt16 Symbolrate; // Symbol rate in Ksymb/sec
|
|
250
|
+
Core::JSON::EnumType<FecType> Fec; // Forward error correction setting
|
|
251
|
+
Core::JSON::EnumType<DvbsmodulationType> Modulation; // DVB S Modulation supported by the platform
|
|
252
|
+
Core::JSON::Boolean Dvbs2; // True when tuning to a DVB-S2 signal
|
|
253
|
+
}; // class DvbstuningparamsInfo
|
|
254
|
+
|
|
255
|
+
class DvbttuningparamsInfo : public Core::JSON::Container {
|
|
256
|
+
public:
|
|
257
|
+
DvbttuningparamsInfo()
|
|
258
|
+
: Core::JSON::Container()
|
|
259
|
+
{
|
|
260
|
+
Add(_T("frequency"), &Frequency);
|
|
261
|
+
Add(_T("bandwidth"), &Bandwidth);
|
|
262
|
+
Add(_T("mode"), &Mode);
|
|
263
|
+
Add(_T("dvbt2"), &Dvbt2);
|
|
264
|
+
Add(_T("plpid"), &Plpid);
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
DvbttuningparamsInfo(const DvbttuningparamsInfo&) = delete;
|
|
268
|
+
DvbttuningparamsInfo(DvbttuningparamsInfo&&) noexcept = delete;
|
|
269
|
+
|
|
270
|
+
DvbttuningparamsInfo& operator=(const DvbttuningparamsInfo&) = delete;
|
|
271
|
+
DvbttuningparamsInfo& operator=(DvbttuningparamsInfo&&) noexcept = delete;
|
|
272
|
+
|
|
273
|
+
~DvbttuningparamsInfo() = default;
|
|
274
|
+
|
|
275
|
+
public:
|
|
276
|
+
bool IsDataValid() const
|
|
277
|
+
{
|
|
278
|
+
return ((Frequency.IsSet() == true) && (Bandwidth.IsSet() == true) && (Mode.IsSet() == true) && (Dvbt2.IsSet() == true));
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
public:
|
|
282
|
+
Core::JSON::DecUInt32 Frequency; // Frequency of the transport, in Hz
|
|
283
|
+
Core::JSON::EnumType<DvbtbandwidthType> Bandwidth; // Channel bandwidth
|
|
284
|
+
Core::JSON::EnumType<OfdmmodeType> Mode; // OFDM mode
|
|
285
|
+
Core::JSON::Boolean Dvbt2; // True when tuning to a DVB-T2 signal
|
|
286
|
+
Core::JSON::DecUInt8 Plpid; // PLP ID for tuning to a DVB-T2 signal
|
|
287
|
+
}; // class DvbttuningparamsInfo
|
|
288
|
+
|
|
289
|
+
class EiteventInfo : public Core::JSON::Container {
|
|
290
|
+
public:
|
|
291
|
+
EiteventInfo()
|
|
292
|
+
: Core::JSON::Container()
|
|
293
|
+
{
|
|
294
|
+
_Init();
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
EiteventInfo(const EiteventInfo& _other)
|
|
298
|
+
: Core::JSON::Container()
|
|
299
|
+
, Name(_other.Name)
|
|
300
|
+
, Starttime(_other.Starttime)
|
|
301
|
+
, Duration(_other.Duration)
|
|
302
|
+
, Eventid(_other.Eventid)
|
|
303
|
+
, Shortdescription(_other.Shortdescription)
|
|
304
|
+
, Hassubtitles(_other.Hassubtitles)
|
|
305
|
+
, Hasaudiodescription(_other.Hasaudiodescription)
|
|
306
|
+
, Parentalrating(_other.Parentalrating)
|
|
307
|
+
, Contentdata(_other.Contentdata)
|
|
308
|
+
, Hasextendedinfo(_other.Hasextendedinfo)
|
|
309
|
+
{
|
|
310
|
+
_Init();
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
EiteventInfo(EiteventInfo&& _other) noexcept
|
|
314
|
+
: Core::JSON::Container()
|
|
315
|
+
, Name(std::move(_other.Name))
|
|
316
|
+
, Starttime(std::move(_other.Starttime))
|
|
317
|
+
, Duration(std::move(_other.Duration))
|
|
318
|
+
, Eventid(std::move(_other.Eventid))
|
|
319
|
+
, Shortdescription(std::move(_other.Shortdescription))
|
|
320
|
+
, Hassubtitles(std::move(_other.Hassubtitles))
|
|
321
|
+
, Hasaudiodescription(std::move(_other.Hasaudiodescription))
|
|
322
|
+
, Parentalrating(std::move(_other.Parentalrating))
|
|
323
|
+
, Contentdata(std::move(_other.Contentdata))
|
|
324
|
+
, Hasextendedinfo(std::move(_other.Hasextendedinfo))
|
|
325
|
+
{
|
|
326
|
+
_Init();
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
EiteventInfo& operator=(const EiteventInfo& _rhs)
|
|
330
|
+
{
|
|
331
|
+
Name = _rhs.Name;
|
|
332
|
+
Starttime = _rhs.Starttime;
|
|
333
|
+
Duration = _rhs.Duration;
|
|
334
|
+
Eventid = _rhs.Eventid;
|
|
335
|
+
Shortdescription = _rhs.Shortdescription;
|
|
336
|
+
Hassubtitles = _rhs.Hassubtitles;
|
|
337
|
+
Hasaudiodescription = _rhs.Hasaudiodescription;
|
|
338
|
+
Parentalrating = _rhs.Parentalrating;
|
|
339
|
+
Contentdata = _rhs.Contentdata;
|
|
340
|
+
Hasextendedinfo = _rhs.Hasextendedinfo;
|
|
341
|
+
return (*this);
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
EiteventInfo& operator=(EiteventInfo&& _rhs) noexcept
|
|
345
|
+
{
|
|
346
|
+
Name = std::move(_rhs.Name);
|
|
347
|
+
Starttime = std::move(_rhs.Starttime);
|
|
348
|
+
Duration = std::move(_rhs.Duration);
|
|
349
|
+
Eventid = std::move(_rhs.Eventid);
|
|
350
|
+
Shortdescription = std::move(_rhs.Shortdescription);
|
|
351
|
+
Hassubtitles = std::move(_rhs.Hassubtitles);
|
|
352
|
+
Hasaudiodescription = std::move(_rhs.Hasaudiodescription);
|
|
353
|
+
Parentalrating = std::move(_rhs.Parentalrating);
|
|
354
|
+
Contentdata = std::move(_rhs.Contentdata);
|
|
355
|
+
Hasextendedinfo = std::move(_rhs.Hasextendedinfo);
|
|
356
|
+
return (*this);
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
~EiteventInfo() = default;
|
|
360
|
+
|
|
361
|
+
public:
|
|
362
|
+
bool IsDataValid() const
|
|
363
|
+
{
|
|
364
|
+
return ((Name.IsSet() == true) && (Starttime.IsSet() == true) && (Duration.IsSet() == true) && (Eventid.IsSet() == true) && (Shortdescription.IsSet() == true) && (Hassubtitles.IsSet() == true) && (Hasaudiodescription.IsSet() == true) && (Parentalrating.IsSet() == true) && (Contentdata.IsSet() == true) && (Hasextendedinfo.IsSet() == true));
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
private:
|
|
368
|
+
void _Init()
|
|
369
|
+
{
|
|
370
|
+
Add(_T("name"), &Name);
|
|
371
|
+
Add(_T("starttime"), &Starttime);
|
|
372
|
+
Add(_T("duration"), &Duration);
|
|
373
|
+
Add(_T("eventid"), &Eventid);
|
|
374
|
+
Add(_T("shortdescription"), &Shortdescription);
|
|
375
|
+
Add(_T("hassubtitles"), &Hassubtitles);
|
|
376
|
+
Add(_T("hasaudiodescription"), &Hasaudiodescription);
|
|
377
|
+
Add(_T("parentalrating"), &Parentalrating);
|
|
378
|
+
Add(_T("contentdata"), &Contentdata);
|
|
379
|
+
Add(_T("hasextendedinfo"), &Hasextendedinfo);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
public:
|
|
383
|
+
Core::JSON::String Name; // Name of the DVB event as defined in the short event descriptor
|
|
384
|
+
Core::JSON::DecUInt32 Starttime; // UTC start time of the event in seconds
|
|
385
|
+
Core::JSON::DecUInt32 Duration; // Duration of the event in seconds
|
|
386
|
+
Core::JSON::DecUInt16 Eventid; // ID of the event from the event information table
|
|
387
|
+
Core::JSON::String Shortdescription; // Event description from the EIT short event descriptor
|
|
388
|
+
Core::JSON::Boolean Hassubtitles; // (Version 2) True if subtitles are available
|
|
389
|
+
Core::JSON::Boolean Hasaudiodescription; // (Version 2) True if audio description is available
|
|
390
|
+
Core::JSON::DecUInt8 Parentalrating; // (Version 2) Parental rating for the event, will be 0 if undefined
|
|
391
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt8> Contentdata; // (Version 2) The first 2 4-bit values from the content descriptor as separate bytes
|
|
392
|
+
Core::JSON::Boolean Hasextendedinfo; // (Version 2) True if there's extended event information available
|
|
393
|
+
}; // class EiteventInfo
|
|
394
|
+
|
|
395
|
+
class LnbsettingsInfo : public Core::JSON::Container {
|
|
396
|
+
public:
|
|
397
|
+
LnbsettingsInfo()
|
|
398
|
+
: Core::JSON::Container()
|
|
399
|
+
{
|
|
400
|
+
_Init();
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
LnbsettingsInfo(const LnbsettingsInfo& _other)
|
|
404
|
+
: Core::JSON::Container()
|
|
405
|
+
, Name(_other.Name)
|
|
406
|
+
, Type(_other.Type)
|
|
407
|
+
, Power(_other.Power)
|
|
408
|
+
, Diseqc_tone(_other.Diseqc_tone)
|
|
409
|
+
, Diseqc_cswitch(_other.Diseqc_cswitch)
|
|
410
|
+
, Is22k(_other.Is22k)
|
|
411
|
+
, Is12v(_other.Is12v)
|
|
412
|
+
, Ispulseposition(_other.Ispulseposition)
|
|
413
|
+
, Isdiseqcposition(_other.Isdiseqcposition)
|
|
414
|
+
, Issmatv(_other.Issmatv)
|
|
415
|
+
, Diseqcrepeats(_other.Diseqcrepeats)
|
|
416
|
+
, U_switch(_other.U_switch)
|
|
417
|
+
, Unicablechannel(_other.Unicablechannel)
|
|
418
|
+
, Unicablefreq(_other.Unicablefreq)
|
|
419
|
+
{
|
|
420
|
+
_Init();
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
LnbsettingsInfo(LnbsettingsInfo&& _other) noexcept
|
|
424
|
+
: Core::JSON::Container()
|
|
425
|
+
, Name(std::move(_other.Name))
|
|
426
|
+
, Type(std::move(_other.Type))
|
|
427
|
+
, Power(std::move(_other.Power))
|
|
428
|
+
, Diseqc_tone(std::move(_other.Diseqc_tone))
|
|
429
|
+
, Diseqc_cswitch(std::move(_other.Diseqc_cswitch))
|
|
430
|
+
, Is22k(std::move(_other.Is22k))
|
|
431
|
+
, Is12v(std::move(_other.Is12v))
|
|
432
|
+
, Ispulseposition(std::move(_other.Ispulseposition))
|
|
433
|
+
, Isdiseqcposition(std::move(_other.Isdiseqcposition))
|
|
434
|
+
, Issmatv(std::move(_other.Issmatv))
|
|
435
|
+
, Diseqcrepeats(std::move(_other.Diseqcrepeats))
|
|
436
|
+
, U_switch(std::move(_other.U_switch))
|
|
437
|
+
, Unicablechannel(std::move(_other.Unicablechannel))
|
|
438
|
+
, Unicablefreq(std::move(_other.Unicablefreq))
|
|
439
|
+
{
|
|
440
|
+
_Init();
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
LnbsettingsInfo& operator=(const LnbsettingsInfo& _rhs)
|
|
444
|
+
{
|
|
445
|
+
Name = _rhs.Name;
|
|
446
|
+
Type = _rhs.Type;
|
|
447
|
+
Power = _rhs.Power;
|
|
448
|
+
Diseqc_tone = _rhs.Diseqc_tone;
|
|
449
|
+
Diseqc_cswitch = _rhs.Diseqc_cswitch;
|
|
450
|
+
Is22k = _rhs.Is22k;
|
|
451
|
+
Is12v = _rhs.Is12v;
|
|
452
|
+
Ispulseposition = _rhs.Ispulseposition;
|
|
453
|
+
Isdiseqcposition = _rhs.Isdiseqcposition;
|
|
454
|
+
Issmatv = _rhs.Issmatv;
|
|
455
|
+
Diseqcrepeats = _rhs.Diseqcrepeats;
|
|
456
|
+
U_switch = _rhs.U_switch;
|
|
457
|
+
Unicablechannel = _rhs.Unicablechannel;
|
|
458
|
+
if (_rhs.Unicablefreq != 0) {
|
|
459
|
+
Unicablefreq = _rhs.Unicablefreq;
|
|
460
|
+
}
|
|
461
|
+
return (*this);
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
LnbsettingsInfo& operator=(LnbsettingsInfo&& _rhs) noexcept
|
|
465
|
+
{
|
|
466
|
+
Name = std::move(_rhs.Name);
|
|
467
|
+
Type = std::move(_rhs.Type);
|
|
468
|
+
Power = std::move(_rhs.Power);
|
|
469
|
+
Diseqc_tone = std::move(_rhs.Diseqc_tone);
|
|
470
|
+
Diseqc_cswitch = std::move(_rhs.Diseqc_cswitch);
|
|
471
|
+
Is22k = std::move(_rhs.Is22k);
|
|
472
|
+
Is12v = std::move(_rhs.Is12v);
|
|
473
|
+
Ispulseposition = std::move(_rhs.Ispulseposition);
|
|
474
|
+
Isdiseqcposition = std::move(_rhs.Isdiseqcposition);
|
|
475
|
+
Issmatv = std::move(_rhs.Issmatv);
|
|
476
|
+
Diseqcrepeats = std::move(_rhs.Diseqcrepeats);
|
|
477
|
+
U_switch = std::move(_rhs.U_switch);
|
|
478
|
+
Unicablechannel = std::move(_rhs.Unicablechannel);
|
|
479
|
+
Unicablefreq = std::move(_rhs.Unicablefreq);
|
|
480
|
+
return (*this);
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
~LnbsettingsInfo() = default;
|
|
484
|
+
|
|
485
|
+
public:
|
|
486
|
+
bool IsDataValid() const
|
|
487
|
+
{
|
|
488
|
+
return ((Name.IsSet() == true) && (Type.IsSet() == true) && (Power.IsSet() == true) && (Diseqc_tone.IsSet() == true) && (Diseqc_cswitch.IsSet() == true) && (Is22k.IsSet() == true) && (Is12v.IsSet() == true) && (Ispulseposition.IsSet() == true) && (Isdiseqcposition.IsSet() == true) && (Issmatv.IsSet() == true) && (Diseqcrepeats.IsSet() == true) && (U_switch.IsSet() == true) && (Unicablechannel.IsSet() == true));
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
private:
|
|
492
|
+
void _Init()
|
|
493
|
+
{
|
|
494
|
+
Add(_T("name"), &Name);
|
|
495
|
+
Add(_T("type"), &Type);
|
|
496
|
+
Add(_T("power"), &Power);
|
|
497
|
+
Add(_T("diseqc_tone"), &Diseqc_tone);
|
|
498
|
+
Add(_T("diseqc_cswitch"), &Diseqc_cswitch);
|
|
499
|
+
Add(_T("is22k"), &Is22k);
|
|
500
|
+
Add(_T("is12v"), &Is12v);
|
|
501
|
+
Add(_T("ispulseposition"), &Ispulseposition);
|
|
502
|
+
Add(_T("isdiseqcposition"), &Isdiseqcposition);
|
|
503
|
+
Add(_T("issmatv"), &Issmatv);
|
|
504
|
+
Add(_T("diseqcrepeats"), &Diseqcrepeats);
|
|
505
|
+
Add(_T("u_switch"), &U_switch);
|
|
506
|
+
Add(_T("unicablechannel"), &Unicablechannel);
|
|
507
|
+
Add(_T("unicablefreq"), &Unicablefreq);
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
public:
|
|
511
|
+
Core::JSON::String Name; // User specified name for the LNB settings
|
|
512
|
+
Core::JSON::EnumType<LnbtypeType> Type; // LNB type
|
|
513
|
+
Core::JSON::EnumType<LnbpowerType> Power; // LNB power values
|
|
514
|
+
Core::JSON::EnumType<Diseqc_toneType> Diseqc_tone; // Diseqc Tone
|
|
515
|
+
Core::JSON::EnumType<Diseqc_cswitchType> Diseqc_cswitch; // Diseqc cswitch
|
|
516
|
+
Core::JSON::Boolean Is22k; // 22kHz tone on/off
|
|
517
|
+
Core::JSON::Boolean Is12v; // 12 volts on/off
|
|
518
|
+
Core::JSON::Boolean Ispulseposition; // Pulse position motor used to control dish position
|
|
519
|
+
Core::JSON::Boolean Isdiseqcposition; // Dish positioning is controlled by DiSEqC
|
|
520
|
+
Core::JSON::Boolean Issmatv; // SMATV switcher on/off
|
|
521
|
+
Core::JSON::DecUInt8 Diseqcrepeats; // Number of times to send a DiSEqC message to make sure it's been received
|
|
522
|
+
Core::JSON::DecUInt8 U_switch; // DiSEqC uncommitted switch selector
|
|
523
|
+
Core::JSON::DecUInt8 Unicablechannel; // Unicable channel
|
|
524
|
+
Core::JSON::DecUInt32 Unicablefreq; // Unicable frequency
|
|
525
|
+
}; // class LnbsettingsInfo
|
|
526
|
+
|
|
527
|
+
class SatellitesettingsInfo : public Core::JSON::Container {
|
|
528
|
+
public:
|
|
529
|
+
SatellitesettingsInfo()
|
|
530
|
+
: Core::JSON::Container()
|
|
531
|
+
{
|
|
532
|
+
_Init();
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
SatellitesettingsInfo(const SatellitesettingsInfo& _other)
|
|
536
|
+
: Core::JSON::Container()
|
|
537
|
+
, Name(_other.Name)
|
|
538
|
+
, Longitude(_other.Longitude)
|
|
539
|
+
, Lnb(_other.Lnb)
|
|
540
|
+
{
|
|
541
|
+
_Init();
|
|
542
|
+
}
|
|
543
|
+
|
|
544
|
+
SatellitesettingsInfo(SatellitesettingsInfo&& _other) noexcept
|
|
545
|
+
: Core::JSON::Container()
|
|
546
|
+
, Name(std::move(_other.Name))
|
|
547
|
+
, Longitude(std::move(_other.Longitude))
|
|
548
|
+
, Lnb(std::move(_other.Lnb))
|
|
549
|
+
{
|
|
550
|
+
_Init();
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
SatellitesettingsInfo& operator=(const SatellitesettingsInfo& _rhs)
|
|
554
|
+
{
|
|
555
|
+
Name = _rhs.Name;
|
|
556
|
+
Longitude = _rhs.Longitude;
|
|
557
|
+
Lnb = _rhs.Lnb;
|
|
558
|
+
return (*this);
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
SatellitesettingsInfo& operator=(SatellitesettingsInfo&& _rhs) noexcept
|
|
562
|
+
{
|
|
563
|
+
Name = std::move(_rhs.Name);
|
|
564
|
+
Longitude = std::move(_rhs.Longitude);
|
|
565
|
+
Lnb = std::move(_rhs.Lnb);
|
|
566
|
+
return (*this);
|
|
567
|
+
}
|
|
568
|
+
|
|
569
|
+
~SatellitesettingsInfo() = default;
|
|
570
|
+
|
|
571
|
+
public:
|
|
572
|
+
bool IsDataValid() const
|
|
573
|
+
{
|
|
574
|
+
return ((Name.IsSet() == true) && (Longitude.IsSet() == true) && (Lnb.IsSet() == true));
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
private:
|
|
578
|
+
void _Init()
|
|
579
|
+
{
|
|
580
|
+
Add(_T("name"), &Name);
|
|
581
|
+
Add(_T("longitude"), &Longitude);
|
|
582
|
+
Add(_T("lnb"), &Lnb);
|
|
583
|
+
}
|
|
584
|
+
|
|
585
|
+
public:
|
|
586
|
+
Core::JSON::String Name; // User specified name for the satellite settings
|
|
587
|
+
Core::JSON::DecSInt16 Longitude; // Longitudinal location of the satellite in 1/10ths of a degree, with an east coordinate given as a positive value and a west coordinate as negative. Astra 28.2E would be defined as 282 and Eutelsat 5.0W would be -50.
|
|
588
|
+
Core::JSON::String Lnb; // Name of the LNB settings to be used when tuning to this satellite
|
|
589
|
+
}; // class SatellitesettingsInfo
|
|
590
|
+
|
|
591
|
+
class ServiceInfo : public Core::JSON::Container {
|
|
592
|
+
public:
|
|
593
|
+
ServiceInfo()
|
|
594
|
+
: Core::JSON::Container()
|
|
595
|
+
{
|
|
596
|
+
_Init();
|
|
597
|
+
}
|
|
598
|
+
|
|
599
|
+
ServiceInfo(const ServiceInfo& _other)
|
|
600
|
+
: Core::JSON::Container()
|
|
601
|
+
, Fullname(_other.Fullname)
|
|
602
|
+
, Shortname(_other.Shortname)
|
|
603
|
+
, Dvburi(_other.Dvburi)
|
|
604
|
+
, Servicetype(_other.Servicetype)
|
|
605
|
+
, Lcn(_other.Lcn)
|
|
606
|
+
, Scrambled(_other.Scrambled)
|
|
607
|
+
, Hascadescriptor(_other.Hascadescriptor)
|
|
608
|
+
, Hidden(_other.Hidden)
|
|
609
|
+
, Selectable(_other.Selectable)
|
|
610
|
+
, Runningstatus(_other.Runningstatus)
|
|
611
|
+
{
|
|
612
|
+
_Init();
|
|
613
|
+
}
|
|
614
|
+
|
|
615
|
+
ServiceInfo(ServiceInfo&& _other) noexcept
|
|
616
|
+
: Core::JSON::Container()
|
|
617
|
+
, Fullname(std::move(_other.Fullname))
|
|
618
|
+
, Shortname(std::move(_other.Shortname))
|
|
619
|
+
, Dvburi(std::move(_other.Dvburi))
|
|
620
|
+
, Servicetype(std::move(_other.Servicetype))
|
|
621
|
+
, Lcn(std::move(_other.Lcn))
|
|
622
|
+
, Scrambled(std::move(_other.Scrambled))
|
|
623
|
+
, Hascadescriptor(std::move(_other.Hascadescriptor))
|
|
624
|
+
, Hidden(std::move(_other.Hidden))
|
|
625
|
+
, Selectable(std::move(_other.Selectable))
|
|
626
|
+
, Runningstatus(std::move(_other.Runningstatus))
|
|
627
|
+
{
|
|
628
|
+
_Init();
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
ServiceInfo& operator=(const ServiceInfo& _rhs)
|
|
632
|
+
{
|
|
633
|
+
Fullname = _rhs.Fullname;
|
|
634
|
+
Shortname = _rhs.Shortname;
|
|
635
|
+
Dvburi = _rhs.Dvburi;
|
|
636
|
+
Servicetype = _rhs.Servicetype;
|
|
637
|
+
Lcn = _rhs.Lcn;
|
|
638
|
+
Scrambled = _rhs.Scrambled;
|
|
639
|
+
Hascadescriptor = _rhs.Hascadescriptor;
|
|
640
|
+
Hidden = _rhs.Hidden;
|
|
641
|
+
Selectable = _rhs.Selectable;
|
|
642
|
+
Runningstatus = _rhs.Runningstatus;
|
|
643
|
+
return (*this);
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
ServiceInfo& operator=(ServiceInfo&& _rhs) noexcept
|
|
647
|
+
{
|
|
648
|
+
Fullname = std::move(_rhs.Fullname);
|
|
649
|
+
Shortname = std::move(_rhs.Shortname);
|
|
650
|
+
Dvburi = std::move(_rhs.Dvburi);
|
|
651
|
+
Servicetype = std::move(_rhs.Servicetype);
|
|
652
|
+
Lcn = std::move(_rhs.Lcn);
|
|
653
|
+
Scrambled = std::move(_rhs.Scrambled);
|
|
654
|
+
Hascadescriptor = std::move(_rhs.Hascadescriptor);
|
|
655
|
+
Hidden = std::move(_rhs.Hidden);
|
|
656
|
+
Selectable = std::move(_rhs.Selectable);
|
|
657
|
+
Runningstatus = std::move(_rhs.Runningstatus);
|
|
658
|
+
return (*this);
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
~ServiceInfo() = default;
|
|
662
|
+
|
|
663
|
+
public:
|
|
664
|
+
bool IsDataValid() const
|
|
665
|
+
{
|
|
666
|
+
return ((Fullname.IsSet() == true) && (Shortname.IsSet() == true) && (Dvburi.IsSet() == true) && (Servicetype.IsSet() == true) && (Lcn.IsSet() == true) && (Scrambled.IsSet() == true) && (Hascadescriptor.IsSet() == true) && (Hidden.IsSet() == true) && (Selectable.IsSet() == true) && (Runningstatus.IsSet() == true));
|
|
667
|
+
}
|
|
668
|
+
|
|
669
|
+
private:
|
|
670
|
+
void _Init()
|
|
671
|
+
{
|
|
672
|
+
Add(_T("fullname"), &Fullname);
|
|
673
|
+
Add(_T("shortname"), &Shortname);
|
|
674
|
+
Add(_T("dvburi"), &Dvburi);
|
|
675
|
+
Add(_T("servicetype"), &Servicetype);
|
|
676
|
+
Add(_T("lcn"), &Lcn);
|
|
677
|
+
Add(_T("scrambled"), &Scrambled);
|
|
678
|
+
Add(_T("hascadescriptor"), &Hascadescriptor);
|
|
679
|
+
Add(_T("hidden"), &Hidden);
|
|
680
|
+
Add(_T("selectable"), &Selectable);
|
|
681
|
+
Add(_T("runningstatus"), &Runningstatus);
|
|
682
|
+
}
|
|
683
|
+
|
|
684
|
+
public:
|
|
685
|
+
Core::JSON::String Fullname; // (Version 2) Full service name as given by the service descriptor in the SDT
|
|
686
|
+
Core::JSON::String Shortname; // Short service name as given by the service descriptor in the SDT
|
|
687
|
+
Core::JSON::String Dvburi; // DVB triplet of the form a.b.c, where 'a' is the original network ID, 'b' is the transport ID and 'c' is the service ID, in decimal
|
|
688
|
+
Core::JSON::EnumType<ServicetypeType> Servicetype; // (Version 2) Service type as given by the service descriptor in the SDT
|
|
689
|
+
Core::JSON::DecUInt16 Lcn; // Logical channel number
|
|
690
|
+
Core::JSON::Boolean Scrambled; // (Version 2) True if the service is marked as scrambled in the SDT
|
|
691
|
+
Core::JSON::Boolean Hascadescriptor; // (Version 2) True if there is at least one CA descriptor in the service's PMT
|
|
692
|
+
Core::JSON::Boolean Hidden; // (Version 2) True if the service should be hidden
|
|
693
|
+
Core::JSON::Boolean Selectable; // (Version 2) True if the service should be user selectable
|
|
694
|
+
Core::JSON::EnumType<RunningstatusType> Runningstatus; // (Version 2) The running status as given by the service descriptor in the SDT
|
|
695
|
+
}; // class ServiceInfo
|
|
696
|
+
|
|
697
|
+
class ServiceupdatedParamsInfo : public Core::JSON::Container {
|
|
698
|
+
public:
|
|
699
|
+
ServiceupdatedParamsInfo()
|
|
700
|
+
: Core::JSON::Container()
|
|
701
|
+
{
|
|
702
|
+
Add(_T("eventtype"), &Eventtype);
|
|
703
|
+
Add(_T("service"), &Service);
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
ServiceupdatedParamsInfo(const ServiceupdatedParamsInfo&) = delete;
|
|
707
|
+
ServiceupdatedParamsInfo(ServiceupdatedParamsInfo&&) noexcept = delete;
|
|
708
|
+
|
|
709
|
+
ServiceupdatedParamsInfo& operator=(const ServiceupdatedParamsInfo&) = delete;
|
|
710
|
+
ServiceupdatedParamsInfo& operator=(ServiceupdatedParamsInfo&&) noexcept = delete;
|
|
711
|
+
|
|
712
|
+
~ServiceupdatedParamsInfo() = default;
|
|
713
|
+
|
|
714
|
+
public:
|
|
715
|
+
bool IsDataValid() const
|
|
716
|
+
{
|
|
717
|
+
return ((Eventtype.IsSet() == true) && ((Service.IsSet() == true) && (Service.IsDataValid() == true)));
|
|
718
|
+
}
|
|
719
|
+
|
|
720
|
+
public:
|
|
721
|
+
Core::JSON::EnumType<EventtypeType> Eventtype; // Event type that's sent as an asynchronous notification
|
|
722
|
+
ServiceInfo Service; // Service information
|
|
723
|
+
}; // class ServiceupdatedParamsInfo
|
|
724
|
+
|
|
725
|
+
class TransportInfo : public Core::JSON::Container {
|
|
726
|
+
public:
|
|
727
|
+
TransportInfo()
|
|
728
|
+
: Core::JSON::Container()
|
|
729
|
+
{
|
|
730
|
+
Add(_T("tunertype"), &Tunertype);
|
|
731
|
+
Add(_T("originalnetworkid"), &Originalnetworkid);
|
|
732
|
+
Add(_T("transportid"), &Transportid);
|
|
733
|
+
Add(_T("strength"), &Strength);
|
|
734
|
+
Add(_T("quality"), &Quality);
|
|
735
|
+
Add(_T("dvbctuningparams"), &Dvbctuningparams);
|
|
736
|
+
Add(_T("dvbstuningparams"), &Dvbstuningparams);
|
|
737
|
+
Add(_T("dvbttuningparams"), &Dvbttuningparams);
|
|
738
|
+
}
|
|
739
|
+
|
|
740
|
+
TransportInfo(const TransportInfo&) = delete;
|
|
741
|
+
TransportInfo(TransportInfo&&) noexcept = delete;
|
|
742
|
+
|
|
743
|
+
TransportInfo& operator=(const TransportInfo&) = delete;
|
|
744
|
+
TransportInfo& operator=(TransportInfo&&) noexcept = delete;
|
|
745
|
+
|
|
746
|
+
~TransportInfo() = default;
|
|
747
|
+
|
|
748
|
+
public:
|
|
749
|
+
bool IsDataValid() const
|
|
750
|
+
{
|
|
751
|
+
return ((Tunertype.IsSet() == true) && (Originalnetworkid.IsSet() == true) && (Transportid.IsSet() == true) && (Strength.IsSet() == true) && (Quality.IsSet() == true) && ((Dvbctuningparams.IsSet() == false) || (Dvbctuningparams.IsDataValid() == true)) && ((Dvbstuningparams.IsSet() == false) || (Dvbstuningparams.IsDataValid() == true)) && ((Dvbttuningparams.IsSet() == false) || (Dvbttuningparams.IsDataValid() == true)));
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
public:
|
|
755
|
+
Core::JSON::EnumType<TunertypeType> Tunertype; // Tuner type
|
|
756
|
+
Core::JSON::DecUInt16 Originalnetworkid; // Original network ID of the transport
|
|
757
|
+
Core::JSON::DecUInt16 Transportid; // Transport ID of the transport
|
|
758
|
+
Core::JSON::DecUInt8 Strength; // Signal strength as a percentage
|
|
759
|
+
Core::JSON::DecUInt8 Quality; // Signal quality as a percentage
|
|
760
|
+
DvbctuningparamsInfo Dvbctuningparams; // Parameters required to tune to a DVB-C signal
|
|
761
|
+
DvbstuningparamsInfo Dvbstuningparams; // Parameters required to tune to a DVB-S/S2 signal
|
|
762
|
+
DvbttuningparamsInfo Dvbttuningparams; // Parameters required to tune to a DVB-T/T2 signal
|
|
763
|
+
}; // class TransportInfo
|
|
764
|
+
|
|
765
|
+
// Method params/result classes
|
|
766
|
+
//
|
|
767
|
+
|
|
768
|
+
class CountryconfigData : public Core::JSON::Container {
|
|
769
|
+
public:
|
|
770
|
+
CountryconfigData()
|
|
771
|
+
: Core::JSON::Container()
|
|
772
|
+
{
|
|
773
|
+
_Init();
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
CountryconfigData(const CountryconfigData& _other)
|
|
777
|
+
: Core::JSON::Container()
|
|
778
|
+
, Name(_other.Name)
|
|
779
|
+
, Code(_other.Code)
|
|
780
|
+
{
|
|
781
|
+
_Init();
|
|
782
|
+
}
|
|
783
|
+
|
|
784
|
+
CountryconfigData(CountryconfigData&& _other) noexcept
|
|
785
|
+
: Core::JSON::Container()
|
|
786
|
+
, Name(std::move(_other.Name))
|
|
787
|
+
, Code(std::move(_other.Code))
|
|
788
|
+
{
|
|
789
|
+
_Init();
|
|
790
|
+
}
|
|
791
|
+
|
|
792
|
+
CountryconfigData& operator=(const CountryconfigData& _rhs)
|
|
793
|
+
{
|
|
794
|
+
Name = _rhs.Name;
|
|
795
|
+
Code = _rhs.Code;
|
|
796
|
+
return (*this);
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
CountryconfigData& operator=(CountryconfigData&& _rhs) noexcept
|
|
800
|
+
{
|
|
801
|
+
Name = std::move(_rhs.Name);
|
|
802
|
+
Code = std::move(_rhs.Code);
|
|
803
|
+
return (*this);
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
~CountryconfigData() = default;
|
|
807
|
+
|
|
808
|
+
public:
|
|
809
|
+
bool IsDataValid() const
|
|
810
|
+
{
|
|
811
|
+
return ((Name.IsSet() == true) && (Code.IsSet() == true));
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
private:
|
|
815
|
+
void _Init()
|
|
816
|
+
{
|
|
817
|
+
Add(_T("name"), &Name);
|
|
818
|
+
Add(_T("code"), &Code);
|
|
819
|
+
}
|
|
820
|
+
|
|
821
|
+
public:
|
|
822
|
+
Core::JSON::String Name; // Name of the country as a UTF-8 string
|
|
823
|
+
Core::JSON::DecUInt32 Code; // 3-character ISO code for the country
|
|
824
|
+
}; // class CountryconfigData
|
|
825
|
+
|
|
826
|
+
class EventchangedParamsData : public Core::JSON::Container {
|
|
827
|
+
public:
|
|
828
|
+
EventchangedParamsData()
|
|
829
|
+
: Core::JSON::Container()
|
|
830
|
+
{
|
|
831
|
+
Add(_T("eventtype"), &Eventtype);
|
|
832
|
+
Add(_T("service"), &Service);
|
|
833
|
+
Add(_T("event"), &Event);
|
|
834
|
+
}
|
|
835
|
+
|
|
836
|
+
EventchangedParamsData(const EventchangedParamsData&) = delete;
|
|
837
|
+
EventchangedParamsData(EventchangedParamsData&&) noexcept = delete;
|
|
838
|
+
|
|
839
|
+
EventchangedParamsData& operator=(const EventchangedParamsData&) = delete;
|
|
840
|
+
EventchangedParamsData& operator=(EventchangedParamsData&&) noexcept = delete;
|
|
841
|
+
|
|
842
|
+
~EventchangedParamsData() = default;
|
|
843
|
+
|
|
844
|
+
public:
|
|
845
|
+
bool IsDataValid() const
|
|
846
|
+
{
|
|
847
|
+
return ((Eventtype.IsSet() == true) && ((Service.IsSet() == true) && (Service.IsDataValid() == true)) && ((Event.IsSet() == true) && (Event.IsDataValid() == true)));
|
|
848
|
+
}
|
|
849
|
+
|
|
850
|
+
public:
|
|
851
|
+
Core::JSON::EnumType<EventtypeType> Eventtype; // Event type that's sent as an asynchronous notification
|
|
852
|
+
ServiceInfo Service; // Service information
|
|
853
|
+
EiteventInfo Event; // EIT event information
|
|
854
|
+
}; // class EventchangedParamsData
|
|
855
|
+
|
|
856
|
+
class ExtendedeventinfoData : public Core::JSON::Container {
|
|
857
|
+
public:
|
|
858
|
+
class ExtendedeventitemData : public Core::JSON::Container {
|
|
859
|
+
public:
|
|
860
|
+
ExtendedeventitemData()
|
|
861
|
+
: Core::JSON::Container()
|
|
862
|
+
{
|
|
863
|
+
_Init();
|
|
864
|
+
}
|
|
865
|
+
|
|
866
|
+
ExtendedeventitemData(const ExtendedeventitemData& _other)
|
|
867
|
+
: Core::JSON::Container()
|
|
868
|
+
, Description(_other.Description)
|
|
869
|
+
, Item(_other.Item)
|
|
870
|
+
{
|
|
871
|
+
_Init();
|
|
872
|
+
}
|
|
873
|
+
|
|
874
|
+
ExtendedeventitemData(ExtendedeventitemData&& _other) noexcept
|
|
875
|
+
: Core::JSON::Container()
|
|
876
|
+
, Description(std::move(_other.Description))
|
|
877
|
+
, Item(std::move(_other.Item))
|
|
878
|
+
{
|
|
879
|
+
_Init();
|
|
880
|
+
}
|
|
881
|
+
|
|
882
|
+
ExtendedeventitemData& operator=(const ExtendedeventitemData& _rhs)
|
|
883
|
+
{
|
|
884
|
+
Description = _rhs.Description;
|
|
885
|
+
Item = _rhs.Item;
|
|
886
|
+
return (*this);
|
|
887
|
+
}
|
|
888
|
+
|
|
889
|
+
ExtendedeventitemData& operator=(ExtendedeventitemData&& _rhs) noexcept
|
|
890
|
+
{
|
|
891
|
+
Description = std::move(_rhs.Description);
|
|
892
|
+
Item = std::move(_rhs.Item);
|
|
893
|
+
return (*this);
|
|
894
|
+
}
|
|
895
|
+
|
|
896
|
+
~ExtendedeventitemData() = default;
|
|
897
|
+
|
|
898
|
+
public:
|
|
899
|
+
bool IsDataValid() const
|
|
900
|
+
{
|
|
901
|
+
return ((Description.IsSet() == true) && (Item.IsSet() == true));
|
|
902
|
+
}
|
|
903
|
+
|
|
904
|
+
private:
|
|
905
|
+
void _Init()
|
|
906
|
+
{
|
|
907
|
+
Add(_T("description"), &Description);
|
|
908
|
+
Add(_T("item"), &Item);
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
public:
|
|
912
|
+
Core::JSON::String Description; // Description of the item
|
|
913
|
+
Core::JSON::String Item; // Item text
|
|
914
|
+
}; // class ExtendedeventitemData
|
|
915
|
+
|
|
916
|
+
ExtendedeventinfoData()
|
|
917
|
+
: Core::JSON::Container()
|
|
918
|
+
{
|
|
919
|
+
Add(_T("description"), &Description);
|
|
920
|
+
Add(_T("items"), &Items);
|
|
921
|
+
}
|
|
922
|
+
|
|
923
|
+
ExtendedeventinfoData(const ExtendedeventinfoData&) = delete;
|
|
924
|
+
ExtendedeventinfoData(ExtendedeventinfoData&&) noexcept = delete;
|
|
925
|
+
|
|
926
|
+
ExtendedeventinfoData& operator=(const ExtendedeventinfoData&) = delete;
|
|
927
|
+
ExtendedeventinfoData& operator=(ExtendedeventinfoData&&) noexcept = delete;
|
|
928
|
+
|
|
929
|
+
~ExtendedeventinfoData() = default;
|
|
930
|
+
|
|
931
|
+
public:
|
|
932
|
+
bool IsDataValid() const
|
|
933
|
+
{
|
|
934
|
+
return (true);
|
|
935
|
+
}
|
|
936
|
+
|
|
937
|
+
public:
|
|
938
|
+
Core::JSON::String Description; // Extended event description text
|
|
939
|
+
Core::JSON::ArrayType<ExtendedeventinfoData::ExtendedeventitemData> Items; // An array of extended event item
|
|
940
|
+
}; // class ExtendedeventinfoData
|
|
941
|
+
|
|
942
|
+
class FinishServiceSearchParamsData : public Core::JSON::Container {
|
|
943
|
+
public:
|
|
944
|
+
FinishServiceSearchParamsData()
|
|
945
|
+
: Core::JSON::Container()
|
|
946
|
+
{
|
|
947
|
+
Add(_T("tunertype"), &Tunertype);
|
|
948
|
+
Add(_T("savechanges"), &Savechanges);
|
|
949
|
+
}
|
|
950
|
+
|
|
951
|
+
FinishServiceSearchParamsData(const FinishServiceSearchParamsData&) = delete;
|
|
952
|
+
FinishServiceSearchParamsData(FinishServiceSearchParamsData&&) noexcept = delete;
|
|
953
|
+
|
|
954
|
+
FinishServiceSearchParamsData& operator=(const FinishServiceSearchParamsData&) = delete;
|
|
955
|
+
FinishServiceSearchParamsData& operator=(FinishServiceSearchParamsData&&) noexcept = delete;
|
|
956
|
+
|
|
957
|
+
~FinishServiceSearchParamsData() = default;
|
|
958
|
+
|
|
959
|
+
public:
|
|
960
|
+
bool IsDataValid() const
|
|
961
|
+
{
|
|
962
|
+
return ((Tunertype.IsSet() == true) && (Savechanges.IsSet() == true));
|
|
963
|
+
}
|
|
964
|
+
|
|
965
|
+
public:
|
|
966
|
+
Core::JSON::EnumType<TunertypeType> Tunertype; // Tuner type
|
|
967
|
+
Core::JSON::Boolean Savechanges; // Set true if the services found during the search should be saved
|
|
968
|
+
}; // class FinishServiceSearchParamsData
|
|
969
|
+
|
|
970
|
+
class NowNextEventsData : public Core::JSON::Container {
|
|
971
|
+
public:
|
|
972
|
+
NowNextEventsData()
|
|
973
|
+
: Core::JSON::Container()
|
|
974
|
+
{
|
|
975
|
+
Add(_T("now"), &Now);
|
|
976
|
+
Add(_T("next"), &Next);
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
NowNextEventsData(const NowNextEventsData&) = delete;
|
|
980
|
+
NowNextEventsData(NowNextEventsData&&) noexcept = delete;
|
|
981
|
+
|
|
982
|
+
NowNextEventsData& operator=(const NowNextEventsData&) = delete;
|
|
983
|
+
NowNextEventsData& operator=(NowNextEventsData&&) noexcept = delete;
|
|
984
|
+
|
|
985
|
+
~NowNextEventsData() = default;
|
|
986
|
+
|
|
987
|
+
public:
|
|
988
|
+
bool IsDataValid() const
|
|
989
|
+
{
|
|
990
|
+
return (((Now.IsSet() == false) || (Now.IsDataValid() == true)) && ((Next.IsSet() == false) || (Next.IsDataValid() == true)));
|
|
991
|
+
}
|
|
992
|
+
|
|
993
|
+
public:
|
|
994
|
+
EiteventInfo Now; // EIT event information
|
|
995
|
+
EiteventInfo Next; // EIT event information
|
|
996
|
+
}; // class NowNextEventsData
|
|
997
|
+
|
|
998
|
+
class SearchstatusParamsData : public Core::JSON::Container {
|
|
999
|
+
public:
|
|
1000
|
+
SearchstatusParamsData()
|
|
1001
|
+
: Core::JSON::Container()
|
|
1002
|
+
{
|
|
1003
|
+
Add(_T("handle"), &Handle);
|
|
1004
|
+
Add(_T("eventtype"), &Eventtype);
|
|
1005
|
+
Add(_T("finished"), &Finished);
|
|
1006
|
+
Add(_T("progress"), &Progress);
|
|
1007
|
+
Add(_T("transport"), &Transport);
|
|
1008
|
+
}
|
|
1009
|
+
|
|
1010
|
+
SearchstatusParamsData(const SearchstatusParamsData&) = delete;
|
|
1011
|
+
SearchstatusParamsData(SearchstatusParamsData&&) noexcept = delete;
|
|
1012
|
+
|
|
1013
|
+
SearchstatusParamsData& operator=(const SearchstatusParamsData&) = delete;
|
|
1014
|
+
SearchstatusParamsData& operator=(SearchstatusParamsData&&) noexcept = delete;
|
|
1015
|
+
|
|
1016
|
+
~SearchstatusParamsData() = default;
|
|
1017
|
+
|
|
1018
|
+
public:
|
|
1019
|
+
bool IsDataValid() const
|
|
1020
|
+
{
|
|
1021
|
+
return ((Handle.IsSet() == true) && (Eventtype.IsSet() == true) && (Finished.IsSet() == true) && (Progress.IsSet() == true) && ((Transport.IsSet() == false) || (Transport.IsDataValid() == true)));
|
|
1022
|
+
}
|
|
1023
|
+
|
|
1024
|
+
public:
|
|
1025
|
+
Core::JSON::DecUInt32 Handle; // The handle assigned for the search and to which this information is relevant
|
|
1026
|
+
Core::JSON::EnumType<EventtypeType> Eventtype; // Event type that's sent as an asynchronous notification
|
|
1027
|
+
Core::JSON::Boolean Finished; // Set to true if the service search has finished, false otherwise
|
|
1028
|
+
Core::JSON::DecUInt8 Progress; // Progress of the search expressed as a percentage
|
|
1029
|
+
TransportInfo Transport; // (Version 2) Details for a transport
|
|
1030
|
+
}; // class SearchstatusParamsData
|
|
1031
|
+
|
|
1032
|
+
class ComponentData : public Core::JSON::Container {
|
|
1033
|
+
public:
|
|
1034
|
+
// Type of data contained in this component
|
|
1035
|
+
enum class TypeType : uint8_t {
|
|
1036
|
+
VIDEO,
|
|
1037
|
+
AUDIO,
|
|
1038
|
+
SUBTITLES,
|
|
1039
|
+
TELETEXT,
|
|
1040
|
+
DATA
|
|
1041
|
+
};
|
|
1042
|
+
|
|
1043
|
+
class AudioData : public Core::JSON::Container {
|
|
1044
|
+
public:
|
|
1045
|
+
// Type of the audio contained in the component
|
|
1046
|
+
enum class TypeType : uint8_t {
|
|
1047
|
+
UNDEFINED,
|
|
1048
|
+
CLEAN,
|
|
1049
|
+
HEARINGIMPAIRED,
|
|
1050
|
+
VISUALLYIMPAIRED,
|
|
1051
|
+
UNKNOWN
|
|
1052
|
+
};
|
|
1053
|
+
|
|
1054
|
+
// Audio mode
|
|
1055
|
+
enum class ModeType : uint8_t {
|
|
1056
|
+
MONO,
|
|
1057
|
+
LEFT,
|
|
1058
|
+
RIGHT,
|
|
1059
|
+
STEREO,
|
|
1060
|
+
MULTICHANNEL,
|
|
1061
|
+
UNDEFINED
|
|
1062
|
+
};
|
|
1063
|
+
|
|
1064
|
+
AudioData()
|
|
1065
|
+
: Core::JSON::Container()
|
|
1066
|
+
{
|
|
1067
|
+
_Init();
|
|
1068
|
+
}
|
|
1069
|
+
|
|
1070
|
+
AudioData(const AudioData& _other)
|
|
1071
|
+
: Core::JSON::Container()
|
|
1072
|
+
, Codec(_other.Codec)
|
|
1073
|
+
, Language(_other.Language)
|
|
1074
|
+
, Type(_other.Type)
|
|
1075
|
+
, Mode(_other.Mode)
|
|
1076
|
+
{
|
|
1077
|
+
_Init();
|
|
1078
|
+
}
|
|
1079
|
+
|
|
1080
|
+
AudioData(AudioData&& _other) noexcept
|
|
1081
|
+
: Core::JSON::Container()
|
|
1082
|
+
, Codec(std::move(_other.Codec))
|
|
1083
|
+
, Language(std::move(_other.Language))
|
|
1084
|
+
, Type(std::move(_other.Type))
|
|
1085
|
+
, Mode(std::move(_other.Mode))
|
|
1086
|
+
{
|
|
1087
|
+
_Init();
|
|
1088
|
+
}
|
|
1089
|
+
|
|
1090
|
+
AudioData& operator=(const AudioData& _rhs)
|
|
1091
|
+
{
|
|
1092
|
+
Codec = _rhs.Codec;
|
|
1093
|
+
Language = _rhs.Language;
|
|
1094
|
+
Type = _rhs.Type;
|
|
1095
|
+
Mode = _rhs.Mode;
|
|
1096
|
+
return (*this);
|
|
1097
|
+
}
|
|
1098
|
+
|
|
1099
|
+
AudioData& operator=(AudioData&& _rhs) noexcept
|
|
1100
|
+
{
|
|
1101
|
+
Codec = std::move(_rhs.Codec);
|
|
1102
|
+
Language = std::move(_rhs.Language);
|
|
1103
|
+
Type = std::move(_rhs.Type);
|
|
1104
|
+
Mode = std::move(_rhs.Mode);
|
|
1105
|
+
return (*this);
|
|
1106
|
+
}
|
|
1107
|
+
|
|
1108
|
+
~AudioData() = default;
|
|
1109
|
+
|
|
1110
|
+
public:
|
|
1111
|
+
bool IsDataValid() const
|
|
1112
|
+
{
|
|
1113
|
+
return ((Language.IsSet() == true) && (Type.IsSet() == true) && (Mode.IsSet() == true));
|
|
1114
|
+
}
|
|
1115
|
+
|
|
1116
|
+
private:
|
|
1117
|
+
void _Init()
|
|
1118
|
+
{
|
|
1119
|
+
Add(_T("codec"), &Codec);
|
|
1120
|
+
Add(_T("language"), &Language);
|
|
1121
|
+
Add(_T("type"), &Type);
|
|
1122
|
+
Add(_T("mode"), &Mode);
|
|
1123
|
+
}
|
|
1124
|
+
|
|
1125
|
+
public:
|
|
1126
|
+
Core::JSON::EnumType<CodecType> Codec; // Video or audio codec type
|
|
1127
|
+
Core::JSON::String Language; // ISO 3-char language code
|
|
1128
|
+
Core::JSON::EnumType<ComponentData::AudioData::TypeType> Type; // Type of the audio contained in the component
|
|
1129
|
+
Core::JSON::EnumType<ComponentData::AudioData::ModeType> Mode; // Audio mode
|
|
1130
|
+
}; // class AudioData
|
|
1131
|
+
|
|
1132
|
+
class CodecData : public Core::JSON::Container {
|
|
1133
|
+
public:
|
|
1134
|
+
CodecData()
|
|
1135
|
+
: Core::JSON::Container()
|
|
1136
|
+
{
|
|
1137
|
+
_Init();
|
|
1138
|
+
}
|
|
1139
|
+
|
|
1140
|
+
CodecData(const CodecData& _other)
|
|
1141
|
+
: Core::JSON::Container()
|
|
1142
|
+
, Codec(_other.Codec)
|
|
1143
|
+
{
|
|
1144
|
+
_Init();
|
|
1145
|
+
}
|
|
1146
|
+
|
|
1147
|
+
CodecData(CodecData&& _other) noexcept
|
|
1148
|
+
: Core::JSON::Container()
|
|
1149
|
+
, Codec(std::move(_other.Codec))
|
|
1150
|
+
{
|
|
1151
|
+
_Init();
|
|
1152
|
+
}
|
|
1153
|
+
|
|
1154
|
+
CodecData& operator=(const CodecData& _rhs)
|
|
1155
|
+
{
|
|
1156
|
+
Codec = _rhs.Codec;
|
|
1157
|
+
return (*this);
|
|
1158
|
+
}
|
|
1159
|
+
|
|
1160
|
+
CodecData& operator=(CodecData&& _rhs) noexcept
|
|
1161
|
+
{
|
|
1162
|
+
Codec = std::move(_rhs.Codec);
|
|
1163
|
+
return (*this);
|
|
1164
|
+
}
|
|
1165
|
+
|
|
1166
|
+
~CodecData() = default;
|
|
1167
|
+
|
|
1168
|
+
public:
|
|
1169
|
+
bool IsDataValid() const
|
|
1170
|
+
{
|
|
1171
|
+
return (Codec.IsSet() == true);
|
|
1172
|
+
}
|
|
1173
|
+
|
|
1174
|
+
private:
|
|
1175
|
+
void _Init()
|
|
1176
|
+
{
|
|
1177
|
+
Add(_T("codec"), &Codec);
|
|
1178
|
+
}
|
|
1179
|
+
|
|
1180
|
+
public:
|
|
1181
|
+
Core::JSON::EnumType<CodecType> Codec; // Video or audio codec type
|
|
1182
|
+
}; // class CodecData
|
|
1183
|
+
|
|
1184
|
+
class SubtitlesData : public Core::JSON::Container {
|
|
1185
|
+
public:
|
|
1186
|
+
// Intended TV format for the subtitles
|
|
1187
|
+
enum class FormatType : uint8_t {
|
|
1188
|
+
DEFAULT,
|
|
1189
|
+
E4_3,
|
|
1190
|
+
E16_9,
|
|
1191
|
+
E221_1,
|
|
1192
|
+
HD,
|
|
1193
|
+
HARDOFHEARING,
|
|
1194
|
+
HARDOFHEARING4_3,
|
|
1195
|
+
HARDOFHEARING16_9,
|
|
1196
|
+
HARDOFHEARING221_1,
|
|
1197
|
+
HARDOFHEARINGHD
|
|
1198
|
+
};
|
|
1199
|
+
|
|
1200
|
+
SubtitlesData()
|
|
1201
|
+
: Core::JSON::Container()
|
|
1202
|
+
{
|
|
1203
|
+
_Init();
|
|
1204
|
+
}
|
|
1205
|
+
|
|
1206
|
+
SubtitlesData(const SubtitlesData& _other)
|
|
1207
|
+
: Core::JSON::Container()
|
|
1208
|
+
, Language(_other.Language)
|
|
1209
|
+
, Format(_other.Format)
|
|
1210
|
+
, Compositionpage(_other.Compositionpage)
|
|
1211
|
+
, Ancillarypage(_other.Ancillarypage)
|
|
1212
|
+
{
|
|
1213
|
+
_Init();
|
|
1214
|
+
}
|
|
1215
|
+
|
|
1216
|
+
SubtitlesData(SubtitlesData&& _other) noexcept
|
|
1217
|
+
: Core::JSON::Container()
|
|
1218
|
+
, Language(std::move(_other.Language))
|
|
1219
|
+
, Format(std::move(_other.Format))
|
|
1220
|
+
, Compositionpage(std::move(_other.Compositionpage))
|
|
1221
|
+
, Ancillarypage(std::move(_other.Ancillarypage))
|
|
1222
|
+
{
|
|
1223
|
+
_Init();
|
|
1224
|
+
}
|
|
1225
|
+
|
|
1226
|
+
SubtitlesData& operator=(const SubtitlesData& _rhs)
|
|
1227
|
+
{
|
|
1228
|
+
Language = _rhs.Language;
|
|
1229
|
+
Format = _rhs.Format;
|
|
1230
|
+
Compositionpage = _rhs.Compositionpage;
|
|
1231
|
+
Ancillarypage = _rhs.Ancillarypage;
|
|
1232
|
+
return (*this);
|
|
1233
|
+
}
|
|
1234
|
+
|
|
1235
|
+
SubtitlesData& operator=(SubtitlesData&& _rhs) noexcept
|
|
1236
|
+
{
|
|
1237
|
+
Language = std::move(_rhs.Language);
|
|
1238
|
+
Format = std::move(_rhs.Format);
|
|
1239
|
+
Compositionpage = std::move(_rhs.Compositionpage);
|
|
1240
|
+
Ancillarypage = std::move(_rhs.Ancillarypage);
|
|
1241
|
+
return (*this);
|
|
1242
|
+
}
|
|
1243
|
+
|
|
1244
|
+
~SubtitlesData() = default;
|
|
1245
|
+
|
|
1246
|
+
public:
|
|
1247
|
+
bool IsDataValid() const
|
|
1248
|
+
{
|
|
1249
|
+
return ((Language.IsSet() == true) && (Format.IsSet() == true) && (Compositionpage.IsSet() == true) && (Ancillarypage.IsSet() == true));
|
|
1250
|
+
}
|
|
1251
|
+
|
|
1252
|
+
private:
|
|
1253
|
+
void _Init()
|
|
1254
|
+
{
|
|
1255
|
+
Add(_T("language"), &Language);
|
|
1256
|
+
Add(_T("format"), &Format);
|
|
1257
|
+
Add(_T("compositionpage"), &Compositionpage);
|
|
1258
|
+
Add(_T("ancillarypage"), &Ancillarypage);
|
|
1259
|
+
}
|
|
1260
|
+
|
|
1261
|
+
public:
|
|
1262
|
+
Core::JSON::String Language; // ISO 3-char language code
|
|
1263
|
+
Core::JSON::EnumType<ComponentData::SubtitlesData::FormatType> Format; // Intended TV format for the subtitles
|
|
1264
|
+
Core::JSON::DecUInt16 Compositionpage; // Composition page to be used for subtitles in this component
|
|
1265
|
+
Core::JSON::DecUInt16 Ancillarypage; // Ancillary page to be used for subtitles in this component
|
|
1266
|
+
}; // class SubtitlesData
|
|
1267
|
+
|
|
1268
|
+
class TeletextData : public Core::JSON::Container {
|
|
1269
|
+
public:
|
|
1270
|
+
TeletextData()
|
|
1271
|
+
: Core::JSON::Container()
|
|
1272
|
+
{
|
|
1273
|
+
_Init();
|
|
1274
|
+
}
|
|
1275
|
+
|
|
1276
|
+
TeletextData(const TeletextData& _other)
|
|
1277
|
+
: Core::JSON::Container()
|
|
1278
|
+
, Language(_other.Language)
|
|
1279
|
+
, Type(_other.Type)
|
|
1280
|
+
, Magazine(_other.Magazine)
|
|
1281
|
+
, Page(_other.Page)
|
|
1282
|
+
{
|
|
1283
|
+
_Init();
|
|
1284
|
+
}
|
|
1285
|
+
|
|
1286
|
+
TeletextData(TeletextData&& _other) noexcept
|
|
1287
|
+
: Core::JSON::Container()
|
|
1288
|
+
, Language(std::move(_other.Language))
|
|
1289
|
+
, Type(std::move(_other.Type))
|
|
1290
|
+
, Magazine(std::move(_other.Magazine))
|
|
1291
|
+
, Page(std::move(_other.Page))
|
|
1292
|
+
{
|
|
1293
|
+
_Init();
|
|
1294
|
+
}
|
|
1295
|
+
|
|
1296
|
+
TeletextData& operator=(const TeletextData& _rhs)
|
|
1297
|
+
{
|
|
1298
|
+
Language = _rhs.Language;
|
|
1299
|
+
Type = _rhs.Type;
|
|
1300
|
+
Magazine = _rhs.Magazine;
|
|
1301
|
+
Page = _rhs.Page;
|
|
1302
|
+
return (*this);
|
|
1303
|
+
}
|
|
1304
|
+
|
|
1305
|
+
TeletextData& operator=(TeletextData&& _rhs) noexcept
|
|
1306
|
+
{
|
|
1307
|
+
Language = std::move(_rhs.Language);
|
|
1308
|
+
Type = std::move(_rhs.Type);
|
|
1309
|
+
Magazine = std::move(_rhs.Magazine);
|
|
1310
|
+
Page = std::move(_rhs.Page);
|
|
1311
|
+
return (*this);
|
|
1312
|
+
}
|
|
1313
|
+
|
|
1314
|
+
~TeletextData() = default;
|
|
1315
|
+
|
|
1316
|
+
public:
|
|
1317
|
+
bool IsDataValid() const
|
|
1318
|
+
{
|
|
1319
|
+
return ((Language.IsSet() == true) && (Type.IsSet() == true) && (Magazine.IsSet() == true) && (Page.IsSet() == true));
|
|
1320
|
+
}
|
|
1321
|
+
|
|
1322
|
+
private:
|
|
1323
|
+
void _Init()
|
|
1324
|
+
{
|
|
1325
|
+
Add(_T("language"), &Language);
|
|
1326
|
+
Add(_T("type"), &Type);
|
|
1327
|
+
Add(_T("magazine"), &Magazine);
|
|
1328
|
+
Add(_T("page"), &Page);
|
|
1329
|
+
}
|
|
1330
|
+
|
|
1331
|
+
public:
|
|
1332
|
+
Core::JSON::String Language; // ISO 3-char language code
|
|
1333
|
+
Core::JSON::DecUInt8 Type; // Type of teletext data
|
|
1334
|
+
Core::JSON::DecUInt8 Magazine; // Magazine number for this type and language
|
|
1335
|
+
Core::JSON::DecUInt8 Page; // Page number for this type and language
|
|
1336
|
+
}; // class TeletextData
|
|
1337
|
+
|
|
1338
|
+
ComponentData()
|
|
1339
|
+
: Core::JSON::Container()
|
|
1340
|
+
{
|
|
1341
|
+
_Init();
|
|
1342
|
+
}
|
|
1343
|
+
|
|
1344
|
+
ComponentData(const ComponentData& _other)
|
|
1345
|
+
: Core::JSON::Container()
|
|
1346
|
+
, Type(_other.Type)
|
|
1347
|
+
, Tags(_other.Tags)
|
|
1348
|
+
, Pid(_other.Pid)
|
|
1349
|
+
, Video(_other.Video)
|
|
1350
|
+
, Audio(_other.Audio)
|
|
1351
|
+
, Subtitles(_other.Subtitles)
|
|
1352
|
+
, Teletext(_other.Teletext)
|
|
1353
|
+
{
|
|
1354
|
+
_Init();
|
|
1355
|
+
}
|
|
1356
|
+
|
|
1357
|
+
ComponentData(ComponentData&& _other) noexcept
|
|
1358
|
+
: Core::JSON::Container()
|
|
1359
|
+
, Type(std::move(_other.Type))
|
|
1360
|
+
, Tags(std::move(_other.Tags))
|
|
1361
|
+
, Pid(std::move(_other.Pid))
|
|
1362
|
+
, Video(std::move(_other.Video))
|
|
1363
|
+
, Audio(std::move(_other.Audio))
|
|
1364
|
+
, Subtitles(std::move(_other.Subtitles))
|
|
1365
|
+
, Teletext(std::move(_other.Teletext))
|
|
1366
|
+
{
|
|
1367
|
+
_Init();
|
|
1368
|
+
}
|
|
1369
|
+
|
|
1370
|
+
ComponentData& operator=(const ComponentData& _rhs)
|
|
1371
|
+
{
|
|
1372
|
+
Type = _rhs.Type;
|
|
1373
|
+
Tags = _rhs.Tags;
|
|
1374
|
+
Pid = _rhs.Pid;
|
|
1375
|
+
Video = _rhs.Video;
|
|
1376
|
+
Audio = _rhs.Audio;
|
|
1377
|
+
Subtitles = _rhs.Subtitles;
|
|
1378
|
+
Teletext = _rhs.Teletext;
|
|
1379
|
+
return (*this);
|
|
1380
|
+
}
|
|
1381
|
+
|
|
1382
|
+
ComponentData& operator=(ComponentData&& _rhs) noexcept
|
|
1383
|
+
{
|
|
1384
|
+
Type = std::move(_rhs.Type);
|
|
1385
|
+
Tags = std::move(_rhs.Tags);
|
|
1386
|
+
Pid = std::move(_rhs.Pid);
|
|
1387
|
+
Video = std::move(_rhs.Video);
|
|
1388
|
+
Audio = std::move(_rhs.Audio);
|
|
1389
|
+
Subtitles = std::move(_rhs.Subtitles);
|
|
1390
|
+
Teletext = std::move(_rhs.Teletext);
|
|
1391
|
+
return (*this);
|
|
1392
|
+
}
|
|
1393
|
+
|
|
1394
|
+
~ComponentData() = default;
|
|
1395
|
+
|
|
1396
|
+
public:
|
|
1397
|
+
bool IsDataValid() const
|
|
1398
|
+
{
|
|
1399
|
+
return ((Type.IsSet() == true) && (Pid.IsSet() == true) && ((Video.IsSet() == false) || (Video.IsDataValid() == true)) && ((Audio.IsSet() == false) || (Audio.IsDataValid() == true)) && ((Subtitles.IsSet() == false) || (Subtitles.IsDataValid() == true)) && ((Teletext.IsSet() == false) || (Teletext.IsDataValid() == true)));
|
|
1400
|
+
}
|
|
1401
|
+
|
|
1402
|
+
private:
|
|
1403
|
+
void _Init()
|
|
1404
|
+
{
|
|
1405
|
+
Add(_T("type"), &Type);
|
|
1406
|
+
Add(_T("tags"), &Tags);
|
|
1407
|
+
Add(_T("pid"), &Pid);
|
|
1408
|
+
Add(_T("video"), &Video);
|
|
1409
|
+
Add(_T("audio"), &Audio);
|
|
1410
|
+
Add(_T("subtitles"), &Subtitles);
|
|
1411
|
+
Add(_T("teletext"), &Teletext);
|
|
1412
|
+
}
|
|
1413
|
+
|
|
1414
|
+
public:
|
|
1415
|
+
Core::JSON::EnumType<ComponentData::TypeType> Type; // Type of data contained in this component
|
|
1416
|
+
Core::JSON::ArrayType<Core::JSON::DecUInt8> Tags; // Array of component tags
|
|
1417
|
+
Core::JSON::DecUInt16 Pid; // PID of the component
|
|
1418
|
+
ComponentData::CodecData Video; // Video related information for a video component
|
|
1419
|
+
ComponentData::AudioData Audio; // Audio related information for an audio component
|
|
1420
|
+
ComponentData::SubtitlesData Subtitles; // DVB subtitle related information for a subtitle component
|
|
1421
|
+
ComponentData::TeletextData Teletext; // Teletext related information for a teletext component
|
|
1422
|
+
}; // class ComponentData
|
|
1423
|
+
|
|
1424
|
+
class SignalInfoData : public Core::JSON::Container {
|
|
1425
|
+
public:
|
|
1426
|
+
SignalInfoData()
|
|
1427
|
+
: Core::JSON::Container()
|
|
1428
|
+
{
|
|
1429
|
+
Add(_T("locked"), &Locked);
|
|
1430
|
+
Add(_T("strength"), &Strength);
|
|
1431
|
+
Add(_T("quality"), &Quality);
|
|
1432
|
+
}
|
|
1433
|
+
|
|
1434
|
+
SignalInfoData(const SignalInfoData&) = delete;
|
|
1435
|
+
SignalInfoData(SignalInfoData&&) noexcept = delete;
|
|
1436
|
+
|
|
1437
|
+
SignalInfoData& operator=(const SignalInfoData&) = delete;
|
|
1438
|
+
SignalInfoData& operator=(SignalInfoData&&) noexcept = delete;
|
|
1439
|
+
|
|
1440
|
+
~SignalInfoData() = default;
|
|
1441
|
+
|
|
1442
|
+
public:
|
|
1443
|
+
bool IsDataValid() const
|
|
1444
|
+
{
|
|
1445
|
+
return ((Locked.IsSet() == true) && (Strength.IsSet() == true) && (Quality.IsSet() == true));
|
|
1446
|
+
}
|
|
1447
|
+
|
|
1448
|
+
public:
|
|
1449
|
+
Core::JSON::Boolean Locked; // Tuned locked status
|
|
1450
|
+
Core::JSON::DecUInt8 Strength; // The signal strength as a percentage
|
|
1451
|
+
Core::JSON::DecUInt8 Quality; // The signal quality as a percentage
|
|
1452
|
+
}; // class SignalInfoData
|
|
1453
|
+
|
|
1454
|
+
class StartPlayingParamsData : public Core::JSON::Container {
|
|
1455
|
+
public:
|
|
1456
|
+
StartPlayingParamsData()
|
|
1457
|
+
: Core::JSON::Container()
|
|
1458
|
+
{
|
|
1459
|
+
Add(_T("dvburi"), &Dvburi);
|
|
1460
|
+
Add(_T("lcn"), &Lcn);
|
|
1461
|
+
Add(_T("monitoronly"), &Monitoronly);
|
|
1462
|
+
}
|
|
1463
|
+
|
|
1464
|
+
StartPlayingParamsData(const StartPlayingParamsData&) = delete;
|
|
1465
|
+
StartPlayingParamsData(StartPlayingParamsData&&) noexcept = delete;
|
|
1466
|
+
|
|
1467
|
+
StartPlayingParamsData& operator=(const StartPlayingParamsData&) = delete;
|
|
1468
|
+
StartPlayingParamsData& operator=(StartPlayingParamsData&&) noexcept = delete;
|
|
1469
|
+
|
|
1470
|
+
~StartPlayingParamsData() = default;
|
|
1471
|
+
|
|
1472
|
+
public:
|
|
1473
|
+
bool IsDataValid() const
|
|
1474
|
+
{
|
|
1475
|
+
return (true);
|
|
1476
|
+
}
|
|
1477
|
+
|
|
1478
|
+
public:
|
|
1479
|
+
Core::JSON::String Dvburi; // DVB triplet of the form a.b.c, where 'a' is the original network ID, 'b' is the transport ID and 'c' is the service ID, in decimal
|
|
1480
|
+
Core::JSON::DecUInt16 Lcn; // LCN of the service to be tuned to
|
|
1481
|
+
Core::JSON::Boolean Monitoronly; // (Version 2) set to 'true' to monitor SI/PSI data only. Will default to 'false' if not defined
|
|
1482
|
+
}; // class StartPlayingParamsData
|
|
1483
|
+
|
|
1484
|
+
class StartServiceSearchParamsData : public Core::JSON::Container {
|
|
1485
|
+
public:
|
|
1486
|
+
// Supported Search Type
|
|
1487
|
+
enum class SearchtypeType : uint8_t {
|
|
1488
|
+
FREQUENCY,
|
|
1489
|
+
NETWORK
|
|
1490
|
+
};
|
|
1491
|
+
|
|
1492
|
+
StartServiceSearchParamsData()
|
|
1493
|
+
: Core::JSON::Container()
|
|
1494
|
+
{
|
|
1495
|
+
Add(_T("tunertype"), &Tunertype);
|
|
1496
|
+
Add(_T("searchtype"), &Searchtype);
|
|
1497
|
+
Add(_T("retune"), &Retune);
|
|
1498
|
+
Add(_T("usetuningparams"), &Usetuningparams);
|
|
1499
|
+
Add(_T("dvbstuningparams"), &Dvbstuningparams);
|
|
1500
|
+
Add(_T("dvbctuningparams"), &Dvbctuningparams);
|
|
1501
|
+
Add(_T("dvbttuningparams"), &Dvbttuningparams);
|
|
1502
|
+
}
|
|
1503
|
+
|
|
1504
|
+
StartServiceSearchParamsData(const StartServiceSearchParamsData&) = delete;
|
|
1505
|
+
StartServiceSearchParamsData(StartServiceSearchParamsData&&) noexcept = delete;
|
|
1506
|
+
|
|
1507
|
+
StartServiceSearchParamsData& operator=(const StartServiceSearchParamsData&) = delete;
|
|
1508
|
+
StartServiceSearchParamsData& operator=(StartServiceSearchParamsData&&) noexcept = delete;
|
|
1509
|
+
|
|
1510
|
+
~StartServiceSearchParamsData() = default;
|
|
1511
|
+
|
|
1512
|
+
public:
|
|
1513
|
+
bool IsDataValid() const
|
|
1514
|
+
{
|
|
1515
|
+
return ((Tunertype.IsSet() == true) && (Searchtype.IsSet() == true) && (Retune.IsSet() == true) && (Usetuningparams.IsSet() == true) && ((Dvbstuningparams.IsSet() == false) || (Dvbstuningparams.IsDataValid() == true)) && ((Dvbctuningparams.IsSet() == false) || (Dvbctuningparams.IsDataValid() == true)) && ((Dvbttuningparams.IsSet() == false) || (Dvbttuningparams.IsDataValid() == true)));
|
|
1516
|
+
}
|
|
1517
|
+
|
|
1518
|
+
public:
|
|
1519
|
+
Core::JSON::EnumType<TunertypeType> Tunertype; // Tuner type
|
|
1520
|
+
Core::JSON::EnumType<StartServiceSearchParamsData::SearchtypeType> Searchtype; // Supported Search Type
|
|
1521
|
+
Core::JSON::Boolean Retune; // Set to true if current services are to be replaced in the database, false if the scan is to update the existing services
|
|
1522
|
+
Core::JSON::Boolean Usetuningparams; // Set to true if the optional tuning parameters are defined
|
|
1523
|
+
DvbstuningparamsInfo Dvbstuningparams; // Parameters required to tune to a DVB-S/S2 signal
|
|
1524
|
+
DvbctuningparamsInfo Dvbctuningparams; // Parameters required to tune to a DVB-C signal
|
|
1525
|
+
DvbttuningparamsInfo Dvbttuningparams; // Parameters required to tune to a DVB-T/T2 signal
|
|
1526
|
+
}; // class StartServiceSearchParamsData
|
|
1527
|
+
|
|
1528
|
+
class StatusData : public Core::JSON::Container {
|
|
1529
|
+
public:
|
|
1530
|
+
StatusData()
|
|
1531
|
+
: Core::JSON::Container()
|
|
1532
|
+
{
|
|
1533
|
+
Add(_T("tuner"), &Tuner);
|
|
1534
|
+
Add(_T("demux"), &Demux);
|
|
1535
|
+
Add(_T("pmtpid"), &Pmtpid);
|
|
1536
|
+
Add(_T("dvburi"), &Dvburi);
|
|
1537
|
+
Add(_T("lcn"), &Lcn);
|
|
1538
|
+
}
|
|
1539
|
+
|
|
1540
|
+
StatusData(const StatusData&) = delete;
|
|
1541
|
+
StatusData(StatusData&&) noexcept = delete;
|
|
1542
|
+
|
|
1543
|
+
StatusData& operator=(const StatusData&) = delete;
|
|
1544
|
+
StatusData& operator=(StatusData&&) noexcept = delete;
|
|
1545
|
+
|
|
1546
|
+
~StatusData() = default;
|
|
1547
|
+
|
|
1548
|
+
public:
|
|
1549
|
+
bool IsDataValid() const
|
|
1550
|
+
{
|
|
1551
|
+
return ((Tuner.IsSet() == true) && (Demux.IsSet() == true) && (Pmtpid.IsSet() == true) && (Dvburi.IsSet() == true) && (Lcn.IsSet() == true));
|
|
1552
|
+
}
|
|
1553
|
+
|
|
1554
|
+
public:
|
|
1555
|
+
Core::JSON::DecUInt8 Tuner; // The tuner id used by the play handle
|
|
1556
|
+
Core::JSON::DecUInt8 Demux; // The demux id used by the play handle
|
|
1557
|
+
Core::JSON::DecUInt16 Pmtpid; // The PMT PID of the service being played
|
|
1558
|
+
Core::JSON::String Dvburi; // DVB triplet of the form a.b.c, where 'a' is the original network ID, 'b' is the transport ID and 'c' is the service ID, in decimal
|
|
1559
|
+
Core::JSON::DecUInt16 Lcn; // LCN of the service being played
|
|
1560
|
+
}; // class StatusData
|
|
1561
|
+
|
|
1562
|
+
} // namespace DTV
|
|
1563
|
+
|
|
1564
|
+
POP_WARNING()
|
|
1565
|
+
|
|
1566
|
+
} // namespace JsonData
|
|
1567
|
+
|
|
1568
|
+
// Enum conversion handlers
|
|
1569
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::LnbtypeType)
|
|
1570
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::LnbpowerType)
|
|
1571
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::Diseqc_toneType)
|
|
1572
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::Diseqc_cswitchType)
|
|
1573
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::TunertypeType)
|
|
1574
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::StartServiceSearchParamsData::SearchtypeType)
|
|
1575
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::PolarityType)
|
|
1576
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::FecType)
|
|
1577
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::DvbsmodulationType)
|
|
1578
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::DvbcmodulationType)
|
|
1579
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::DvbtbandwidthType)
|
|
1580
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::OfdmmodeType)
|
|
1581
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::ServicetypeType)
|
|
1582
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::RunningstatusType)
|
|
1583
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::ComponentData::TypeType)
|
|
1584
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::CodecType)
|
|
1585
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::ComponentData::AudioData::TypeType)
|
|
1586
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::ComponentData::AudioData::ModeType)
|
|
1587
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::ComponentData::SubtitlesData::FormatType)
|
|
1588
|
+
ENUM_CONVERSION_HANDLER(JsonData::DTV::EventtypeType)
|
|
1589
|
+
|
|
1590
|
+
}
|
|
1591
|
+
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
// C++ types for DeviceIdentification API.
|
|
2
|
+
// Generated automatically from 'IDeviceIdentification.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDeviceIdentification.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DeviceIdentification {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class DeviceInfoData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
DeviceInfoData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
DeviceInfoData(const DeviceInfoData& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, DeviceID(_other.DeviceID)
|
|
33
|
+
, FirmwareVersion(_other.FirmwareVersion)
|
|
34
|
+
, Chipset(_other.Chipset)
|
|
35
|
+
{
|
|
36
|
+
_Init();
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
DeviceInfoData(DeviceInfoData&& _other) noexcept
|
|
40
|
+
: Core::JSON::Container()
|
|
41
|
+
, DeviceID(std::move(_other.DeviceID))
|
|
42
|
+
, FirmwareVersion(std::move(_other.FirmwareVersion))
|
|
43
|
+
, Chipset(std::move(_other.Chipset))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
DeviceInfoData(const Exchange::IDeviceIdentification::DeviceInfo& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
DeviceID = _other.deviceID;
|
|
52
|
+
if (_other.firmwareVersion.IsSet() == true) {
|
|
53
|
+
FirmwareVersion = _other.firmwareVersion.Value();
|
|
54
|
+
}
|
|
55
|
+
if (_other.chipset.IsSet() == true) {
|
|
56
|
+
Chipset = _other.chipset.Value();
|
|
57
|
+
}
|
|
58
|
+
_Init();
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
DeviceInfoData& operator=(const DeviceInfoData& _rhs)
|
|
62
|
+
{
|
|
63
|
+
DeviceID = _rhs.DeviceID;
|
|
64
|
+
if (_rhs.FirmwareVersion.IsSet() == true) {
|
|
65
|
+
FirmwareVersion = _rhs.FirmwareVersion;
|
|
66
|
+
}
|
|
67
|
+
if (_rhs.Chipset.IsSet() == true) {
|
|
68
|
+
Chipset = _rhs.Chipset;
|
|
69
|
+
}
|
|
70
|
+
return (*this);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
DeviceInfoData& operator=(DeviceInfoData&& _rhs) noexcept
|
|
74
|
+
{
|
|
75
|
+
DeviceID = std::move(_rhs.DeviceID);
|
|
76
|
+
FirmwareVersion = std::move(_rhs.FirmwareVersion);
|
|
77
|
+
Chipset = std::move(_rhs.Chipset);
|
|
78
|
+
return (*this);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
DeviceInfoData& operator=(const Exchange::IDeviceIdentification::DeviceInfo& _rhs)
|
|
82
|
+
{
|
|
83
|
+
DeviceID = _rhs.deviceID;
|
|
84
|
+
if (_rhs.firmwareVersion.IsSet() == true) {
|
|
85
|
+
FirmwareVersion = _rhs.firmwareVersion.Value();
|
|
86
|
+
}
|
|
87
|
+
if (_rhs.chipset.IsSet() == true) {
|
|
88
|
+
Chipset = _rhs.chipset.Value();
|
|
89
|
+
}
|
|
90
|
+
return (*this);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
operator Exchange::IDeviceIdentification::DeviceInfo() const
|
|
94
|
+
{
|
|
95
|
+
Exchange::IDeviceIdentification::DeviceInfo _value{};
|
|
96
|
+
_value.deviceID = DeviceID;
|
|
97
|
+
if (FirmwareVersion.IsSet() == true) {
|
|
98
|
+
_value.firmwareVersion = FirmwareVersion;
|
|
99
|
+
}
|
|
100
|
+
if (Chipset.IsSet() == true) {
|
|
101
|
+
_value.chipset = Chipset;
|
|
102
|
+
}
|
|
103
|
+
return (_value);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
~DeviceInfoData() = default;
|
|
107
|
+
|
|
108
|
+
public:
|
|
109
|
+
bool IsDataValid() const
|
|
110
|
+
{
|
|
111
|
+
return (DeviceID.IsSet() == true);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
private:
|
|
115
|
+
void _Init()
|
|
116
|
+
{
|
|
117
|
+
Add(_T("deviceid"), &DeviceID);
|
|
118
|
+
Add(_T("firmwareversion"), &FirmwareVersion);
|
|
119
|
+
Add(_T("chipset"), &Chipset);
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
public:
|
|
123
|
+
Core::JSON::String DeviceID; // Device ID
|
|
124
|
+
Core::JSON::String FirmwareVersion; // Version of the device firmware
|
|
125
|
+
Core::JSON::String Chipset; // Chipset used for this device
|
|
126
|
+
}; // class DeviceInfoData
|
|
127
|
+
|
|
128
|
+
} // namespace DeviceIdentification
|
|
129
|
+
|
|
130
|
+
POP_WARNING()
|
|
131
|
+
|
|
132
|
+
} // namespace JsonData
|
|
133
|
+
|
|
134
|
+
}
|
|
135
|
+
|
|
@@ -0,0 +1,1184 @@
|
|
|
1
|
+
// C++ types for Device Info API.
|
|
2
|
+
// Generated automatically from 'DeviceInfo.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DeviceInfo {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Audio capability
|
|
23
|
+
enum class AudiocapabilityType : uint8_t {
|
|
24
|
+
NONE,
|
|
25
|
+
ATMOS,
|
|
26
|
+
DD,
|
|
27
|
+
DDPLUS,
|
|
28
|
+
DAD,
|
|
29
|
+
DAPV2,
|
|
30
|
+
MS12
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
// Audio output supported by the device
|
|
34
|
+
enum class AudioportType : uint8_t {
|
|
35
|
+
OTHER,
|
|
36
|
+
RF_MODULATOR,
|
|
37
|
+
ANALOG,
|
|
38
|
+
SPDIF0,
|
|
39
|
+
HDMI0,
|
|
40
|
+
HDMI1,
|
|
41
|
+
DISPLAYPORT
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
// HDCP support
|
|
45
|
+
enum class CopyprotectionType : uint8_t {
|
|
46
|
+
HDCP_UNAVAILABLE,
|
|
47
|
+
HDCP_14,
|
|
48
|
+
HDCP_20,
|
|
49
|
+
HDCP_21,
|
|
50
|
+
HDCP_22
|
|
51
|
+
};
|
|
52
|
+
|
|
53
|
+
// MS12 audio capability
|
|
54
|
+
enum class Ms12capabilityType : uint8_t {
|
|
55
|
+
NONE,
|
|
56
|
+
DOLBYVOLUME,
|
|
57
|
+
INTELIGENTEQUALIZER,
|
|
58
|
+
DIALOGUEENHANCER
|
|
59
|
+
};
|
|
60
|
+
|
|
61
|
+
// MS12 Profile
|
|
62
|
+
enum class Ms12profileType : uint8_t {
|
|
63
|
+
NONE,
|
|
64
|
+
MUSIC,
|
|
65
|
+
MOVIE,
|
|
66
|
+
VOICE
|
|
67
|
+
};
|
|
68
|
+
|
|
69
|
+
// Resolution supported by the device
|
|
70
|
+
enum class Output_resolutionType : uint8_t {
|
|
71
|
+
UNKNOWN,
|
|
72
|
+
E480I,
|
|
73
|
+
E480P,
|
|
74
|
+
E576I,
|
|
75
|
+
E576P,
|
|
76
|
+
E576P50,
|
|
77
|
+
E720P,
|
|
78
|
+
E720P24,
|
|
79
|
+
E720P25,
|
|
80
|
+
E720P30,
|
|
81
|
+
E720P50,
|
|
82
|
+
E720P60,
|
|
83
|
+
E1080I,
|
|
84
|
+
E1080I25,
|
|
85
|
+
E1080I50,
|
|
86
|
+
E1080I60,
|
|
87
|
+
E1080P,
|
|
88
|
+
E1080P24,
|
|
89
|
+
E1080P25,
|
|
90
|
+
E1080P30,
|
|
91
|
+
E1080P50,
|
|
92
|
+
E1080P60,
|
|
93
|
+
E2160P24,
|
|
94
|
+
E2160P25,
|
|
95
|
+
E2160P30,
|
|
96
|
+
E2160P50,
|
|
97
|
+
E2160P60,
|
|
98
|
+
E4320P30,
|
|
99
|
+
E4320P60
|
|
100
|
+
};
|
|
101
|
+
|
|
102
|
+
// Video output supported by the device
|
|
103
|
+
enum class VideodisplayType : uint8_t {
|
|
104
|
+
OTHER,
|
|
105
|
+
RF_MODULATOR,
|
|
106
|
+
COMPOSITE,
|
|
107
|
+
SVIDEO,
|
|
108
|
+
COMPONET,
|
|
109
|
+
SCART_RGB,
|
|
110
|
+
HDMI0,
|
|
111
|
+
HDMI1,
|
|
112
|
+
DISPLAYPORT
|
|
113
|
+
};
|
|
114
|
+
|
|
115
|
+
// Common classes
|
|
116
|
+
//
|
|
117
|
+
|
|
118
|
+
class AudiocapabilitiesParamsInfo : public Core::JSON::Container {
|
|
119
|
+
public:
|
|
120
|
+
AudiocapabilitiesParamsInfo()
|
|
121
|
+
: Core::JSON::Container()
|
|
122
|
+
{
|
|
123
|
+
Add(_T("audioPort"), &AudioPort);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
AudiocapabilitiesParamsInfo(const AudiocapabilitiesParamsInfo&) = delete;
|
|
127
|
+
AudiocapabilitiesParamsInfo(AudiocapabilitiesParamsInfo&&) noexcept = delete;
|
|
128
|
+
|
|
129
|
+
AudiocapabilitiesParamsInfo& operator=(const AudiocapabilitiesParamsInfo&) = delete;
|
|
130
|
+
AudiocapabilitiesParamsInfo& operator=(AudiocapabilitiesParamsInfo&&) noexcept = delete;
|
|
131
|
+
|
|
132
|
+
~AudiocapabilitiesParamsInfo() = default;
|
|
133
|
+
|
|
134
|
+
public:
|
|
135
|
+
bool IsDataValid() const
|
|
136
|
+
{
|
|
137
|
+
return (AudioPort.IsSet() == true);
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
public:
|
|
141
|
+
Core::JSON::EnumType<AudioportType> AudioPort; // Audio output supported by the device
|
|
142
|
+
}; // class AudiocapabilitiesParamsInfo
|
|
143
|
+
|
|
144
|
+
class FriendlynameInfo : public Core::JSON::Container {
|
|
145
|
+
public:
|
|
146
|
+
FriendlynameInfo()
|
|
147
|
+
: Core::JSON::Container()
|
|
148
|
+
{
|
|
149
|
+
Add(_T("name"), &Name);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
FriendlynameInfo(const FriendlynameInfo&) = delete;
|
|
153
|
+
FriendlynameInfo(FriendlynameInfo&&) noexcept = delete;
|
|
154
|
+
|
|
155
|
+
FriendlynameInfo& operator=(const FriendlynameInfo&) = delete;
|
|
156
|
+
FriendlynameInfo& operator=(FriendlynameInfo&&) noexcept = delete;
|
|
157
|
+
|
|
158
|
+
~FriendlynameInfo() = default;
|
|
159
|
+
|
|
160
|
+
public:
|
|
161
|
+
bool IsDataValid() const
|
|
162
|
+
{
|
|
163
|
+
return (Name.IsSet() == true);
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
public:
|
|
167
|
+
Core::JSON::String Name; // Device friendly name
|
|
168
|
+
}; // class FriendlynameInfo
|
|
169
|
+
|
|
170
|
+
class SupportedresolutionsParamsInfo : public Core::JSON::Container {
|
|
171
|
+
public:
|
|
172
|
+
SupportedresolutionsParamsInfo()
|
|
173
|
+
: Core::JSON::Container()
|
|
174
|
+
{
|
|
175
|
+
Add(_T("videoDisplay"), &VideoDisplay);
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
SupportedresolutionsParamsInfo(const SupportedresolutionsParamsInfo&) = delete;
|
|
179
|
+
SupportedresolutionsParamsInfo(SupportedresolutionsParamsInfo&&) noexcept = delete;
|
|
180
|
+
|
|
181
|
+
SupportedresolutionsParamsInfo& operator=(const SupportedresolutionsParamsInfo&) = delete;
|
|
182
|
+
SupportedresolutionsParamsInfo& operator=(SupportedresolutionsParamsInfo&&) noexcept = delete;
|
|
183
|
+
|
|
184
|
+
~SupportedresolutionsParamsInfo() = default;
|
|
185
|
+
|
|
186
|
+
public:
|
|
187
|
+
bool IsDataValid() const
|
|
188
|
+
{
|
|
189
|
+
return (VideoDisplay.IsSet() == true);
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
public:
|
|
193
|
+
Core::JSON::EnumType<VideodisplayType> VideoDisplay; // Video output supported by the device
|
|
194
|
+
}; // class SupportedresolutionsParamsInfo
|
|
195
|
+
|
|
196
|
+
// Method params/result classes
|
|
197
|
+
//
|
|
198
|
+
|
|
199
|
+
class AddressesData : public Core::JSON::Container {
|
|
200
|
+
public:
|
|
201
|
+
AddressesData()
|
|
202
|
+
: Core::JSON::Container()
|
|
203
|
+
{
|
|
204
|
+
_Init();
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
AddressesData(const AddressesData& _other)
|
|
208
|
+
: Core::JSON::Container()
|
|
209
|
+
, Name(_other.Name)
|
|
210
|
+
, Mac(_other.Mac)
|
|
211
|
+
, Ip(_other.Ip)
|
|
212
|
+
{
|
|
213
|
+
_Init();
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
AddressesData(AddressesData&& _other) noexcept
|
|
217
|
+
: Core::JSON::Container()
|
|
218
|
+
, Name(std::move(_other.Name))
|
|
219
|
+
, Mac(std::move(_other.Mac))
|
|
220
|
+
, Ip(std::move(_other.Ip))
|
|
221
|
+
{
|
|
222
|
+
_Init();
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
AddressesData& operator=(const AddressesData& _rhs)
|
|
226
|
+
{
|
|
227
|
+
Name = _rhs.Name;
|
|
228
|
+
Mac = _rhs.Mac;
|
|
229
|
+
Ip = _rhs.Ip;
|
|
230
|
+
return (*this);
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
AddressesData& operator=(AddressesData&& _rhs) noexcept
|
|
234
|
+
{
|
|
235
|
+
Name = std::move(_rhs.Name);
|
|
236
|
+
Mac = std::move(_rhs.Mac);
|
|
237
|
+
Ip = std::move(_rhs.Ip);
|
|
238
|
+
return (*this);
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
~AddressesData() = default;
|
|
242
|
+
|
|
243
|
+
public:
|
|
244
|
+
bool IsDataValid() const
|
|
245
|
+
{
|
|
246
|
+
return ((Name.IsSet() == true) && (Mac.IsSet() == true));
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
private:
|
|
250
|
+
void _Init()
|
|
251
|
+
{
|
|
252
|
+
Add(_T("name"), &Name);
|
|
253
|
+
Add(_T("mac"), &Mac);
|
|
254
|
+
Add(_T("ip"), &Ip);
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
public:
|
|
258
|
+
Core::JSON::String Name; // Interface name
|
|
259
|
+
Core::JSON::String Mac; // Interface MAC address
|
|
260
|
+
Core::JSON::ArrayType<Core::JSON::String> Ip; // An array of Interface IP address
|
|
261
|
+
}; // class AddressesData
|
|
262
|
+
|
|
263
|
+
class AudiocapabilitiesResultData : public Core::JSON::Container {
|
|
264
|
+
public:
|
|
265
|
+
AudiocapabilitiesResultData()
|
|
266
|
+
: Core::JSON::Container()
|
|
267
|
+
{
|
|
268
|
+
Add(_T("AudioCapabilities"), &AudioCapabilities);
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
AudiocapabilitiesResultData(const AudiocapabilitiesResultData&) = delete;
|
|
272
|
+
AudiocapabilitiesResultData(AudiocapabilitiesResultData&&) noexcept = delete;
|
|
273
|
+
|
|
274
|
+
AudiocapabilitiesResultData& operator=(const AudiocapabilitiesResultData&) = delete;
|
|
275
|
+
AudiocapabilitiesResultData& operator=(AudiocapabilitiesResultData&&) noexcept = delete;
|
|
276
|
+
|
|
277
|
+
~AudiocapabilitiesResultData() = default;
|
|
278
|
+
|
|
279
|
+
public:
|
|
280
|
+
bool IsDataValid() const
|
|
281
|
+
{
|
|
282
|
+
return (AudioCapabilities.IsSet() == true);
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
public:
|
|
286
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<AudiocapabilityType>> AudioCapabilities; // An array of audio capabilities
|
|
287
|
+
}; // class AudiocapabilitiesResultData
|
|
288
|
+
|
|
289
|
+
class DefaultresolutionResultData : public Core::JSON::Container {
|
|
290
|
+
public:
|
|
291
|
+
DefaultresolutionResultData()
|
|
292
|
+
: Core::JSON::Container()
|
|
293
|
+
{
|
|
294
|
+
Add(_T("defaultResolution"), &DefaultResolution);
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
DefaultresolutionResultData(const DefaultresolutionResultData&) = delete;
|
|
298
|
+
DefaultresolutionResultData(DefaultresolutionResultData&&) noexcept = delete;
|
|
299
|
+
|
|
300
|
+
DefaultresolutionResultData& operator=(const DefaultresolutionResultData&) = delete;
|
|
301
|
+
DefaultresolutionResultData& operator=(DefaultresolutionResultData&&) noexcept = delete;
|
|
302
|
+
|
|
303
|
+
~DefaultresolutionResultData() = default;
|
|
304
|
+
|
|
305
|
+
public:
|
|
306
|
+
bool IsDataValid() const
|
|
307
|
+
{
|
|
308
|
+
return (DefaultResolution.IsSet() == true);
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
public:
|
|
312
|
+
Core::JSON::EnumType<Output_resolutionType> DefaultResolution; // Resolution supported by the device
|
|
313
|
+
}; // class DefaultresolutionResultData
|
|
314
|
+
|
|
315
|
+
class DeviceaudiocapabilitiesData : public Core::JSON::Container {
|
|
316
|
+
public:
|
|
317
|
+
class AudiooutputcapabilitiesData : public Core::JSON::Container {
|
|
318
|
+
public:
|
|
319
|
+
AudiooutputcapabilitiesData()
|
|
320
|
+
: Core::JSON::Container()
|
|
321
|
+
{
|
|
322
|
+
_Init();
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
AudiooutputcapabilitiesData(const AudiooutputcapabilitiesData& _other)
|
|
326
|
+
: Core::JSON::Container()
|
|
327
|
+
, AudioPort(_other.AudioPort)
|
|
328
|
+
, Audiocapabilities(_other.Audiocapabilities)
|
|
329
|
+
, Ms12capabilities(_other.Ms12capabilities)
|
|
330
|
+
, Ms12profiles(_other.Ms12profiles)
|
|
331
|
+
{
|
|
332
|
+
_Init();
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
AudiooutputcapabilitiesData(AudiooutputcapabilitiesData&& _other) noexcept
|
|
336
|
+
: Core::JSON::Container()
|
|
337
|
+
, AudioPort(std::move(_other.AudioPort))
|
|
338
|
+
, Audiocapabilities(std::move(_other.Audiocapabilities))
|
|
339
|
+
, Ms12capabilities(std::move(_other.Ms12capabilities))
|
|
340
|
+
, Ms12profiles(std::move(_other.Ms12profiles))
|
|
341
|
+
{
|
|
342
|
+
_Init();
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
AudiooutputcapabilitiesData& operator=(const AudiooutputcapabilitiesData& _rhs)
|
|
346
|
+
{
|
|
347
|
+
AudioPort = _rhs.AudioPort;
|
|
348
|
+
Audiocapabilities = _rhs.Audiocapabilities;
|
|
349
|
+
Ms12capabilities = _rhs.Ms12capabilities;
|
|
350
|
+
Ms12profiles = _rhs.Ms12profiles;
|
|
351
|
+
return (*this);
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
AudiooutputcapabilitiesData& operator=(AudiooutputcapabilitiesData&& _rhs) noexcept
|
|
355
|
+
{
|
|
356
|
+
AudioPort = std::move(_rhs.AudioPort);
|
|
357
|
+
Audiocapabilities = std::move(_rhs.Audiocapabilities);
|
|
358
|
+
Ms12capabilities = std::move(_rhs.Ms12capabilities);
|
|
359
|
+
Ms12profiles = std::move(_rhs.Ms12profiles);
|
|
360
|
+
return (*this);
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
~AudiooutputcapabilitiesData() = default;
|
|
364
|
+
|
|
365
|
+
public:
|
|
366
|
+
bool IsDataValid() const
|
|
367
|
+
{
|
|
368
|
+
return ((Audiocapabilities.IsSet() == true) && (Ms12capabilities.IsSet() == true) && (Ms12profiles.IsSet() == true));
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
private:
|
|
372
|
+
void _Init()
|
|
373
|
+
{
|
|
374
|
+
Add(_T("audioPort"), &AudioPort);
|
|
375
|
+
Add(_T("audiocapabilities"), &Audiocapabilities);
|
|
376
|
+
Add(_T("ms12capabilities"), &Ms12capabilities);
|
|
377
|
+
Add(_T("ms12profiles"), &Ms12profiles);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
public:
|
|
381
|
+
Core::JSON::EnumType<AudioportType> AudioPort; // Audio Output support
|
|
382
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<AudiocapabilityType>> Audiocapabilities; // Audio capabilities for the specified audio port
|
|
383
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Ms12capabilityType>> Ms12capabilities; // Audio ms12 capabilities for the specified audio port
|
|
384
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Ms12profileType>> Ms12profiles; // Audio ms12 profiles for the specified audio port
|
|
385
|
+
}; // class AudiooutputcapabilitiesData
|
|
386
|
+
|
|
387
|
+
DeviceaudiocapabilitiesData()
|
|
388
|
+
: Core::JSON::Container()
|
|
389
|
+
{
|
|
390
|
+
Add(_T("audiooutputcapabilities"), &Audiooutputcapabilities);
|
|
391
|
+
}
|
|
392
|
+
|
|
393
|
+
DeviceaudiocapabilitiesData(const DeviceaudiocapabilitiesData&) = delete;
|
|
394
|
+
DeviceaudiocapabilitiesData(DeviceaudiocapabilitiesData&&) noexcept = delete;
|
|
395
|
+
|
|
396
|
+
DeviceaudiocapabilitiesData& operator=(const DeviceaudiocapabilitiesData&) = delete;
|
|
397
|
+
DeviceaudiocapabilitiesData& operator=(DeviceaudiocapabilitiesData&&) noexcept = delete;
|
|
398
|
+
|
|
399
|
+
~DeviceaudiocapabilitiesData() = default;
|
|
400
|
+
|
|
401
|
+
public:
|
|
402
|
+
bool IsDataValid() const
|
|
403
|
+
{
|
|
404
|
+
return (Audiooutputcapabilities.IsSet() == true);
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
public:
|
|
408
|
+
Core::JSON::ArrayType<DeviceaudiocapabilitiesData::AudiooutputcapabilitiesData> Audiooutputcapabilities; // An array of audiooutputcapabilities
|
|
409
|
+
}; // class DeviceaudiocapabilitiesData
|
|
410
|
+
|
|
411
|
+
class DeviceinfoData : public Core::JSON::Container {
|
|
412
|
+
public:
|
|
413
|
+
DeviceinfoData()
|
|
414
|
+
: Core::JSON::Container()
|
|
415
|
+
{
|
|
416
|
+
Add(_T("devicetype"), &Devicetype);
|
|
417
|
+
Add(_T("friendlyname"), &Friendlyname);
|
|
418
|
+
Add(_T("distributorid"), &Distributorid);
|
|
419
|
+
Add(_T("make"), &Make);
|
|
420
|
+
Add(_T("modelname"), &Modelname);
|
|
421
|
+
Add(_T("modelyear"), &Modelyear);
|
|
422
|
+
Add(_T("platformname"), &Platformname);
|
|
423
|
+
Add(_T("serialnumber"), &Serialnumber);
|
|
424
|
+
Add(_T("sku"), &Sku);
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
DeviceinfoData(const DeviceinfoData&) = delete;
|
|
428
|
+
DeviceinfoData(DeviceinfoData&&) noexcept = delete;
|
|
429
|
+
|
|
430
|
+
DeviceinfoData& operator=(const DeviceinfoData&) = delete;
|
|
431
|
+
DeviceinfoData& operator=(DeviceinfoData&&) noexcept = delete;
|
|
432
|
+
|
|
433
|
+
~DeviceinfoData() = default;
|
|
434
|
+
|
|
435
|
+
public:
|
|
436
|
+
bool IsDataValid() const
|
|
437
|
+
{
|
|
438
|
+
return ((Devicetype.IsSet() == true) && (Friendlyname.IsSet() == true) && (Distributorid.IsSet() == true) && (Make.IsSet() == true) && (Modelname.IsSet() == true) && (Modelyear.IsSet() == true) && (Platformname.IsSet() == true) && (Serialnumber.IsSet() == true) && (Sku.IsSet() == true));
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
public:
|
|
442
|
+
Core::JSON::String Devicetype; // Device type
|
|
443
|
+
Core::JSON::String Friendlyname; // Friendly name
|
|
444
|
+
Core::JSON::String Distributorid; // Partner ID or distributor ID for device
|
|
445
|
+
Core::JSON::String Make; // Device manufacturer
|
|
446
|
+
Core::JSON::String Modelname; // Model Name
|
|
447
|
+
Core::JSON::DecUInt16 Modelyear; // Model Year
|
|
448
|
+
Core::JSON::String Platformname; // Platform name
|
|
449
|
+
Core::JSON::String Serialnumber; // Device serial number
|
|
450
|
+
Core::JSON::String Sku; // Device model number or SKU
|
|
451
|
+
}; // class DeviceinfoData
|
|
452
|
+
|
|
453
|
+
class DevicetypeData : public Core::JSON::Container {
|
|
454
|
+
public:
|
|
455
|
+
// Device type
|
|
456
|
+
enum class DevicetypeType : uint8_t {
|
|
457
|
+
TV,
|
|
458
|
+
IPSTB,
|
|
459
|
+
QAMIPSTB,
|
|
460
|
+
HYBRID,
|
|
461
|
+
MEDIACLIENT
|
|
462
|
+
};
|
|
463
|
+
|
|
464
|
+
DevicetypeData()
|
|
465
|
+
: Core::JSON::Container()
|
|
466
|
+
{
|
|
467
|
+
Add(_T("devicetype"), &Devicetype);
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
DevicetypeData(const DevicetypeData&) = delete;
|
|
471
|
+
DevicetypeData(DevicetypeData&&) noexcept = delete;
|
|
472
|
+
|
|
473
|
+
DevicetypeData& operator=(const DevicetypeData&) = delete;
|
|
474
|
+
DevicetypeData& operator=(DevicetypeData&&) noexcept = delete;
|
|
475
|
+
|
|
476
|
+
~DevicetypeData() = default;
|
|
477
|
+
|
|
478
|
+
public:
|
|
479
|
+
bool IsDataValid() const
|
|
480
|
+
{
|
|
481
|
+
return (Devicetype.IsSet() == true);
|
|
482
|
+
}
|
|
483
|
+
|
|
484
|
+
public:
|
|
485
|
+
Core::JSON::EnumType<DevicetypeData::DevicetypeType> Devicetype; // Device type
|
|
486
|
+
}; // class DevicetypeData
|
|
487
|
+
|
|
488
|
+
class DevicevideocapabilitiesData : public Core::JSON::Container {
|
|
489
|
+
public:
|
|
490
|
+
class VideooutputcapabilitiesData : public Core::JSON::Container {
|
|
491
|
+
public:
|
|
492
|
+
VideooutputcapabilitiesData()
|
|
493
|
+
: Core::JSON::Container()
|
|
494
|
+
{
|
|
495
|
+
_Init();
|
|
496
|
+
}
|
|
497
|
+
|
|
498
|
+
VideooutputcapabilitiesData(const VideooutputcapabilitiesData& _other)
|
|
499
|
+
: Core::JSON::Container()
|
|
500
|
+
, Hdcp(_other.Hdcp)
|
|
501
|
+
, VideoDisplay(_other.VideoDisplay)
|
|
502
|
+
, Output_resolutions(_other.Output_resolutions)
|
|
503
|
+
, Defaultresolution(_other.Defaultresolution)
|
|
504
|
+
{
|
|
505
|
+
_Init();
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
VideooutputcapabilitiesData(VideooutputcapabilitiesData&& _other) noexcept
|
|
509
|
+
: Core::JSON::Container()
|
|
510
|
+
, Hdcp(std::move(_other.Hdcp))
|
|
511
|
+
, VideoDisplay(std::move(_other.VideoDisplay))
|
|
512
|
+
, Output_resolutions(std::move(_other.Output_resolutions))
|
|
513
|
+
, Defaultresolution(std::move(_other.Defaultresolution))
|
|
514
|
+
{
|
|
515
|
+
_Init();
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
VideooutputcapabilitiesData& operator=(const VideooutputcapabilitiesData& _rhs)
|
|
519
|
+
{
|
|
520
|
+
Hdcp = _rhs.Hdcp;
|
|
521
|
+
VideoDisplay = _rhs.VideoDisplay;
|
|
522
|
+
Output_resolutions = _rhs.Output_resolutions;
|
|
523
|
+
Defaultresolution = _rhs.Defaultresolution;
|
|
524
|
+
return (*this);
|
|
525
|
+
}
|
|
526
|
+
|
|
527
|
+
VideooutputcapabilitiesData& operator=(VideooutputcapabilitiesData&& _rhs) noexcept
|
|
528
|
+
{
|
|
529
|
+
Hdcp = std::move(_rhs.Hdcp);
|
|
530
|
+
VideoDisplay = std::move(_rhs.VideoDisplay);
|
|
531
|
+
Output_resolutions = std::move(_rhs.Output_resolutions);
|
|
532
|
+
Defaultresolution = std::move(_rhs.Defaultresolution);
|
|
533
|
+
return (*this);
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
~VideooutputcapabilitiesData() = default;
|
|
537
|
+
|
|
538
|
+
public:
|
|
539
|
+
bool IsDataValid() const
|
|
540
|
+
{
|
|
541
|
+
return ((Hdcp.IsSet() == true) && (Output_resolutions.IsSet() == true) && (Defaultresolution.IsSet() == true));
|
|
542
|
+
}
|
|
543
|
+
|
|
544
|
+
private:
|
|
545
|
+
void _Init()
|
|
546
|
+
{
|
|
547
|
+
Add(_T("hdcp"), &Hdcp);
|
|
548
|
+
Add(_T("videoDisplay"), &VideoDisplay);
|
|
549
|
+
Add(_T("output_resolutions"), &Output_resolutions);
|
|
550
|
+
Add(_T("defaultresolution"), &Defaultresolution);
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
public:
|
|
554
|
+
Core::JSON::EnumType<CopyprotectionType> Hdcp; // HDCP support
|
|
555
|
+
Core::JSON::EnumType<VideodisplayType> VideoDisplay; // Video Output support
|
|
556
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Output_resolutionType>> Output_resolutions; // Supported resolutions
|
|
557
|
+
Core::JSON::EnumType<Output_resolutionType> Defaultresolution; // Default resolution
|
|
558
|
+
}; // class VideooutputcapabilitiesData
|
|
559
|
+
|
|
560
|
+
DevicevideocapabilitiesData()
|
|
561
|
+
: Core::JSON::Container()
|
|
562
|
+
{
|
|
563
|
+
Add(_T("hostedid"), &Hostedid);
|
|
564
|
+
Add(_T("hdr"), &Hdr);
|
|
565
|
+
Add(_T("atmos"), &Atmos);
|
|
566
|
+
Add(_T("cec"), &Cec);
|
|
567
|
+
Add(_T("videooutputcapabilities"), &Videooutputcapabilities);
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
DevicevideocapabilitiesData(const DevicevideocapabilitiesData&) = delete;
|
|
571
|
+
DevicevideocapabilitiesData(DevicevideocapabilitiesData&&) noexcept = delete;
|
|
572
|
+
|
|
573
|
+
DevicevideocapabilitiesData& operator=(const DevicevideocapabilitiesData&) = delete;
|
|
574
|
+
DevicevideocapabilitiesData& operator=(DevicevideocapabilitiesData&&) noexcept = delete;
|
|
575
|
+
|
|
576
|
+
~DevicevideocapabilitiesData() = default;
|
|
577
|
+
|
|
578
|
+
public:
|
|
579
|
+
bool IsDataValid() const
|
|
580
|
+
{
|
|
581
|
+
return ((Hostedid.IsSet() == true) && (Hdr.IsSet() == true) && (Atmos.IsSet() == true) && (Cec.IsSet() == true) && (Videooutputcapabilities.IsSet() == true));
|
|
582
|
+
}
|
|
583
|
+
|
|
584
|
+
public:
|
|
585
|
+
Core::JSON::String Hostedid; // EDID of the host
|
|
586
|
+
Core::JSON::Boolean Hdr; // Is HDR supported by this device
|
|
587
|
+
Core::JSON::Boolean Atmos; // Is Atmos supported by this device
|
|
588
|
+
Core::JSON::Boolean Cec; // Is CEC supported by this device
|
|
589
|
+
Core::JSON::ArrayType<DevicevideocapabilitiesData::VideooutputcapabilitiesData> Videooutputcapabilities; // An array of videooutputcapabilities
|
|
590
|
+
}; // class DevicevideocapabilitiesData
|
|
591
|
+
|
|
592
|
+
class DistributoridData : public Core::JSON::Container {
|
|
593
|
+
public:
|
|
594
|
+
// Partner ID or distributor ID for device
|
|
595
|
+
enum class DistributoridType : uint8_t {
|
|
596
|
+
COMCAST,
|
|
597
|
+
XGLOBAL,
|
|
598
|
+
SKY_DE,
|
|
599
|
+
SKY_ITALIA,
|
|
600
|
+
SKY_UK,
|
|
601
|
+
SKY_UK_DEV,
|
|
602
|
+
SKY_DEU,
|
|
603
|
+
SKY_DEU_DEV,
|
|
604
|
+
SKY_IT,
|
|
605
|
+
SKY_IT_DEV,
|
|
606
|
+
COX,
|
|
607
|
+
COX_HOSPITALITY,
|
|
608
|
+
COX_DEV,
|
|
609
|
+
COX_QA,
|
|
610
|
+
MIT,
|
|
611
|
+
SHAW,
|
|
612
|
+
SHAW_DEV,
|
|
613
|
+
ROGERS,
|
|
614
|
+
ROGERS_DEV,
|
|
615
|
+
VIDEOTRON,
|
|
616
|
+
CHARTER,
|
|
617
|
+
CHARTER_DEV
|
|
618
|
+
};
|
|
619
|
+
|
|
620
|
+
DistributoridData()
|
|
621
|
+
: Core::JSON::Container()
|
|
622
|
+
{
|
|
623
|
+
Add(_T("distributorid"), &Distributorid);
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
DistributoridData(const DistributoridData&) = delete;
|
|
627
|
+
DistributoridData(DistributoridData&&) noexcept = delete;
|
|
628
|
+
|
|
629
|
+
DistributoridData& operator=(const DistributoridData&) = delete;
|
|
630
|
+
DistributoridData& operator=(DistributoridData&&) noexcept = delete;
|
|
631
|
+
|
|
632
|
+
~DistributoridData() = default;
|
|
633
|
+
|
|
634
|
+
public:
|
|
635
|
+
bool IsDataValid() const
|
|
636
|
+
{
|
|
637
|
+
return (Distributorid.IsSet() == true);
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
public:
|
|
641
|
+
Core::JSON::EnumType<DistributoridData::DistributoridType> Distributorid; // Partner ID or distributor ID for device
|
|
642
|
+
}; // class DistributoridData
|
|
643
|
+
|
|
644
|
+
class FirmwareversionData : public Core::JSON::Container {
|
|
645
|
+
public:
|
|
646
|
+
// Yocto version
|
|
647
|
+
enum class YoctoType : uint8_t {
|
|
648
|
+
DUNFELL,
|
|
649
|
+
MORTY,
|
|
650
|
+
DAISY,
|
|
651
|
+
KIRKSTONE
|
|
652
|
+
};
|
|
653
|
+
|
|
654
|
+
FirmwareversionData()
|
|
655
|
+
: Core::JSON::Container()
|
|
656
|
+
{
|
|
657
|
+
Add(_T("imagename"), &Imagename);
|
|
658
|
+
Add(_T("sdk"), &Sdk);
|
|
659
|
+
Add(_T("mediarite"), &Mediarite);
|
|
660
|
+
Add(_T("yocto"), &Yocto);
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
FirmwareversionData(const FirmwareversionData&) = delete;
|
|
664
|
+
FirmwareversionData(FirmwareversionData&&) noexcept = delete;
|
|
665
|
+
|
|
666
|
+
FirmwareversionData& operator=(const FirmwareversionData&) = delete;
|
|
667
|
+
FirmwareversionData& operator=(FirmwareversionData&&) noexcept = delete;
|
|
668
|
+
|
|
669
|
+
~FirmwareversionData() = default;
|
|
670
|
+
|
|
671
|
+
public:
|
|
672
|
+
bool IsDataValid() const
|
|
673
|
+
{
|
|
674
|
+
return (Imagename.IsSet() == true);
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
public:
|
|
678
|
+
Core::JSON::String Imagename; // Name of firmware image
|
|
679
|
+
Core::JSON::String Sdk; // SDK version string
|
|
680
|
+
Core::JSON::String Mediarite; // Mediarite value
|
|
681
|
+
Core::JSON::EnumType<FirmwareversionData::YoctoType> Yocto; // Yocto version
|
|
682
|
+
}; // class FirmwareversionData
|
|
683
|
+
|
|
684
|
+
class HostedidData : public Core::JSON::Container {
|
|
685
|
+
public:
|
|
686
|
+
HostedidData()
|
|
687
|
+
: Core::JSON::Container()
|
|
688
|
+
{
|
|
689
|
+
Add(_T("EDID"), &EDID);
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
HostedidData(const HostedidData&) = delete;
|
|
693
|
+
HostedidData(HostedidData&&) noexcept = delete;
|
|
694
|
+
|
|
695
|
+
HostedidData& operator=(const HostedidData&) = delete;
|
|
696
|
+
HostedidData& operator=(HostedidData&&) noexcept = delete;
|
|
697
|
+
|
|
698
|
+
~HostedidData() = default;
|
|
699
|
+
|
|
700
|
+
public:
|
|
701
|
+
bool IsDataValid() const
|
|
702
|
+
{
|
|
703
|
+
return (EDID.IsSet() == true);
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
public:
|
|
707
|
+
Core::JSON::String EDID; // A base64 encoded byte array string representing the EDID
|
|
708
|
+
}; // class HostedidData
|
|
709
|
+
|
|
710
|
+
class MakeData : public Core::JSON::Container {
|
|
711
|
+
public:
|
|
712
|
+
// Device manufacturer
|
|
713
|
+
enum class MakeType : uint8_t {
|
|
714
|
+
PLATCO,
|
|
715
|
+
LLAMA,
|
|
716
|
+
HISENSE,
|
|
717
|
+
ELEMENT,
|
|
718
|
+
SKY,
|
|
719
|
+
SERCOMM,
|
|
720
|
+
COMMSCOPE,
|
|
721
|
+
ARRIS,
|
|
722
|
+
CISCO,
|
|
723
|
+
PACE,
|
|
724
|
+
SAMSUNG,
|
|
725
|
+
TECHNICOLOR,
|
|
726
|
+
AMLOGIC_INC,
|
|
727
|
+
RASPBERRYPI_ORG,
|
|
728
|
+
PIONEER
|
|
729
|
+
};
|
|
730
|
+
|
|
731
|
+
MakeData()
|
|
732
|
+
: Core::JSON::Container()
|
|
733
|
+
{
|
|
734
|
+
Add(_T("make"), &Make);
|
|
735
|
+
}
|
|
736
|
+
|
|
737
|
+
MakeData(const MakeData&) = delete;
|
|
738
|
+
MakeData(MakeData&&) noexcept = delete;
|
|
739
|
+
|
|
740
|
+
MakeData& operator=(const MakeData&) = delete;
|
|
741
|
+
MakeData& operator=(MakeData&&) noexcept = delete;
|
|
742
|
+
|
|
743
|
+
~MakeData() = default;
|
|
744
|
+
|
|
745
|
+
public:
|
|
746
|
+
bool IsDataValid() const
|
|
747
|
+
{
|
|
748
|
+
return (Make.IsSet() == true);
|
|
749
|
+
}
|
|
750
|
+
|
|
751
|
+
public:
|
|
752
|
+
Core::JSON::EnumType<MakeData::MakeType> Make; // Device manufacturer
|
|
753
|
+
}; // class MakeData
|
|
754
|
+
|
|
755
|
+
class ModelidData : public Core::JSON::Container {
|
|
756
|
+
public:
|
|
757
|
+
// Device model number or SKU
|
|
758
|
+
enum class SkuType : uint8_t {
|
|
759
|
+
PLTL11AEI,
|
|
760
|
+
ZWCN11MWI,
|
|
761
|
+
SKTL11AEI,
|
|
762
|
+
LS301,
|
|
763
|
+
HSTP11MWR,
|
|
764
|
+
HSTP11MWRFX50,
|
|
765
|
+
ELTE11MWR,
|
|
766
|
+
SKXI11ADS,
|
|
767
|
+
SKXI11AIS,
|
|
768
|
+
SKXI11ANS,
|
|
769
|
+
SCXI11AIC,
|
|
770
|
+
SCXI11BEI,
|
|
771
|
+
CMXI11BEI,
|
|
772
|
+
AX013AN,
|
|
773
|
+
AX014AN,
|
|
774
|
+
AX061AEI,
|
|
775
|
+
MX011AN,
|
|
776
|
+
CS011AN,
|
|
777
|
+
CXD01ANI,
|
|
778
|
+
PX001AN,
|
|
779
|
+
PX013AN,
|
|
780
|
+
PX022AN,
|
|
781
|
+
PX032ANI,
|
|
782
|
+
PX051AEI,
|
|
783
|
+
PXD01ANI,
|
|
784
|
+
SX022AN,
|
|
785
|
+
TX061AEI,
|
|
786
|
+
PI,
|
|
787
|
+
XUSHTC11MWR,
|
|
788
|
+
XUSPTC11MWR,
|
|
789
|
+
XUSHTB11MWR,
|
|
790
|
+
PITU11MWR
|
|
791
|
+
};
|
|
792
|
+
|
|
793
|
+
ModelidData()
|
|
794
|
+
: Core::JSON::Container()
|
|
795
|
+
{
|
|
796
|
+
Add(_T("sku"), &Sku);
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
ModelidData(const ModelidData&) = delete;
|
|
800
|
+
ModelidData(ModelidData&&) noexcept = delete;
|
|
801
|
+
|
|
802
|
+
ModelidData& operator=(const ModelidData&) = delete;
|
|
803
|
+
ModelidData& operator=(ModelidData&&) noexcept = delete;
|
|
804
|
+
|
|
805
|
+
~ModelidData() = default;
|
|
806
|
+
|
|
807
|
+
public:
|
|
808
|
+
bool IsDataValid() const
|
|
809
|
+
{
|
|
810
|
+
return (Sku.IsSet() == true);
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
public:
|
|
814
|
+
Core::JSON::EnumType<ModelidData::SkuType> Sku; // Device model number or SKU
|
|
815
|
+
}; // class ModelidData
|
|
816
|
+
|
|
817
|
+
class ModelnameData : public Core::JSON::Container {
|
|
818
|
+
public:
|
|
819
|
+
ModelnameData()
|
|
820
|
+
: Core::JSON::Container()
|
|
821
|
+
{
|
|
822
|
+
Add(_T("model"), &Model);
|
|
823
|
+
}
|
|
824
|
+
|
|
825
|
+
ModelnameData(const ModelnameData&) = delete;
|
|
826
|
+
ModelnameData(ModelnameData&&) noexcept = delete;
|
|
827
|
+
|
|
828
|
+
ModelnameData& operator=(const ModelnameData&) = delete;
|
|
829
|
+
ModelnameData& operator=(ModelnameData&&) noexcept = delete;
|
|
830
|
+
|
|
831
|
+
~ModelnameData() = default;
|
|
832
|
+
|
|
833
|
+
public:
|
|
834
|
+
bool IsDataValid() const
|
|
835
|
+
{
|
|
836
|
+
return (Model.IsSet() == true);
|
|
837
|
+
}
|
|
838
|
+
|
|
839
|
+
public:
|
|
840
|
+
Core::JSON::String Model; // Device model name
|
|
841
|
+
}; // class ModelnameData
|
|
842
|
+
|
|
843
|
+
class ModelyearData : public Core::JSON::Container {
|
|
844
|
+
public:
|
|
845
|
+
ModelyearData()
|
|
846
|
+
: Core::JSON::Container()
|
|
847
|
+
{
|
|
848
|
+
Add(_T("year"), &Year);
|
|
849
|
+
}
|
|
850
|
+
|
|
851
|
+
ModelyearData(const ModelyearData&) = delete;
|
|
852
|
+
ModelyearData(ModelyearData&&) noexcept = delete;
|
|
853
|
+
|
|
854
|
+
ModelyearData& operator=(const ModelyearData&) = delete;
|
|
855
|
+
ModelyearData& operator=(ModelyearData&&) noexcept = delete;
|
|
856
|
+
|
|
857
|
+
~ModelyearData() = default;
|
|
858
|
+
|
|
859
|
+
public:
|
|
860
|
+
bool IsDataValid() const
|
|
861
|
+
{
|
|
862
|
+
return (Year.IsSet() == true);
|
|
863
|
+
}
|
|
864
|
+
|
|
865
|
+
public:
|
|
866
|
+
Core::JSON::DecUInt16 Year; // Device model year
|
|
867
|
+
}; // class ModelyearData
|
|
868
|
+
|
|
869
|
+
class Ms12capabilitiesResultData : public Core::JSON::Container {
|
|
870
|
+
public:
|
|
871
|
+
Ms12capabilitiesResultData()
|
|
872
|
+
: Core::JSON::Container()
|
|
873
|
+
{
|
|
874
|
+
Add(_T("MS12Capabilities"), &MS12Capabilities);
|
|
875
|
+
}
|
|
876
|
+
|
|
877
|
+
Ms12capabilitiesResultData(const Ms12capabilitiesResultData&) = delete;
|
|
878
|
+
Ms12capabilitiesResultData(Ms12capabilitiesResultData&&) noexcept = delete;
|
|
879
|
+
|
|
880
|
+
Ms12capabilitiesResultData& operator=(const Ms12capabilitiesResultData&) = delete;
|
|
881
|
+
Ms12capabilitiesResultData& operator=(Ms12capabilitiesResultData&&) noexcept = delete;
|
|
882
|
+
|
|
883
|
+
~Ms12capabilitiesResultData() = default;
|
|
884
|
+
|
|
885
|
+
public:
|
|
886
|
+
bool IsDataValid() const
|
|
887
|
+
{
|
|
888
|
+
return (MS12Capabilities.IsSet() == true);
|
|
889
|
+
}
|
|
890
|
+
|
|
891
|
+
public:
|
|
892
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Ms12capabilityType>> MS12Capabilities; // An array of MS12 audio capabilities
|
|
893
|
+
}; // class Ms12capabilitiesResultData
|
|
894
|
+
|
|
895
|
+
class SerialnumberData : public Core::JSON::Container {
|
|
896
|
+
public:
|
|
897
|
+
SerialnumberData()
|
|
898
|
+
: Core::JSON::Container()
|
|
899
|
+
{
|
|
900
|
+
Add(_T("serialnumber"), &Serialnumber);
|
|
901
|
+
}
|
|
902
|
+
|
|
903
|
+
SerialnumberData(const SerialnumberData&) = delete;
|
|
904
|
+
SerialnumberData(SerialnumberData&&) noexcept = delete;
|
|
905
|
+
|
|
906
|
+
SerialnumberData& operator=(const SerialnumberData&) = delete;
|
|
907
|
+
SerialnumberData& operator=(SerialnumberData&&) noexcept = delete;
|
|
908
|
+
|
|
909
|
+
~SerialnumberData() = default;
|
|
910
|
+
|
|
911
|
+
public:
|
|
912
|
+
bool IsDataValid() const
|
|
913
|
+
{
|
|
914
|
+
return (Serialnumber.IsSet() == true);
|
|
915
|
+
}
|
|
916
|
+
|
|
917
|
+
public:
|
|
918
|
+
Core::JSON::String Serialnumber; // Device Serial Number
|
|
919
|
+
}; // class SerialnumberData
|
|
920
|
+
|
|
921
|
+
class SocketinfoData : public Core::JSON::Container {
|
|
922
|
+
public:
|
|
923
|
+
SocketinfoData()
|
|
924
|
+
: Core::JSON::Container()
|
|
925
|
+
{
|
|
926
|
+
Add(_T("total"), &Total);
|
|
927
|
+
Add(_T("open"), &Open);
|
|
928
|
+
Add(_T("link"), &Link);
|
|
929
|
+
Add(_T("exception"), &Exception);
|
|
930
|
+
Add(_T("shutdown"), &Shutdown);
|
|
931
|
+
Add(_T("runs"), &Runs);
|
|
932
|
+
}
|
|
933
|
+
|
|
934
|
+
SocketinfoData(const SocketinfoData&) = delete;
|
|
935
|
+
SocketinfoData(SocketinfoData&&) noexcept = delete;
|
|
936
|
+
|
|
937
|
+
SocketinfoData& operator=(const SocketinfoData&) = delete;
|
|
938
|
+
SocketinfoData& operator=(SocketinfoData&&) noexcept = delete;
|
|
939
|
+
|
|
940
|
+
~SocketinfoData() = default;
|
|
941
|
+
|
|
942
|
+
public:
|
|
943
|
+
bool IsDataValid() const
|
|
944
|
+
{
|
|
945
|
+
return (Runs.IsSet() == true);
|
|
946
|
+
}
|
|
947
|
+
|
|
948
|
+
public:
|
|
949
|
+
Core::JSON::DecUInt32 Total; // Number of total
|
|
950
|
+
Core::JSON::DecUInt32 Open; // Number of open
|
|
951
|
+
Core::JSON::DecUInt32 Link; // Number of link
|
|
952
|
+
Core::JSON::DecUInt32 Exception; // Number of exception
|
|
953
|
+
Core::JSON::DecUInt32 Shutdown; // Number of shutdown
|
|
954
|
+
Core::JSON::DecUInt32 Runs; // Number of runs
|
|
955
|
+
}; // class SocketinfoData
|
|
956
|
+
|
|
957
|
+
class SupportedaudioportsData : public Core::JSON::Container {
|
|
958
|
+
public:
|
|
959
|
+
SupportedaudioportsData()
|
|
960
|
+
: Core::JSON::Container()
|
|
961
|
+
{
|
|
962
|
+
Add(_T("supportedAudioPorts"), &SupportedAudioPorts);
|
|
963
|
+
}
|
|
964
|
+
|
|
965
|
+
SupportedaudioportsData(const SupportedaudioportsData&) = delete;
|
|
966
|
+
SupportedaudioportsData(SupportedaudioportsData&&) noexcept = delete;
|
|
967
|
+
|
|
968
|
+
SupportedaudioportsData& operator=(const SupportedaudioportsData&) = delete;
|
|
969
|
+
SupportedaudioportsData& operator=(SupportedaudioportsData&&) noexcept = delete;
|
|
970
|
+
|
|
971
|
+
~SupportedaudioportsData() = default;
|
|
972
|
+
|
|
973
|
+
public:
|
|
974
|
+
bool IsDataValid() const
|
|
975
|
+
{
|
|
976
|
+
return (SupportedAudioPorts.IsSet() == true);
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
public:
|
|
980
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<AudioportType>> SupportedAudioPorts; // Audio Output support
|
|
981
|
+
}; // class SupportedaudioportsData
|
|
982
|
+
|
|
983
|
+
class SupportedhdcpResultData : public Core::JSON::Container {
|
|
984
|
+
public:
|
|
985
|
+
SupportedhdcpResultData()
|
|
986
|
+
: Core::JSON::Container()
|
|
987
|
+
{
|
|
988
|
+
Add(_T("supportedHDCPVersion"), &SupportedHDCPVersion);
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
SupportedhdcpResultData(const SupportedhdcpResultData&) = delete;
|
|
992
|
+
SupportedhdcpResultData(SupportedhdcpResultData&&) noexcept = delete;
|
|
993
|
+
|
|
994
|
+
SupportedhdcpResultData& operator=(const SupportedhdcpResultData&) = delete;
|
|
995
|
+
SupportedhdcpResultData& operator=(SupportedhdcpResultData&&) noexcept = delete;
|
|
996
|
+
|
|
997
|
+
~SupportedhdcpResultData() = default;
|
|
998
|
+
|
|
999
|
+
public:
|
|
1000
|
+
bool IsDataValid() const
|
|
1001
|
+
{
|
|
1002
|
+
return (SupportedHDCPVersion.IsSet() == true);
|
|
1003
|
+
}
|
|
1004
|
+
|
|
1005
|
+
public:
|
|
1006
|
+
Core::JSON::EnumType<CopyprotectionType> SupportedHDCPVersion; // HDCP support
|
|
1007
|
+
}; // class SupportedhdcpResultData
|
|
1008
|
+
|
|
1009
|
+
class Supportedms12audioprofilesResultData : public Core::JSON::Container {
|
|
1010
|
+
public:
|
|
1011
|
+
Supportedms12audioprofilesResultData()
|
|
1012
|
+
: Core::JSON::Container()
|
|
1013
|
+
{
|
|
1014
|
+
Add(_T("supportedMS12AudioProfiles"), &SupportedMS12AudioProfiles);
|
|
1015
|
+
}
|
|
1016
|
+
|
|
1017
|
+
Supportedms12audioprofilesResultData(const Supportedms12audioprofilesResultData&) = delete;
|
|
1018
|
+
Supportedms12audioprofilesResultData(Supportedms12audioprofilesResultData&&) noexcept = delete;
|
|
1019
|
+
|
|
1020
|
+
Supportedms12audioprofilesResultData& operator=(const Supportedms12audioprofilesResultData&) = delete;
|
|
1021
|
+
Supportedms12audioprofilesResultData& operator=(Supportedms12audioprofilesResultData&&) noexcept = delete;
|
|
1022
|
+
|
|
1023
|
+
~Supportedms12audioprofilesResultData() = default;
|
|
1024
|
+
|
|
1025
|
+
public:
|
|
1026
|
+
bool IsDataValid() const
|
|
1027
|
+
{
|
|
1028
|
+
return (SupportedMS12AudioProfiles.IsSet() == true);
|
|
1029
|
+
}
|
|
1030
|
+
|
|
1031
|
+
public:
|
|
1032
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Ms12profileType>> SupportedMS12AudioProfiles; // An array of ms12 audio profiles
|
|
1033
|
+
}; // class Supportedms12audioprofilesResultData
|
|
1034
|
+
|
|
1035
|
+
class SupportedresolutionsResultData : public Core::JSON::Container {
|
|
1036
|
+
public:
|
|
1037
|
+
SupportedresolutionsResultData()
|
|
1038
|
+
: Core::JSON::Container()
|
|
1039
|
+
{
|
|
1040
|
+
Add(_T("supportedResolutions"), &SupportedResolutions);
|
|
1041
|
+
}
|
|
1042
|
+
|
|
1043
|
+
SupportedresolutionsResultData(const SupportedresolutionsResultData&) = delete;
|
|
1044
|
+
SupportedresolutionsResultData(SupportedresolutionsResultData&&) noexcept = delete;
|
|
1045
|
+
|
|
1046
|
+
SupportedresolutionsResultData& operator=(const SupportedresolutionsResultData&) = delete;
|
|
1047
|
+
SupportedresolutionsResultData& operator=(SupportedresolutionsResultData&&) noexcept = delete;
|
|
1048
|
+
|
|
1049
|
+
~SupportedresolutionsResultData() = default;
|
|
1050
|
+
|
|
1051
|
+
public:
|
|
1052
|
+
bool IsDataValid() const
|
|
1053
|
+
{
|
|
1054
|
+
return (SupportedResolutions.IsSet() == true);
|
|
1055
|
+
}
|
|
1056
|
+
|
|
1057
|
+
public:
|
|
1058
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Output_resolutionType>> SupportedResolutions; // An array of resolution supported by the device
|
|
1059
|
+
}; // class SupportedresolutionsResultData
|
|
1060
|
+
|
|
1061
|
+
class SupportedvideodisplaysData : public Core::JSON::Container {
|
|
1062
|
+
public:
|
|
1063
|
+
SupportedvideodisplaysData()
|
|
1064
|
+
: Core::JSON::Container()
|
|
1065
|
+
{
|
|
1066
|
+
Add(_T("supportedVideoDisplays"), &SupportedVideoDisplays);
|
|
1067
|
+
}
|
|
1068
|
+
|
|
1069
|
+
SupportedvideodisplaysData(const SupportedvideodisplaysData&) = delete;
|
|
1070
|
+
SupportedvideodisplaysData(SupportedvideodisplaysData&&) noexcept = delete;
|
|
1071
|
+
|
|
1072
|
+
SupportedvideodisplaysData& operator=(const SupportedvideodisplaysData&) = delete;
|
|
1073
|
+
SupportedvideodisplaysData& operator=(SupportedvideodisplaysData&&) noexcept = delete;
|
|
1074
|
+
|
|
1075
|
+
~SupportedvideodisplaysData() = default;
|
|
1076
|
+
|
|
1077
|
+
public:
|
|
1078
|
+
bool IsDataValid() const
|
|
1079
|
+
{
|
|
1080
|
+
return (SupportedVideoDisplays.IsSet() == true);
|
|
1081
|
+
}
|
|
1082
|
+
|
|
1083
|
+
public:
|
|
1084
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<VideodisplayType>> SupportedVideoDisplays; // Video Output support
|
|
1085
|
+
}; // class SupportedvideodisplaysData
|
|
1086
|
+
|
|
1087
|
+
class SysteminfoData : public Core::JSON::Container {
|
|
1088
|
+
public:
|
|
1089
|
+
class CpuloadavgsData : public Core::JSON::Container {
|
|
1090
|
+
public:
|
|
1091
|
+
CpuloadavgsData()
|
|
1092
|
+
: Core::JSON::Container()
|
|
1093
|
+
{
|
|
1094
|
+
Add(_T("avg1min"), &Avg1min);
|
|
1095
|
+
Add(_T("avg5min"), &Avg5min);
|
|
1096
|
+
Add(_T("avg15min"), &Avg15min);
|
|
1097
|
+
}
|
|
1098
|
+
|
|
1099
|
+
CpuloadavgsData(const CpuloadavgsData&) = delete;
|
|
1100
|
+
CpuloadavgsData(CpuloadavgsData&&) noexcept = delete;
|
|
1101
|
+
|
|
1102
|
+
CpuloadavgsData& operator=(const CpuloadavgsData&) = delete;
|
|
1103
|
+
CpuloadavgsData& operator=(CpuloadavgsData&&) noexcept = delete;
|
|
1104
|
+
|
|
1105
|
+
~CpuloadavgsData() = default;
|
|
1106
|
+
|
|
1107
|
+
public:
|
|
1108
|
+
bool IsDataValid() const
|
|
1109
|
+
{
|
|
1110
|
+
return ((Avg1min.IsSet() == true) && (Avg5min.IsSet() == true) && (Avg15min.IsSet() == true));
|
|
1111
|
+
}
|
|
1112
|
+
|
|
1113
|
+
public:
|
|
1114
|
+
Core::JSON::DecUInt64 Avg1min; // 1min cpuload average
|
|
1115
|
+
Core::JSON::DecUInt64 Avg5min; // 5min cpuload average
|
|
1116
|
+
Core::JSON::DecUInt64 Avg15min; // 15min cpuload average
|
|
1117
|
+
}; // class CpuloadavgsData
|
|
1118
|
+
|
|
1119
|
+
SysteminfoData()
|
|
1120
|
+
: Core::JSON::Container()
|
|
1121
|
+
{
|
|
1122
|
+
Add(_T("version"), &Version);
|
|
1123
|
+
Add(_T("uptime"), &Uptime);
|
|
1124
|
+
Add(_T("totalram"), &Totalram);
|
|
1125
|
+
Add(_T("freeram"), &Freeram);
|
|
1126
|
+
Add(_T("totalswap"), &Totalswap);
|
|
1127
|
+
Add(_T("freeswap"), &Freeswap);
|
|
1128
|
+
Add(_T("devicename"), &Devicename);
|
|
1129
|
+
Add(_T("cpuload"), &Cpuload);
|
|
1130
|
+
Add(_T("cpuloadavg"), &Cpuloadavg);
|
|
1131
|
+
Add(_T("serialnumber"), &Serialnumber);
|
|
1132
|
+
Add(_T("time"), &Time);
|
|
1133
|
+
}
|
|
1134
|
+
|
|
1135
|
+
SysteminfoData(const SysteminfoData&) = delete;
|
|
1136
|
+
SysteminfoData(SysteminfoData&&) noexcept = delete;
|
|
1137
|
+
|
|
1138
|
+
SysteminfoData& operator=(const SysteminfoData&) = delete;
|
|
1139
|
+
SysteminfoData& operator=(SysteminfoData&&) noexcept = delete;
|
|
1140
|
+
|
|
1141
|
+
~SysteminfoData() = default;
|
|
1142
|
+
|
|
1143
|
+
public:
|
|
1144
|
+
bool IsDataValid() const
|
|
1145
|
+
{
|
|
1146
|
+
return ((Version.IsSet() == true) && (Uptime.IsSet() == true) && (Totalram.IsSet() == true) && (Freeram.IsSet() == true) && (Totalswap.IsSet() == true) && (Freeswap.IsSet() == true) && (Devicename.IsSet() == true) && (Cpuload.IsSet() == true) && ((Cpuloadavg.IsSet() == true) && (Cpuloadavg.IsDataValid() == true)) && (Serialnumber.IsSet() == true) && (Time.IsSet() == true));
|
|
1147
|
+
}
|
|
1148
|
+
|
|
1149
|
+
public:
|
|
1150
|
+
Core::JSON::String Version; // Software version (in form *version#hashtag*)
|
|
1151
|
+
Core::JSON::DecUInt64 Uptime; // System uptime (in seconds)
|
|
1152
|
+
Core::JSON::DecUInt64 Totalram; // Total installed system RAM memory (in bytes)
|
|
1153
|
+
Core::JSON::DecUInt64 Freeram; // Free system RAM memory (in bytes)
|
|
1154
|
+
Core::JSON::DecUInt64 Totalswap; // Total swap space (in bytes)
|
|
1155
|
+
Core::JSON::DecUInt64 Freeswap; // Swap space still available (in bytes)
|
|
1156
|
+
Core::JSON::String Devicename; // Host name
|
|
1157
|
+
Core::JSON::String Cpuload; // Current CPU load (percentage)
|
|
1158
|
+
SysteminfoData::CpuloadavgsData Cpuloadavg; // CPU load average
|
|
1159
|
+
Core::JSON::String Serialnumber; // Device serial number
|
|
1160
|
+
Core::JSON::String Time; // Current system date and time
|
|
1161
|
+
}; // class SysteminfoData
|
|
1162
|
+
|
|
1163
|
+
} // namespace DeviceInfo
|
|
1164
|
+
|
|
1165
|
+
POP_WARNING()
|
|
1166
|
+
|
|
1167
|
+
} // namespace JsonData
|
|
1168
|
+
|
|
1169
|
+
// Enum conversion handlers
|
|
1170
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::VideodisplayType)
|
|
1171
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::Output_resolutionType)
|
|
1172
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::CopyprotectionType)
|
|
1173
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::AudioportType)
|
|
1174
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::AudiocapabilityType)
|
|
1175
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::Ms12capabilityType)
|
|
1176
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::Ms12profileType)
|
|
1177
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::FirmwareversionData::YoctoType)
|
|
1178
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::MakeData::MakeType)
|
|
1179
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::ModelidData::SkuType)
|
|
1180
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::DevicetypeData::DevicetypeType)
|
|
1181
|
+
ENUM_CONVERSION_HANDLER(JsonData::DeviceInfo::DistributoridData::DistributoridType)
|
|
1182
|
+
|
|
1183
|
+
}
|
|
1184
|
+
|
|
@@ -0,0 +1,225 @@
|
|
|
1
|
+
// C++ types for Dictionary API.
|
|
2
|
+
// Generated automatically from 'IDictionary.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDictionary.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Dictionary {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class GetParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
GetParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("path"), &Path);
|
|
28
|
+
Add(_T("key"), &Key);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
GetParamsData(const GetParamsData&) = delete;
|
|
32
|
+
GetParamsData(GetParamsData&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
GetParamsData& operator=(const GetParamsData&) = delete;
|
|
35
|
+
GetParamsData& operator=(GetParamsData&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~GetParamsData() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((Path.IsSet() == true) && (Key.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::String Path; // NameSpace path to be used
|
|
47
|
+
Core::JSON::String Key; // Key to be used
|
|
48
|
+
}; // class GetParamsData
|
|
49
|
+
|
|
50
|
+
class ModifiedParamsData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
ModifiedParamsData()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("key"), &Key);
|
|
56
|
+
Add(_T("value"), &Value);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
ModifiedParamsData(const ModifiedParamsData&) = delete;
|
|
60
|
+
ModifiedParamsData(ModifiedParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
ModifiedParamsData& operator=(const ModifiedParamsData&) = delete;
|
|
63
|
+
ModifiedParamsData& operator=(ModifiedParamsData&&) noexcept = delete;
|
|
64
|
+
|
|
65
|
+
~ModifiedParamsData() = default;
|
|
66
|
+
|
|
67
|
+
public:
|
|
68
|
+
bool IsDataValid() const
|
|
69
|
+
{
|
|
70
|
+
return ((Key.IsSet() == true) && (Value.IsSet() == true));
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
Core::JSON::String Key; // Key which value changed
|
|
75
|
+
Core::JSON::String Value; // Value that changed
|
|
76
|
+
}; // class ModifiedParamsData
|
|
77
|
+
|
|
78
|
+
class PathEntriesParamsData : public Core::JSON::Container {
|
|
79
|
+
public:
|
|
80
|
+
PathEntriesParamsData()
|
|
81
|
+
: Core::JSON::Container()
|
|
82
|
+
{
|
|
83
|
+
Add(_T("path"), &Path);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
PathEntriesParamsData(const PathEntriesParamsData&) = delete;
|
|
87
|
+
PathEntriesParamsData(PathEntriesParamsData&&) noexcept = delete;
|
|
88
|
+
|
|
89
|
+
PathEntriesParamsData& operator=(const PathEntriesParamsData&) = delete;
|
|
90
|
+
PathEntriesParamsData& operator=(PathEntriesParamsData&&) noexcept = delete;
|
|
91
|
+
|
|
92
|
+
~PathEntriesParamsData() = default;
|
|
93
|
+
|
|
94
|
+
public:
|
|
95
|
+
bool IsDataValid() const
|
|
96
|
+
{
|
|
97
|
+
return (Path.IsSet() == true);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
Core::JSON::String Path; // Namespace path where to get the keys and/or nested namespaces for
|
|
102
|
+
}; // class PathEntriesParamsData
|
|
103
|
+
|
|
104
|
+
class PathEntryData : public Core::JSON::Container {
|
|
105
|
+
public:
|
|
106
|
+
PathEntryData()
|
|
107
|
+
: Core::JSON::Container()
|
|
108
|
+
{
|
|
109
|
+
_Init();
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
PathEntryData(const PathEntryData& _other)
|
|
113
|
+
: Core::JSON::Container()
|
|
114
|
+
, Name(_other.Name)
|
|
115
|
+
, Type(_other.Type)
|
|
116
|
+
{
|
|
117
|
+
_Init();
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
PathEntryData(PathEntryData&& _other) noexcept
|
|
121
|
+
: Core::JSON::Container()
|
|
122
|
+
, Name(std::move(_other.Name))
|
|
123
|
+
, Type(std::move(_other.Type))
|
|
124
|
+
{
|
|
125
|
+
_Init();
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
PathEntryData(const Exchange::IDictionary::PathEntry& _other)
|
|
129
|
+
: Core::JSON::Container()
|
|
130
|
+
{
|
|
131
|
+
Name = _other.name;
|
|
132
|
+
Type = _other.type;
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
PathEntryData& operator=(const PathEntryData& _rhs)
|
|
137
|
+
{
|
|
138
|
+
Name = _rhs.Name;
|
|
139
|
+
Type = _rhs.Type;
|
|
140
|
+
return (*this);
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
PathEntryData& operator=(PathEntryData&& _rhs) noexcept
|
|
144
|
+
{
|
|
145
|
+
Name = std::move(_rhs.Name);
|
|
146
|
+
Type = std::move(_rhs.Type);
|
|
147
|
+
return (*this);
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
PathEntryData& operator=(const Exchange::IDictionary::PathEntry& _rhs)
|
|
151
|
+
{
|
|
152
|
+
Name = _rhs.name;
|
|
153
|
+
Type = _rhs.type;
|
|
154
|
+
return (*this);
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
operator Exchange::IDictionary::PathEntry() const
|
|
158
|
+
{
|
|
159
|
+
Exchange::IDictionary::PathEntry _value{};
|
|
160
|
+
_value.name = Name;
|
|
161
|
+
_value.type = Type;
|
|
162
|
+
return (_value);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
~PathEntryData() = default;
|
|
166
|
+
|
|
167
|
+
public:
|
|
168
|
+
bool IsDataValid() const
|
|
169
|
+
{
|
|
170
|
+
return ((Name.IsSet() == true) && (Type.IsSet() == true));
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
private:
|
|
174
|
+
void _Init()
|
|
175
|
+
{
|
|
176
|
+
Add(_T("name"), &Name);
|
|
177
|
+
Add(_T("type"), &Type);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
public:
|
|
181
|
+
Core::JSON::String Name; // Name of Key or Namespace
|
|
182
|
+
Core::JSON::EnumType<Exchange::IDictionary::Type> Type; // Type
|
|
183
|
+
}; // class PathEntryData
|
|
184
|
+
|
|
185
|
+
class SetParamsData : public Core::JSON::Container {
|
|
186
|
+
public:
|
|
187
|
+
SetParamsData()
|
|
188
|
+
: Core::JSON::Container()
|
|
189
|
+
{
|
|
190
|
+
Add(_T("path"), &Path);
|
|
191
|
+
Add(_T("key"), &Key);
|
|
192
|
+
Add(_T("value"), &Value);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
SetParamsData(const SetParamsData&) = delete;
|
|
196
|
+
SetParamsData(SetParamsData&&) noexcept = delete;
|
|
197
|
+
|
|
198
|
+
SetParamsData& operator=(const SetParamsData&) = delete;
|
|
199
|
+
SetParamsData& operator=(SetParamsData&&) noexcept = delete;
|
|
200
|
+
|
|
201
|
+
~SetParamsData() = default;
|
|
202
|
+
|
|
203
|
+
public:
|
|
204
|
+
bool IsDataValid() const
|
|
205
|
+
{
|
|
206
|
+
return ((Path.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true));
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
public:
|
|
210
|
+
Core::JSON::String Path; // NameSpace path to be used
|
|
211
|
+
Core::JSON::String Key; // Key to be used
|
|
212
|
+
Core::JSON::String Value; // Value to be set
|
|
213
|
+
}; // class SetParamsData
|
|
214
|
+
|
|
215
|
+
} // namespace Dictionary
|
|
216
|
+
|
|
217
|
+
POP_WARNING()
|
|
218
|
+
|
|
219
|
+
} // namespace JsonData
|
|
220
|
+
|
|
221
|
+
// Enum conversion handlers
|
|
222
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDictionary::Type)
|
|
223
|
+
|
|
224
|
+
}
|
|
225
|
+
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
// C++ types for DisplayProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDisplayInfo.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace DisplayProperties {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace DisplayProperties
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::HDCPProtectionType)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::INotification::Source)
|
|
31
|
+
ENUM_CONVERSION_HANDLER(Exchange::IHDRProperties::HDRType)
|
|
32
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::ColourSpaceType)
|
|
33
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::FrameRateType)
|
|
34
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::ColourDepthType)
|
|
35
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::ColorimetryType)
|
|
36
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::QuantizationRangeType)
|
|
37
|
+
ENUM_CONVERSION_HANDLER(Exchange::IDisplayProperties::EotfType)
|
|
38
|
+
|
|
39
|
+
}
|
|
40
|
+
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
// C++ types for Output API.
|
|
2
|
+
// Generated automatically from 'IDolby.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDolby.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Dolby {
|
|
18
|
+
|
|
19
|
+
namespace Output {
|
|
20
|
+
|
|
21
|
+
// Method params/result classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class AudioModeChangedParamsData : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
AudioModeChangedParamsData()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
Add(_T("mode"), &Mode);
|
|
30
|
+
Add(_T("enabled"), &Enabled);
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
AudioModeChangedParamsData(const AudioModeChangedParamsData&) = delete;
|
|
34
|
+
AudioModeChangedParamsData(AudioModeChangedParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
AudioModeChangedParamsData& operator=(const AudioModeChangedParamsData&) = delete;
|
|
37
|
+
AudioModeChangedParamsData& operator=(AudioModeChangedParamsData&&) noexcept = delete;
|
|
38
|
+
|
|
39
|
+
~AudioModeChangedParamsData() = default;
|
|
40
|
+
|
|
41
|
+
public:
|
|
42
|
+
bool IsDataValid() const
|
|
43
|
+
{
|
|
44
|
+
return ((Mode.IsSet() == true) && (Enabled.IsSet() == true));
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
public:
|
|
48
|
+
Core::JSON::EnumType<Exchange::Dolby::IOutput::SoundModes> Mode; // Changed Mode
|
|
49
|
+
Core::JSON::Boolean Enabled; // Enabled/Disabled
|
|
50
|
+
}; // class AudioModeChangedParamsData
|
|
51
|
+
|
|
52
|
+
} // namespace Output
|
|
53
|
+
|
|
54
|
+
} // namespace Dolby
|
|
55
|
+
|
|
56
|
+
POP_WARNING()
|
|
57
|
+
|
|
58
|
+
} // namespace JsonData
|
|
59
|
+
|
|
60
|
+
// Enum conversion handlers
|
|
61
|
+
ENUM_CONVERSION_HANDLER(Exchange::Dolby::IOutput::SoundModes)
|
|
62
|
+
ENUM_CONVERSION_HANDLER(Exchange::Dolby::IOutput::Type)
|
|
63
|
+
|
|
64
|
+
}
|
|
65
|
+
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
// C++ types for ErrorToString API.
|
|
2
|
+
// Generated automatically from 'IContentProtection.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IContentProtection.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ErrorToString {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ErrorToStringParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ErrorToStringParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("code"), &Code);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ErrorToStringParamsData(const ErrorToStringParamsData&) = delete;
|
|
31
|
+
ErrorToStringParamsData(ErrorToStringParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
ErrorToStringParamsData& operator=(const ErrorToStringParamsData&) = delete;
|
|
34
|
+
ErrorToStringParamsData& operator=(ErrorToStringParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~ErrorToStringParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Code.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecSInt32 Code;
|
|
46
|
+
}; // class ErrorToStringParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace ErrorToString
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
// Enum conversion handlers
|
|
55
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::KeySystem)
|
|
56
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::State)
|
|
57
|
+
ENUM_CONVERSION_HANDLER(Exchange::IContentProtection::INotification::Status::State)
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
@@ -0,0 +1,168 @@
|
|
|
1
|
+
// C++ types for Firmware Control API.
|
|
2
|
+
// Generated automatically from 'FirmwareControl.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace FirmwareControl {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Upgrade status
|
|
23
|
+
enum class StatusType : uint8_t {
|
|
24
|
+
NONE,
|
|
25
|
+
UPGRADESTARTED,
|
|
26
|
+
DOWNLOADSTARTED,
|
|
27
|
+
DOWNLOADABORTED,
|
|
28
|
+
DOWNLOADCOMPLETED,
|
|
29
|
+
INSTALLINITIATED,
|
|
30
|
+
INSTALLNOTSTARTED,
|
|
31
|
+
INSTALLABORTED,
|
|
32
|
+
INSTALLSTARTED,
|
|
33
|
+
UPGRADECOMPLETED,
|
|
34
|
+
UPGRADECANCELLED
|
|
35
|
+
};
|
|
36
|
+
|
|
37
|
+
// Method params/result classes
|
|
38
|
+
//
|
|
39
|
+
|
|
40
|
+
class ResumeParamsData : public Core::JSON::Container {
|
|
41
|
+
public:
|
|
42
|
+
ResumeParamsData()
|
|
43
|
+
: Core::JSON::Container()
|
|
44
|
+
{
|
|
45
|
+
Add(_T("name"), &Name);
|
|
46
|
+
Add(_T("location"), &Location);
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
ResumeParamsData(const ResumeParamsData&) = delete;
|
|
50
|
+
ResumeParamsData(ResumeParamsData&&) noexcept = delete;
|
|
51
|
+
|
|
52
|
+
ResumeParamsData& operator=(const ResumeParamsData&) = delete;
|
|
53
|
+
ResumeParamsData& operator=(ResumeParamsData&&) noexcept = delete;
|
|
54
|
+
|
|
55
|
+
~ResumeParamsData() = default;
|
|
56
|
+
|
|
57
|
+
public:
|
|
58
|
+
bool IsDataValid() const
|
|
59
|
+
{
|
|
60
|
+
return (Name.IsSet() == true);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
public:
|
|
64
|
+
Core::JSON::String Name; // Name of the firmware
|
|
65
|
+
Core::JSON::String Location; // Location or URL of the firmware to be upgraded
|
|
66
|
+
}; // class ResumeParamsData
|
|
67
|
+
|
|
68
|
+
class UpgradeParamsData : public Core::JSON::Container {
|
|
69
|
+
public:
|
|
70
|
+
// Type of the firmware
|
|
71
|
+
enum class TypeType : uint8_t {
|
|
72
|
+
CDL,
|
|
73
|
+
RCDL
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
UpgradeParamsData()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
Add(_T("name"), &Name);
|
|
80
|
+
Add(_T("location"), &Location);
|
|
81
|
+
Add(_T("type"), &Type);
|
|
82
|
+
Add(_T("progressinterval"), &Progressinterval);
|
|
83
|
+
Add(_T("hmac"), &Hmac);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
UpgradeParamsData(const UpgradeParamsData&) = delete;
|
|
87
|
+
UpgradeParamsData(UpgradeParamsData&&) noexcept = delete;
|
|
88
|
+
|
|
89
|
+
UpgradeParamsData& operator=(const UpgradeParamsData&) = delete;
|
|
90
|
+
UpgradeParamsData& operator=(UpgradeParamsData&&) noexcept = delete;
|
|
91
|
+
|
|
92
|
+
~UpgradeParamsData() = default;
|
|
93
|
+
|
|
94
|
+
public:
|
|
95
|
+
bool IsDataValid() const
|
|
96
|
+
{
|
|
97
|
+
return (Name.IsSet() == true);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
Core::JSON::String Name; // Name of the firmware
|
|
102
|
+
Core::JSON::String Location; // Location or URL of the firmware to be upgraded
|
|
103
|
+
Core::JSON::EnumType<UpgradeParamsData::TypeType> Type; // Type of the firmware
|
|
104
|
+
Core::JSON::DecUInt16 Progressinterval; // Number of seconds between progress update events (5 seconds, 10 seconds etc). 0 means invoking callback only once to report final upgrade result
|
|
105
|
+
Core::JSON::String Hmac; // HMAC value of firmare
|
|
106
|
+
}; // class UpgradeParamsData
|
|
107
|
+
|
|
108
|
+
class UpgradeprogressParamsData : public Core::JSON::Container {
|
|
109
|
+
public:
|
|
110
|
+
// Reason of error
|
|
111
|
+
enum class ErrorType : uint8_t {
|
|
112
|
+
NONE,
|
|
113
|
+
GENERIC,
|
|
114
|
+
INVALIDPARAMETERS,
|
|
115
|
+
INVALIDSTATE,
|
|
116
|
+
NOENOUGHSPACE,
|
|
117
|
+
OPERATIONOTSUPPORTED,
|
|
118
|
+
INCORRECTHASH,
|
|
119
|
+
UNAUTHENTICATED,
|
|
120
|
+
UNAVAILABLE,
|
|
121
|
+
TIMEDOUT,
|
|
122
|
+
DOWNLOADDIRECTORYNOTEXIST,
|
|
123
|
+
RESUMENOTSUPPORTED,
|
|
124
|
+
INVALIDRANGE,
|
|
125
|
+
UNKOWN
|
|
126
|
+
};
|
|
127
|
+
|
|
128
|
+
UpgradeprogressParamsData()
|
|
129
|
+
: Core::JSON::Container()
|
|
130
|
+
{
|
|
131
|
+
Add(_T("status"), &Status);
|
|
132
|
+
Add(_T("error"), &Error);
|
|
133
|
+
Add(_T("progress"), &Progress);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
UpgradeprogressParamsData(const UpgradeprogressParamsData&) = delete;
|
|
137
|
+
UpgradeprogressParamsData(UpgradeprogressParamsData&&) noexcept = delete;
|
|
138
|
+
|
|
139
|
+
UpgradeprogressParamsData& operator=(const UpgradeprogressParamsData&) = delete;
|
|
140
|
+
UpgradeprogressParamsData& operator=(UpgradeprogressParamsData&&) noexcept = delete;
|
|
141
|
+
|
|
142
|
+
~UpgradeprogressParamsData() = default;
|
|
143
|
+
|
|
144
|
+
public:
|
|
145
|
+
bool IsDataValid() const
|
|
146
|
+
{
|
|
147
|
+
return ((Status.IsSet() == true) && (Error.IsSet() == true) && (Progress.IsSet() == true));
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
public:
|
|
151
|
+
Core::JSON::EnumType<StatusType> Status; // Upgrade status
|
|
152
|
+
Core::JSON::EnumType<UpgradeprogressParamsData::ErrorType> Error; // Reason of error
|
|
153
|
+
Core::JSON::DecUInt32 Progress; // Progress of upgrade (number of bytes transferred during download or percentage of completion during install
|
|
154
|
+
}; // class UpgradeprogressParamsData
|
|
155
|
+
|
|
156
|
+
} // namespace FirmwareControl
|
|
157
|
+
|
|
158
|
+
POP_WARNING()
|
|
159
|
+
|
|
160
|
+
} // namespace JsonData
|
|
161
|
+
|
|
162
|
+
// Enum conversion handlers
|
|
163
|
+
ENUM_CONVERSION_HANDLER(JsonData::FirmwareControl::UpgradeParamsData::TypeType)
|
|
164
|
+
ENUM_CONVERSION_HANDLER(JsonData::FirmwareControl::StatusType)
|
|
165
|
+
ENUM_CONVERSION_HANDLER(JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType)
|
|
166
|
+
|
|
167
|
+
}
|
|
168
|
+
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
// C++ types for HDRProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IDisplayInfo.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace HDRProperties {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace HDRProperties
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::HDCPProtectionType)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IConnectionProperties::INotification::Source)
|
|
31
|
+
ENUM_CONVERSION_HANDLER(Exchange::IHDRProperties::HDRType)
|
|
32
|
+
|
|
33
|
+
}
|
|
34
|
+
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
// C++ types for IOConnector API.
|
|
2
|
+
// Generated automatically from 'IIOConnector.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IIOConnector.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace IOConnector {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class PinInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
PinInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("value"), &Value);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
PinInfo(const PinInfo&) = delete;
|
|
31
|
+
PinInfo(PinInfo&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
PinInfo& operator=(const PinInfo&) = delete;
|
|
34
|
+
PinInfo& operator=(PinInfo&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~PinInfo() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Value.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecSInt32 Value; // value of the pin
|
|
46
|
+
}; // class PinInfo
|
|
47
|
+
|
|
48
|
+
// Method params/result classes
|
|
49
|
+
//
|
|
50
|
+
|
|
51
|
+
} // namespace IOConnector
|
|
52
|
+
|
|
53
|
+
POP_WARNING()
|
|
54
|
+
|
|
55
|
+
} // namespace JsonData
|
|
56
|
+
|
|
57
|
+
}
|
|
58
|
+
|
|
@@ -0,0 +1,115 @@
|
|
|
1
|
+
// C++ types for Input Switch API.
|
|
2
|
+
// Generated automatically from 'InputSwitch.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace InputSwitch {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class ChannelParamsInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
ChannelParamsInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
_Init();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
ChannelParamsInfo(const ChannelParamsInfo& _other)
|
|
30
|
+
: Core::JSON::Container()
|
|
31
|
+
, Name(_other.Name)
|
|
32
|
+
, Enabled(_other.Enabled)
|
|
33
|
+
{
|
|
34
|
+
_Init();
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
ChannelParamsInfo(ChannelParamsInfo&& _other) noexcept
|
|
38
|
+
: Core::JSON::Container()
|
|
39
|
+
, Name(std::move(_other.Name))
|
|
40
|
+
, Enabled(std::move(_other.Enabled))
|
|
41
|
+
{
|
|
42
|
+
_Init();
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
ChannelParamsInfo& operator=(const ChannelParamsInfo& _rhs)
|
|
46
|
+
{
|
|
47
|
+
Name = _rhs.Name;
|
|
48
|
+
Enabled = _rhs.Enabled;
|
|
49
|
+
return (*this);
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
ChannelParamsInfo& operator=(ChannelParamsInfo&& _rhs) noexcept
|
|
53
|
+
{
|
|
54
|
+
Name = std::move(_rhs.Name);
|
|
55
|
+
Enabled = std::move(_rhs.Enabled);
|
|
56
|
+
return (*this);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
~ChannelParamsInfo() = default;
|
|
60
|
+
|
|
61
|
+
public:
|
|
62
|
+
bool IsDataValid() const
|
|
63
|
+
{
|
|
64
|
+
return ((Name.IsSet() == true) && (Enabled.IsSet() == true));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
private:
|
|
68
|
+
void _Init()
|
|
69
|
+
{
|
|
70
|
+
Add(_T("name"), &Name);
|
|
71
|
+
Add(_T("enabled"), &Enabled);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
public:
|
|
75
|
+
Core::JSON::String Name; // Callsign that is the owner of this channel
|
|
76
|
+
Core::JSON::Boolean Enabled; // Enable or disable the throughput of data through this channel
|
|
77
|
+
}; // class ChannelParamsInfo
|
|
78
|
+
|
|
79
|
+
class SelectParamsInfo : public Core::JSON::Container {
|
|
80
|
+
public:
|
|
81
|
+
SelectParamsInfo()
|
|
82
|
+
: Core::JSON::Container()
|
|
83
|
+
{
|
|
84
|
+
Add(_T("name"), &Name);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
SelectParamsInfo(const SelectParamsInfo&) = delete;
|
|
88
|
+
SelectParamsInfo(SelectParamsInfo&&) noexcept = delete;
|
|
89
|
+
|
|
90
|
+
SelectParamsInfo& operator=(const SelectParamsInfo&) = delete;
|
|
91
|
+
SelectParamsInfo& operator=(SelectParamsInfo&&) noexcept = delete;
|
|
92
|
+
|
|
93
|
+
~SelectParamsInfo() = default;
|
|
94
|
+
|
|
95
|
+
public:
|
|
96
|
+
bool IsDataValid() const
|
|
97
|
+
{
|
|
98
|
+
return (Name.IsSet() == true);
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
public:
|
|
102
|
+
Core::JSON::String Name; // Callsign that is the owner of this channel
|
|
103
|
+
}; // class SelectParamsInfo
|
|
104
|
+
|
|
105
|
+
// Method params/result classes
|
|
106
|
+
//
|
|
107
|
+
|
|
108
|
+
} // namespace InputSwitch
|
|
109
|
+
|
|
110
|
+
POP_WARNING()
|
|
111
|
+
|
|
112
|
+
} // namespace JsonData
|
|
113
|
+
|
|
114
|
+
}
|
|
115
|
+
|
|
@@ -0,0 +1,733 @@
|
|
|
1
|
+
// C++ types for LISA API.
|
|
2
|
+
// Generated automatically from 'LISA.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace LISA {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class CancelParamsInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
CancelParamsInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("handle"), &Handle);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
CancelParamsInfo(const CancelParamsInfo&) = delete;
|
|
30
|
+
CancelParamsInfo(CancelParamsInfo&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
CancelParamsInfo& operator=(const CancelParamsInfo&) = delete;
|
|
33
|
+
CancelParamsInfo& operator=(CancelParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~CancelParamsInfo() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (Handle.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Handle; // Operation handle
|
|
45
|
+
}; // class CancelParamsInfo
|
|
46
|
+
|
|
47
|
+
class GetStorageDetailsParamsInfo : public Core::JSON::Container {
|
|
48
|
+
public:
|
|
49
|
+
GetStorageDetailsParamsInfo()
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
Add(_T("type"), &Type);
|
|
53
|
+
Add(_T("id"), &Id);
|
|
54
|
+
Add(_T("version"), &Version);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
GetStorageDetailsParamsInfo(const GetStorageDetailsParamsInfo&) = delete;
|
|
58
|
+
GetStorageDetailsParamsInfo(GetStorageDetailsParamsInfo&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
GetStorageDetailsParamsInfo& operator=(const GetStorageDetailsParamsInfo&) = delete;
|
|
61
|
+
GetStorageDetailsParamsInfo& operator=(GetStorageDetailsParamsInfo&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~GetStorageDetailsParamsInfo() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
73
|
+
Core::JSON::String Id; // Application ID
|
|
74
|
+
Core::JSON::String Version; // Application version
|
|
75
|
+
}; // class GetStorageDetailsParamsInfo
|
|
76
|
+
|
|
77
|
+
class KeyvalueInfo : public Core::JSON::Container {
|
|
78
|
+
public:
|
|
79
|
+
KeyvalueInfo()
|
|
80
|
+
: Core::JSON::Container()
|
|
81
|
+
{
|
|
82
|
+
_Init();
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
KeyvalueInfo(const KeyvalueInfo& _other)
|
|
86
|
+
: Core::JSON::Container()
|
|
87
|
+
, Key(_other.Key)
|
|
88
|
+
, Value(_other.Value)
|
|
89
|
+
{
|
|
90
|
+
_Init();
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
KeyvalueInfo(KeyvalueInfo&& _other) noexcept
|
|
94
|
+
: Core::JSON::Container()
|
|
95
|
+
, Key(std::move(_other.Key))
|
|
96
|
+
, Value(std::move(_other.Value))
|
|
97
|
+
{
|
|
98
|
+
_Init();
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
KeyvalueInfo& operator=(const KeyvalueInfo& _rhs)
|
|
102
|
+
{
|
|
103
|
+
Key = _rhs.Key;
|
|
104
|
+
Value = _rhs.Value;
|
|
105
|
+
return (*this);
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
KeyvalueInfo& operator=(KeyvalueInfo&& _rhs) noexcept
|
|
109
|
+
{
|
|
110
|
+
Key = std::move(_rhs.Key);
|
|
111
|
+
Value = std::move(_rhs.Value);
|
|
112
|
+
return (*this);
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
~KeyvalueInfo() = default;
|
|
116
|
+
|
|
117
|
+
public:
|
|
118
|
+
bool IsDataValid() const
|
|
119
|
+
{
|
|
120
|
+
return ((Key.IsSet() == true) && (Value.IsSet() == true));
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
private:
|
|
124
|
+
void _Init()
|
|
125
|
+
{
|
|
126
|
+
Add(_T("key"), &Key);
|
|
127
|
+
Add(_T("value"), &Value);
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
public:
|
|
131
|
+
Core::JSON::String Key; // Key property
|
|
132
|
+
Core::JSON::String Value; // Value property
|
|
133
|
+
}; // class KeyvalueInfo
|
|
134
|
+
|
|
135
|
+
// Method params/result classes
|
|
136
|
+
//
|
|
137
|
+
|
|
138
|
+
class ClearAuxMetadataParamsData : public Core::JSON::Container {
|
|
139
|
+
public:
|
|
140
|
+
ClearAuxMetadataParamsData()
|
|
141
|
+
: Core::JSON::Container()
|
|
142
|
+
{
|
|
143
|
+
Add(_T("type"), &Type);
|
|
144
|
+
Add(_T("id"), &Id);
|
|
145
|
+
Add(_T("version"), &Version);
|
|
146
|
+
Add(_T("key"), &Key);
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
ClearAuxMetadataParamsData(const ClearAuxMetadataParamsData&) = delete;
|
|
150
|
+
ClearAuxMetadataParamsData(ClearAuxMetadataParamsData&&) noexcept = delete;
|
|
151
|
+
|
|
152
|
+
ClearAuxMetadataParamsData& operator=(const ClearAuxMetadataParamsData&) = delete;
|
|
153
|
+
ClearAuxMetadataParamsData& operator=(ClearAuxMetadataParamsData&&) noexcept = delete;
|
|
154
|
+
|
|
155
|
+
~ClearAuxMetadataParamsData() = default;
|
|
156
|
+
|
|
157
|
+
public:
|
|
158
|
+
bool IsDataValid() const
|
|
159
|
+
{
|
|
160
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Key.IsSet() == true));
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
public:
|
|
164
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
165
|
+
Core::JSON::String Id; // Application ID
|
|
166
|
+
Core::JSON::String Version; // Application version
|
|
167
|
+
Core::JSON::String Key; // Metadata key
|
|
168
|
+
}; // class ClearAuxMetadataParamsData
|
|
169
|
+
|
|
170
|
+
class DownloadParamsData : public Core::JSON::Container {
|
|
171
|
+
public:
|
|
172
|
+
DownloadParamsData()
|
|
173
|
+
: Core::JSON::Container()
|
|
174
|
+
{
|
|
175
|
+
Add(_T("type"), &Type);
|
|
176
|
+
Add(_T("id"), &Id);
|
|
177
|
+
Add(_T("version"), &Version);
|
|
178
|
+
Add(_T("resKey"), &ResKey);
|
|
179
|
+
Add(_T("resUrl"), &ResUrl);
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
DownloadParamsData(const DownloadParamsData&) = delete;
|
|
183
|
+
DownloadParamsData(DownloadParamsData&&) noexcept = delete;
|
|
184
|
+
|
|
185
|
+
DownloadParamsData& operator=(const DownloadParamsData&) = delete;
|
|
186
|
+
DownloadParamsData& operator=(DownloadParamsData&&) noexcept = delete;
|
|
187
|
+
|
|
188
|
+
~DownloadParamsData() = default;
|
|
189
|
+
|
|
190
|
+
public:
|
|
191
|
+
bool IsDataValid() const
|
|
192
|
+
{
|
|
193
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (ResKey.IsSet() == true) && (ResUrl.IsSet() == true));
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
public:
|
|
197
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
198
|
+
Core::JSON::String Id; // Application ID
|
|
199
|
+
Core::JSON::String Version; // Application version
|
|
200
|
+
Core::JSON::String ResKey; // Key to access given resource file from db entry
|
|
201
|
+
Core::JSON::String ResUrl; // Url where to download a resource from
|
|
202
|
+
}; // class DownloadParamsData
|
|
203
|
+
|
|
204
|
+
class AppslistpayloadData : public Core::JSON::Container {
|
|
205
|
+
public:
|
|
206
|
+
class AppData : public Core::JSON::Container {
|
|
207
|
+
public:
|
|
208
|
+
class InstalledappData : public Core::JSON::Container {
|
|
209
|
+
public:
|
|
210
|
+
InstalledappData()
|
|
211
|
+
: Core::JSON::Container()
|
|
212
|
+
{
|
|
213
|
+
_Init();
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
InstalledappData(const InstalledappData& _other)
|
|
217
|
+
: Core::JSON::Container()
|
|
218
|
+
, Version(_other.Version)
|
|
219
|
+
, AppName(_other.AppName)
|
|
220
|
+
, Category(_other.Category)
|
|
221
|
+
, Url(_other.Url)
|
|
222
|
+
{
|
|
223
|
+
_Init();
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
InstalledappData(InstalledappData&& _other) noexcept
|
|
227
|
+
: Core::JSON::Container()
|
|
228
|
+
, Version(std::move(_other.Version))
|
|
229
|
+
, AppName(std::move(_other.AppName))
|
|
230
|
+
, Category(std::move(_other.Category))
|
|
231
|
+
, Url(std::move(_other.Url))
|
|
232
|
+
{
|
|
233
|
+
_Init();
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
InstalledappData& operator=(const InstalledappData& _rhs)
|
|
237
|
+
{
|
|
238
|
+
Version = _rhs.Version;
|
|
239
|
+
AppName = _rhs.AppName;
|
|
240
|
+
if (_rhs.Category.Value().empty() == false) {
|
|
241
|
+
Category = _rhs.Category;
|
|
242
|
+
}
|
|
243
|
+
Url = _rhs.Url;
|
|
244
|
+
return (*this);
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
InstalledappData& operator=(InstalledappData&& _rhs) noexcept
|
|
248
|
+
{
|
|
249
|
+
Version = std::move(_rhs.Version);
|
|
250
|
+
AppName = std::move(_rhs.AppName);
|
|
251
|
+
Category = std::move(_rhs.Category);
|
|
252
|
+
Url = std::move(_rhs.Url);
|
|
253
|
+
return (*this);
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
~InstalledappData() = default;
|
|
257
|
+
|
|
258
|
+
public:
|
|
259
|
+
bool IsDataValid() const
|
|
260
|
+
{
|
|
261
|
+
return ((Version.IsSet() == true) && (AppName.IsSet() == true) && (Url.IsSet() == true));
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
private:
|
|
265
|
+
void _Init()
|
|
266
|
+
{
|
|
267
|
+
Add(_T("version"), &Version);
|
|
268
|
+
Add(_T("appName"), &AppName);
|
|
269
|
+
Add(_T("category"), &Category);
|
|
270
|
+
Add(_T("url"), &Url);
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
public:
|
|
274
|
+
Core::JSON::String Version; // Application version
|
|
275
|
+
Core::JSON::String AppName; // Application name
|
|
276
|
+
Core::JSON::String Category; // Application category
|
|
277
|
+
Core::JSON::String Url; // Application url
|
|
278
|
+
}; // class InstalledappData
|
|
279
|
+
|
|
280
|
+
AppData()
|
|
281
|
+
: Core::JSON::Container()
|
|
282
|
+
{
|
|
283
|
+
_Init();
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
AppData(const AppData& _other)
|
|
287
|
+
: Core::JSON::Container()
|
|
288
|
+
, Id(_other.Id)
|
|
289
|
+
, Type(_other.Type)
|
|
290
|
+
, Installed(_other.Installed)
|
|
291
|
+
{
|
|
292
|
+
_Init();
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
AppData(AppData&& _other) noexcept
|
|
296
|
+
: Core::JSON::Container()
|
|
297
|
+
, Id(std::move(_other.Id))
|
|
298
|
+
, Type(std::move(_other.Type))
|
|
299
|
+
, Installed(std::move(_other.Installed))
|
|
300
|
+
{
|
|
301
|
+
_Init();
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
AppData& operator=(const AppData& _rhs)
|
|
305
|
+
{
|
|
306
|
+
Id = _rhs.Id;
|
|
307
|
+
Type = _rhs.Type;
|
|
308
|
+
Installed = _rhs.Installed;
|
|
309
|
+
return (*this);
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
AppData& operator=(AppData&& _rhs) noexcept
|
|
313
|
+
{
|
|
314
|
+
Id = std::move(_rhs.Id);
|
|
315
|
+
Type = std::move(_rhs.Type);
|
|
316
|
+
Installed = std::move(_rhs.Installed);
|
|
317
|
+
return (*this);
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
~AppData() = default;
|
|
321
|
+
|
|
322
|
+
public:
|
|
323
|
+
bool IsDataValid() const
|
|
324
|
+
{
|
|
325
|
+
return ((Id.IsSet() == true) && (Type.IsSet() == true) && (Installed.IsSet() == true));
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
private:
|
|
329
|
+
void _Init()
|
|
330
|
+
{
|
|
331
|
+
Add(_T("id"), &Id);
|
|
332
|
+
Add(_T("type"), &Type);
|
|
333
|
+
Add(_T("installed"), &Installed);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
public:
|
|
337
|
+
Core::JSON::String Id; // Application ID
|
|
338
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
339
|
+
Core::JSON::ArrayType<AppslistpayloadData::AppData::InstalledappData> Installed; // List of installedApp
|
|
340
|
+
}; // class AppData
|
|
341
|
+
|
|
342
|
+
AppslistpayloadData()
|
|
343
|
+
: Core::JSON::Container()
|
|
344
|
+
{
|
|
345
|
+
Add(_T("apps"), &Apps);
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
AppslistpayloadData(const AppslistpayloadData&) = delete;
|
|
349
|
+
AppslistpayloadData(AppslistpayloadData&&) noexcept = delete;
|
|
350
|
+
|
|
351
|
+
AppslistpayloadData& operator=(const AppslistpayloadData&) = delete;
|
|
352
|
+
AppslistpayloadData& operator=(AppslistpayloadData&&) noexcept = delete;
|
|
353
|
+
|
|
354
|
+
~AppslistpayloadData() = default;
|
|
355
|
+
|
|
356
|
+
public:
|
|
357
|
+
bool IsDataValid() const
|
|
358
|
+
{
|
|
359
|
+
return (Apps.IsSet() == true);
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
public:
|
|
363
|
+
Core::JSON::ArrayType<AppslistpayloadData::AppData> Apps; // List of apps
|
|
364
|
+
}; // class AppslistpayloadData
|
|
365
|
+
|
|
366
|
+
class GetListParamsData : public Core::JSON::Container {
|
|
367
|
+
public:
|
|
368
|
+
GetListParamsData()
|
|
369
|
+
: Core::JSON::Container()
|
|
370
|
+
{
|
|
371
|
+
Add(_T("type"), &Type);
|
|
372
|
+
Add(_T("id"), &Id);
|
|
373
|
+
Add(_T("version"), &Version);
|
|
374
|
+
Add(_T("appName"), &AppName);
|
|
375
|
+
Add(_T("category"), &Category);
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
GetListParamsData(const GetListParamsData&) = delete;
|
|
379
|
+
GetListParamsData(GetListParamsData&&) noexcept = delete;
|
|
380
|
+
|
|
381
|
+
GetListParamsData& operator=(const GetListParamsData&) = delete;
|
|
382
|
+
GetListParamsData& operator=(GetListParamsData&&) noexcept = delete;
|
|
383
|
+
|
|
384
|
+
~GetListParamsData() = default;
|
|
385
|
+
|
|
386
|
+
public:
|
|
387
|
+
bool IsDataValid() const
|
|
388
|
+
{
|
|
389
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true));
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
public:
|
|
393
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
394
|
+
Core::JSON::String Id; // Application ID
|
|
395
|
+
Core::JSON::String Version; // Application version
|
|
396
|
+
Core::JSON::String AppName; // Application name
|
|
397
|
+
Core::JSON::String Category; // Application category
|
|
398
|
+
}; // class GetListParamsData
|
|
399
|
+
|
|
400
|
+
class LockinfoData : public Core::JSON::Container {
|
|
401
|
+
public:
|
|
402
|
+
LockinfoData()
|
|
403
|
+
: Core::JSON::Container()
|
|
404
|
+
{
|
|
405
|
+
Add(_T("reason"), &Reason);
|
|
406
|
+
Add(_T("owner"), &Owner);
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
LockinfoData(const LockinfoData&) = delete;
|
|
410
|
+
LockinfoData(LockinfoData&&) noexcept = delete;
|
|
411
|
+
|
|
412
|
+
LockinfoData& operator=(const LockinfoData&) = delete;
|
|
413
|
+
LockinfoData& operator=(LockinfoData&&) noexcept = delete;
|
|
414
|
+
|
|
415
|
+
~LockinfoData() = default;
|
|
416
|
+
|
|
417
|
+
public:
|
|
418
|
+
bool IsDataValid() const
|
|
419
|
+
{
|
|
420
|
+
return (true);
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
public:
|
|
424
|
+
Core::JSON::String Reason; // Reason for lock
|
|
425
|
+
Core::JSON::String Owner; // Owner of lock
|
|
426
|
+
}; // class LockinfoData
|
|
427
|
+
|
|
428
|
+
class MetadatapayloadData : public Core::JSON::Container {
|
|
429
|
+
public:
|
|
430
|
+
MetadatapayloadData()
|
|
431
|
+
: Core::JSON::Container()
|
|
432
|
+
{
|
|
433
|
+
Add(_T("appName"), &AppName);
|
|
434
|
+
Add(_T("category"), &Category);
|
|
435
|
+
Add(_T("url"), &Url);
|
|
436
|
+
Add(_T("resources"), &Resources);
|
|
437
|
+
Add(_T("auxMetadata"), &AuxMetadata);
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
MetadatapayloadData(const MetadatapayloadData&) = delete;
|
|
441
|
+
MetadatapayloadData(MetadatapayloadData&&) noexcept = delete;
|
|
442
|
+
|
|
443
|
+
MetadatapayloadData& operator=(const MetadatapayloadData&) = delete;
|
|
444
|
+
MetadatapayloadData& operator=(MetadatapayloadData&&) noexcept = delete;
|
|
445
|
+
|
|
446
|
+
~MetadatapayloadData() = default;
|
|
447
|
+
|
|
448
|
+
public:
|
|
449
|
+
bool IsDataValid() const
|
|
450
|
+
{
|
|
451
|
+
return ((Resources.IsSet() == true) && (AuxMetadata.IsSet() == true));
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
public:
|
|
455
|
+
Core::JSON::String AppName; // Application name
|
|
456
|
+
Core::JSON::String Category; // Application category
|
|
457
|
+
Core::JSON::String Url; // Application url
|
|
458
|
+
Core::JSON::ArrayType<KeyvalueInfo> Resources; // List of key-value entries
|
|
459
|
+
Core::JSON::ArrayType<KeyvalueInfo> AuxMetadata; // List of key-value entries
|
|
460
|
+
}; // class MetadatapayloadData
|
|
461
|
+
|
|
462
|
+
class StoragepayloadData : public Core::JSON::Container {
|
|
463
|
+
public:
|
|
464
|
+
class StorageData : public Core::JSON::Container {
|
|
465
|
+
public:
|
|
466
|
+
StorageData()
|
|
467
|
+
: Core::JSON::Container()
|
|
468
|
+
{
|
|
469
|
+
Add(_T("path"), &Path);
|
|
470
|
+
Add(_T("quotaKB"), &QuotaKB);
|
|
471
|
+
Add(_T("usedKB"), &UsedKB);
|
|
472
|
+
}
|
|
473
|
+
|
|
474
|
+
StorageData(const StorageData&) = delete;
|
|
475
|
+
StorageData(StorageData&&) noexcept = delete;
|
|
476
|
+
|
|
477
|
+
StorageData& operator=(const StorageData&) = delete;
|
|
478
|
+
StorageData& operator=(StorageData&&) noexcept = delete;
|
|
479
|
+
|
|
480
|
+
~StorageData() = default;
|
|
481
|
+
|
|
482
|
+
public:
|
|
483
|
+
bool IsDataValid() const
|
|
484
|
+
{
|
|
485
|
+
return ((Path.IsSet() == true) && (UsedKB.IsSet() == true));
|
|
486
|
+
}
|
|
487
|
+
|
|
488
|
+
public:
|
|
489
|
+
Core::JSON::String Path; // Path in local filesystem
|
|
490
|
+
Core::JSON::String QuotaKB; // Number of used kilobytes of storage
|
|
491
|
+
Core::JSON::String UsedKB; // Number of used kilobytes of storage
|
|
492
|
+
}; // class StorageData
|
|
493
|
+
|
|
494
|
+
StoragepayloadData()
|
|
495
|
+
: Core::JSON::Container()
|
|
496
|
+
{
|
|
497
|
+
Add(_T("apps"), &Apps);
|
|
498
|
+
Add(_T("persistent"), &Persistent);
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
StoragepayloadData(const StoragepayloadData&) = delete;
|
|
502
|
+
StoragepayloadData(StoragepayloadData&&) noexcept = delete;
|
|
503
|
+
|
|
504
|
+
StoragepayloadData& operator=(const StoragepayloadData&) = delete;
|
|
505
|
+
StoragepayloadData& operator=(StoragepayloadData&&) noexcept = delete;
|
|
506
|
+
|
|
507
|
+
~StoragepayloadData() = default;
|
|
508
|
+
|
|
509
|
+
public:
|
|
510
|
+
bool IsDataValid() const
|
|
511
|
+
{
|
|
512
|
+
return (((Apps.IsSet() == true) && (Apps.IsDataValid() == true)) && ((Persistent.IsSet() == true) && (Persistent.IsDataValid() == true)));
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
public:
|
|
516
|
+
StoragepayloadData::StorageData Apps; // Storage entry - used in results
|
|
517
|
+
StorageData Persistent; // Storage entry - used in results
|
|
518
|
+
}; // class StoragepayloadData
|
|
519
|
+
|
|
520
|
+
class InstallParamsData : public Core::JSON::Container {
|
|
521
|
+
public:
|
|
522
|
+
InstallParamsData()
|
|
523
|
+
: Core::JSON::Container()
|
|
524
|
+
{
|
|
525
|
+
Add(_T("type"), &Type);
|
|
526
|
+
Add(_T("id"), &Id);
|
|
527
|
+
Add(_T("version"), &Version);
|
|
528
|
+
Add(_T("url"), &Url);
|
|
529
|
+
Add(_T("appName"), &AppName);
|
|
530
|
+
Add(_T("category"), &Category);
|
|
531
|
+
}
|
|
532
|
+
|
|
533
|
+
InstallParamsData(const InstallParamsData&) = delete;
|
|
534
|
+
InstallParamsData(InstallParamsData&&) noexcept = delete;
|
|
535
|
+
|
|
536
|
+
InstallParamsData& operator=(const InstallParamsData&) = delete;
|
|
537
|
+
InstallParamsData& operator=(InstallParamsData&&) noexcept = delete;
|
|
538
|
+
|
|
539
|
+
~InstallParamsData() = default;
|
|
540
|
+
|
|
541
|
+
public:
|
|
542
|
+
bool IsDataValid() const
|
|
543
|
+
{
|
|
544
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Url.IsSet() == true) && (AppName.IsSet() == true) && (Category.IsSet() == true));
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
public:
|
|
548
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
549
|
+
Core::JSON::String Id; // Application ID
|
|
550
|
+
Core::JSON::String Version; // Application version
|
|
551
|
+
Core::JSON::String Url; // Application url
|
|
552
|
+
Core::JSON::String AppName; // Application name
|
|
553
|
+
Core::JSON::String Category; // Application category
|
|
554
|
+
}; // class InstallParamsData
|
|
555
|
+
|
|
556
|
+
class LockParamsData : public Core::JSON::Container {
|
|
557
|
+
public:
|
|
558
|
+
LockParamsData()
|
|
559
|
+
: Core::JSON::Container()
|
|
560
|
+
{
|
|
561
|
+
Add(_T("type"), &Type);
|
|
562
|
+
Add(_T("id"), &Id);
|
|
563
|
+
Add(_T("version"), &Version);
|
|
564
|
+
Add(_T("reason"), &Reason);
|
|
565
|
+
Add(_T("owner"), &Owner);
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
LockParamsData(const LockParamsData&) = delete;
|
|
569
|
+
LockParamsData(LockParamsData&&) noexcept = delete;
|
|
570
|
+
|
|
571
|
+
LockParamsData& operator=(const LockParamsData&) = delete;
|
|
572
|
+
LockParamsData& operator=(LockParamsData&&) noexcept = delete;
|
|
573
|
+
|
|
574
|
+
~LockParamsData() = default;
|
|
575
|
+
|
|
576
|
+
public:
|
|
577
|
+
bool IsDataValid() const
|
|
578
|
+
{
|
|
579
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true));
|
|
580
|
+
}
|
|
581
|
+
|
|
582
|
+
public:
|
|
583
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
584
|
+
Core::JSON::String Id; // Application ID
|
|
585
|
+
Core::JSON::String Version; // Application version
|
|
586
|
+
Core::JSON::String Reason; // Reason for lock
|
|
587
|
+
Core::JSON::String Owner; // Owner of lock
|
|
588
|
+
}; // class LockParamsData
|
|
589
|
+
|
|
590
|
+
class OperationStatusParamsData : public Core::JSON::Container {
|
|
591
|
+
public:
|
|
592
|
+
OperationStatusParamsData()
|
|
593
|
+
: Core::JSON::Container()
|
|
594
|
+
{
|
|
595
|
+
Add(_T("handle"), &Handle);
|
|
596
|
+
Add(_T("operation"), &Operation);
|
|
597
|
+
Add(_T("type"), &Type);
|
|
598
|
+
Add(_T("id"), &Id);
|
|
599
|
+
Add(_T("version"), &Version);
|
|
600
|
+
Add(_T("status"), &Status);
|
|
601
|
+
Add(_T("details"), &Details);
|
|
602
|
+
}
|
|
603
|
+
|
|
604
|
+
OperationStatusParamsData(const OperationStatusParamsData&) = delete;
|
|
605
|
+
OperationStatusParamsData(OperationStatusParamsData&&) noexcept = delete;
|
|
606
|
+
|
|
607
|
+
OperationStatusParamsData& operator=(const OperationStatusParamsData&) = delete;
|
|
608
|
+
OperationStatusParamsData& operator=(OperationStatusParamsData&&) noexcept = delete;
|
|
609
|
+
|
|
610
|
+
~OperationStatusParamsData() = default;
|
|
611
|
+
|
|
612
|
+
public:
|
|
613
|
+
bool IsDataValid() const
|
|
614
|
+
{
|
|
615
|
+
return ((Handle.IsSet() == true) && (Operation.IsSet() == true) && (Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Status.IsSet() == true));
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
public:
|
|
619
|
+
Core::JSON::String Handle; // Operation handle
|
|
620
|
+
Core::JSON::String Operation; // Operation
|
|
621
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
622
|
+
Core::JSON::String Id; // Application ID
|
|
623
|
+
Core::JSON::String Version; // Application version
|
|
624
|
+
Core::JSON::String Status; // Operation status
|
|
625
|
+
Core::JSON::String Details; // If error occurred this property contains details on what happened
|
|
626
|
+
}; // class OperationStatusParamsData
|
|
627
|
+
|
|
628
|
+
class ResetParamsData : public Core::JSON::Container {
|
|
629
|
+
public:
|
|
630
|
+
ResetParamsData()
|
|
631
|
+
: Core::JSON::Container()
|
|
632
|
+
{
|
|
633
|
+
Add(_T("type"), &Type);
|
|
634
|
+
Add(_T("id"), &Id);
|
|
635
|
+
Add(_T("version"), &Version);
|
|
636
|
+
Add(_T("resetType"), &ResetType);
|
|
637
|
+
}
|
|
638
|
+
|
|
639
|
+
ResetParamsData(const ResetParamsData&) = delete;
|
|
640
|
+
ResetParamsData(ResetParamsData&&) noexcept = delete;
|
|
641
|
+
|
|
642
|
+
ResetParamsData& operator=(const ResetParamsData&) = delete;
|
|
643
|
+
ResetParamsData& operator=(ResetParamsData&&) noexcept = delete;
|
|
644
|
+
|
|
645
|
+
~ResetParamsData() = default;
|
|
646
|
+
|
|
647
|
+
public:
|
|
648
|
+
bool IsDataValid() const
|
|
649
|
+
{
|
|
650
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (ResetType.IsSet() == true));
|
|
651
|
+
}
|
|
652
|
+
|
|
653
|
+
public:
|
|
654
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
655
|
+
Core::JSON::String Id; // Application ID
|
|
656
|
+
Core::JSON::String Version; // Application version
|
|
657
|
+
Core::JSON::String ResetType; // Type of the reset to perform
|
|
658
|
+
}; // class ResetParamsData
|
|
659
|
+
|
|
660
|
+
class SetAuxMetadataParamsData : public Core::JSON::Container {
|
|
661
|
+
public:
|
|
662
|
+
SetAuxMetadataParamsData()
|
|
663
|
+
: Core::JSON::Container()
|
|
664
|
+
{
|
|
665
|
+
Add(_T("type"), &Type);
|
|
666
|
+
Add(_T("id"), &Id);
|
|
667
|
+
Add(_T("version"), &Version);
|
|
668
|
+
Add(_T("key"), &Key);
|
|
669
|
+
Add(_T("value"), &Value);
|
|
670
|
+
}
|
|
671
|
+
|
|
672
|
+
SetAuxMetadataParamsData(const SetAuxMetadataParamsData&) = delete;
|
|
673
|
+
SetAuxMetadataParamsData(SetAuxMetadataParamsData&&) noexcept = delete;
|
|
674
|
+
|
|
675
|
+
SetAuxMetadataParamsData& operator=(const SetAuxMetadataParamsData&) = delete;
|
|
676
|
+
SetAuxMetadataParamsData& operator=(SetAuxMetadataParamsData&&) noexcept = delete;
|
|
677
|
+
|
|
678
|
+
~SetAuxMetadataParamsData() = default;
|
|
679
|
+
|
|
680
|
+
public:
|
|
681
|
+
bool IsDataValid() const
|
|
682
|
+
{
|
|
683
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true));
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
public:
|
|
687
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
688
|
+
Core::JSON::String Id; // Application ID
|
|
689
|
+
Core::JSON::String Version; // Application version
|
|
690
|
+
Core::JSON::String Key; // Metadata key
|
|
691
|
+
Core::JSON::String Value; // Metadata value
|
|
692
|
+
}; // class SetAuxMetadataParamsData
|
|
693
|
+
|
|
694
|
+
class UninstallParamsData : public Core::JSON::Container {
|
|
695
|
+
public:
|
|
696
|
+
UninstallParamsData()
|
|
697
|
+
: Core::JSON::Container()
|
|
698
|
+
{
|
|
699
|
+
Add(_T("type"), &Type);
|
|
700
|
+
Add(_T("id"), &Id);
|
|
701
|
+
Add(_T("version"), &Version);
|
|
702
|
+
Add(_T("uninstallType"), &UninstallType);
|
|
703
|
+
}
|
|
704
|
+
|
|
705
|
+
UninstallParamsData(const UninstallParamsData&) = delete;
|
|
706
|
+
UninstallParamsData(UninstallParamsData&&) noexcept = delete;
|
|
707
|
+
|
|
708
|
+
UninstallParamsData& operator=(const UninstallParamsData&) = delete;
|
|
709
|
+
UninstallParamsData& operator=(UninstallParamsData&&) noexcept = delete;
|
|
710
|
+
|
|
711
|
+
~UninstallParamsData() = default;
|
|
712
|
+
|
|
713
|
+
public:
|
|
714
|
+
bool IsDataValid() const
|
|
715
|
+
{
|
|
716
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (UninstallType.IsSet() == true));
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
public:
|
|
720
|
+
Core::JSON::String Type; // Application type (mime-type)
|
|
721
|
+
Core::JSON::String Id; // Application ID
|
|
722
|
+
Core::JSON::String Version; // Application version
|
|
723
|
+
Core::JSON::String UninstallType; // Type of the uninstall to perform
|
|
724
|
+
}; // class UninstallParamsData
|
|
725
|
+
|
|
726
|
+
} // namespace LISA
|
|
727
|
+
|
|
728
|
+
POP_WARNING()
|
|
729
|
+
|
|
730
|
+
} // namespace JsonData
|
|
731
|
+
|
|
732
|
+
}
|
|
733
|
+
|
|
@@ -0,0 +1,177 @@
|
|
|
1
|
+
// C++ types for LocationSync API.
|
|
2
|
+
// Generated automatically from 'ILocationSync.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/ILocationSync.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace LocationSync {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class LocationInfoData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
LocationInfoData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
LocationInfoData(const LocationInfoData& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, City(_other.City)
|
|
33
|
+
, Country(_other.Country)
|
|
34
|
+
, Region(_other.Region)
|
|
35
|
+
, TimeZone(_other.TimeZone)
|
|
36
|
+
, PublicIP(_other.PublicIP)
|
|
37
|
+
{
|
|
38
|
+
_Init();
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
LocationInfoData(LocationInfoData&& _other) noexcept
|
|
42
|
+
: Core::JSON::Container()
|
|
43
|
+
, City(std::move(_other.City))
|
|
44
|
+
, Country(std::move(_other.Country))
|
|
45
|
+
, Region(std::move(_other.Region))
|
|
46
|
+
, TimeZone(std::move(_other.TimeZone))
|
|
47
|
+
, PublicIP(std::move(_other.PublicIP))
|
|
48
|
+
{
|
|
49
|
+
_Init();
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
LocationInfoData(const Exchange::ILocationSync::LocationInfo& _other)
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
if (_other.city.IsSet() == true) {
|
|
56
|
+
City = _other.city.Value();
|
|
57
|
+
}
|
|
58
|
+
if (_other.country.IsSet() == true) {
|
|
59
|
+
Country = _other.country.Value();
|
|
60
|
+
}
|
|
61
|
+
if (_other.region.IsSet() == true) {
|
|
62
|
+
Region = _other.region.Value();
|
|
63
|
+
}
|
|
64
|
+
if (_other.timeZone.IsSet() == true) {
|
|
65
|
+
TimeZone = _other.timeZone.Value();
|
|
66
|
+
}
|
|
67
|
+
if (_other.publicIP.IsSet() == true) {
|
|
68
|
+
PublicIP = _other.publicIP.Value();
|
|
69
|
+
}
|
|
70
|
+
_Init();
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
LocationInfoData& operator=(const LocationInfoData& _rhs)
|
|
74
|
+
{
|
|
75
|
+
if (_rhs.City.IsSet() == true) {
|
|
76
|
+
City = _rhs.City;
|
|
77
|
+
}
|
|
78
|
+
if (_rhs.Country.IsSet() == true) {
|
|
79
|
+
Country = _rhs.Country;
|
|
80
|
+
}
|
|
81
|
+
if (_rhs.Region.IsSet() == true) {
|
|
82
|
+
Region = _rhs.Region;
|
|
83
|
+
}
|
|
84
|
+
if (_rhs.TimeZone.IsSet() == true) {
|
|
85
|
+
TimeZone = _rhs.TimeZone;
|
|
86
|
+
}
|
|
87
|
+
if (_rhs.PublicIP.IsSet() == true) {
|
|
88
|
+
PublicIP = _rhs.PublicIP;
|
|
89
|
+
}
|
|
90
|
+
return (*this);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
LocationInfoData& operator=(LocationInfoData&& _rhs) noexcept
|
|
94
|
+
{
|
|
95
|
+
City = std::move(_rhs.City);
|
|
96
|
+
Country = std::move(_rhs.Country);
|
|
97
|
+
Region = std::move(_rhs.Region);
|
|
98
|
+
TimeZone = std::move(_rhs.TimeZone);
|
|
99
|
+
PublicIP = std::move(_rhs.PublicIP);
|
|
100
|
+
return (*this);
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
LocationInfoData& operator=(const Exchange::ILocationSync::LocationInfo& _rhs)
|
|
104
|
+
{
|
|
105
|
+
if (_rhs.city.IsSet() == true) {
|
|
106
|
+
City = _rhs.city.Value();
|
|
107
|
+
}
|
|
108
|
+
if (_rhs.country.IsSet() == true) {
|
|
109
|
+
Country = _rhs.country.Value();
|
|
110
|
+
}
|
|
111
|
+
if (_rhs.region.IsSet() == true) {
|
|
112
|
+
Region = _rhs.region.Value();
|
|
113
|
+
}
|
|
114
|
+
if (_rhs.timeZone.IsSet() == true) {
|
|
115
|
+
TimeZone = _rhs.timeZone.Value();
|
|
116
|
+
}
|
|
117
|
+
if (_rhs.publicIP.IsSet() == true) {
|
|
118
|
+
PublicIP = _rhs.publicIP.Value();
|
|
119
|
+
}
|
|
120
|
+
return (*this);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
operator Exchange::ILocationSync::LocationInfo() const
|
|
124
|
+
{
|
|
125
|
+
Exchange::ILocationSync::LocationInfo _value{};
|
|
126
|
+
if (City.IsSet() == true) {
|
|
127
|
+
_value.city = City;
|
|
128
|
+
}
|
|
129
|
+
if (Country.IsSet() == true) {
|
|
130
|
+
_value.country = Country;
|
|
131
|
+
}
|
|
132
|
+
if (Region.IsSet() == true) {
|
|
133
|
+
_value.region = Region;
|
|
134
|
+
}
|
|
135
|
+
if (TimeZone.IsSet() == true) {
|
|
136
|
+
_value.timeZone = TimeZone;
|
|
137
|
+
}
|
|
138
|
+
if (PublicIP.IsSet() == true) {
|
|
139
|
+
_value.publicIP = PublicIP;
|
|
140
|
+
}
|
|
141
|
+
return (_value);
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
~LocationInfoData() = default;
|
|
145
|
+
|
|
146
|
+
public:
|
|
147
|
+
bool IsDataValid() const
|
|
148
|
+
{
|
|
149
|
+
return (true);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
private:
|
|
153
|
+
void _Init()
|
|
154
|
+
{
|
|
155
|
+
Add(_T("city"), &City);
|
|
156
|
+
Add(_T("country"), &Country);
|
|
157
|
+
Add(_T("region"), &Region);
|
|
158
|
+
Add(_T("timezone"), &TimeZone);
|
|
159
|
+
Add(_T("publicip"), &PublicIP);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
public:
|
|
163
|
+
Core::JSON::String City; // City name
|
|
164
|
+
Core::JSON::String Country; // Country name
|
|
165
|
+
Core::JSON::String Region; // Region name
|
|
166
|
+
Core::JSON::String TimeZone; // Time zone information
|
|
167
|
+
Core::JSON::String PublicIP; // Public IP
|
|
168
|
+
}; // class LocationInfoData
|
|
169
|
+
|
|
170
|
+
} // namespace LocationSync
|
|
171
|
+
|
|
172
|
+
POP_WARNING()
|
|
173
|
+
|
|
174
|
+
} // namespace JsonData
|
|
175
|
+
|
|
176
|
+
}
|
|
177
|
+
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
// C++ types for Math API.
|
|
2
|
+
// Generated automatically from 'IMath.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IMath.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Math {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AddParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AddParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("a"), &A);
|
|
28
|
+
Add(_T("b"), &B);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
AddParamsInfo(const AddParamsInfo&) = delete;
|
|
32
|
+
AddParamsInfo(AddParamsInfo&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
AddParamsInfo& operator=(const AddParamsInfo&) = delete;
|
|
35
|
+
AddParamsInfo& operator=(AddParamsInfo&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~AddParamsInfo() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((A.IsSet() == true) && (B.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::DecUInt16 A; // First input
|
|
47
|
+
Core::JSON::DecUInt16 B; // Second input
|
|
48
|
+
}; // class AddParamsInfo
|
|
49
|
+
|
|
50
|
+
// Method params/result classes
|
|
51
|
+
//
|
|
52
|
+
|
|
53
|
+
} // namespace Math
|
|
54
|
+
|
|
55
|
+
POP_WARNING()
|
|
56
|
+
|
|
57
|
+
} // namespace JsonData
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
@@ -0,0 +1,423 @@
|
|
|
1
|
+
// C++ types for MemoryMonitor API.
|
|
2
|
+
// Generated automatically from 'IMemoryMonitor.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IMemoryMonitor.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace MemoryMonitor {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class RestartInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
RestartInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
RestartInfo(const RestartInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Limit(_other.Limit)
|
|
33
|
+
, Window(_other.Window)
|
|
34
|
+
{
|
|
35
|
+
_Init();
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
RestartInfo(RestartInfo&& _other) noexcept
|
|
39
|
+
: Core::JSON::Container()
|
|
40
|
+
, Limit(std::move(_other.Limit))
|
|
41
|
+
, Window(std::move(_other.Window))
|
|
42
|
+
{
|
|
43
|
+
_Init();
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
RestartInfo(const Exchange::IMemoryMonitor::Restart& _other)
|
|
47
|
+
: Core::JSON::Container()
|
|
48
|
+
{
|
|
49
|
+
Limit = _other.limit;
|
|
50
|
+
Window = _other.window;
|
|
51
|
+
_Init();
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
RestartInfo& operator=(const RestartInfo& _rhs)
|
|
55
|
+
{
|
|
56
|
+
Limit = _rhs.Limit;
|
|
57
|
+
Window = _rhs.Window;
|
|
58
|
+
return (*this);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
RestartInfo& operator=(RestartInfo&& _rhs) noexcept
|
|
62
|
+
{
|
|
63
|
+
Limit = std::move(_rhs.Limit);
|
|
64
|
+
Window = std::move(_rhs.Window);
|
|
65
|
+
return (*this);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
RestartInfo& operator=(const Exchange::IMemoryMonitor::Restart& _rhs)
|
|
69
|
+
{
|
|
70
|
+
Limit = _rhs.limit;
|
|
71
|
+
Window = _rhs.window;
|
|
72
|
+
return (*this);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
operator Exchange::IMemoryMonitor::Restart() const
|
|
76
|
+
{
|
|
77
|
+
Exchange::IMemoryMonitor::Restart _value{};
|
|
78
|
+
_value.limit = Limit;
|
|
79
|
+
_value.window = Window;
|
|
80
|
+
return (_value);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
~RestartInfo() = default;
|
|
84
|
+
|
|
85
|
+
public:
|
|
86
|
+
bool IsDataValid() const
|
|
87
|
+
{
|
|
88
|
+
return ((Limit.IsSet() == true) && (Window.IsSet() == true));
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
private:
|
|
92
|
+
void _Init()
|
|
93
|
+
{
|
|
94
|
+
Add(_T("limit"), &Limit);
|
|
95
|
+
Add(_T("window"), &Window);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
Core::JSON::DecUInt8 Limit; // Maximum number or restarts to be attempted
|
|
100
|
+
Core::JSON::DecUInt16 Window; // Time period (in seconds) within which failures must happen for the limit to be considered crossed
|
|
101
|
+
}; // class RestartInfo
|
|
102
|
+
|
|
103
|
+
// Method params/result classes
|
|
104
|
+
//
|
|
105
|
+
|
|
106
|
+
class StatisticsData : public Core::JSON::Container {
|
|
107
|
+
public:
|
|
108
|
+
class MeasurementData : public Core::JSON::Container {
|
|
109
|
+
public:
|
|
110
|
+
MeasurementData()
|
|
111
|
+
: Core::JSON::Container()
|
|
112
|
+
{
|
|
113
|
+
_Init();
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
MeasurementData(const MeasurementData& _other)
|
|
117
|
+
: Core::JSON::Container()
|
|
118
|
+
, Min(_other.Min)
|
|
119
|
+
, Max(_other.Max)
|
|
120
|
+
, Average(_other.Average)
|
|
121
|
+
, Last(_other.Last)
|
|
122
|
+
{
|
|
123
|
+
_Init();
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
MeasurementData(MeasurementData&& _other) noexcept
|
|
127
|
+
: Core::JSON::Container()
|
|
128
|
+
, Min(std::move(_other.Min))
|
|
129
|
+
, Max(std::move(_other.Max))
|
|
130
|
+
, Average(std::move(_other.Average))
|
|
131
|
+
, Last(std::move(_other.Last))
|
|
132
|
+
{
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
MeasurementData(const Exchange::IMemoryMonitor::Measurement& _other)
|
|
137
|
+
: Core::JSON::Container()
|
|
138
|
+
{
|
|
139
|
+
Min = _other.min;
|
|
140
|
+
Max = _other.max;
|
|
141
|
+
Average = _other.average;
|
|
142
|
+
Last = _other.last;
|
|
143
|
+
_Init();
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
MeasurementData& operator=(const MeasurementData& _rhs)
|
|
147
|
+
{
|
|
148
|
+
Min = _rhs.Min;
|
|
149
|
+
Max = _rhs.Max;
|
|
150
|
+
Average = _rhs.Average;
|
|
151
|
+
Last = _rhs.Last;
|
|
152
|
+
return (*this);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
MeasurementData& operator=(MeasurementData&& _rhs) noexcept
|
|
156
|
+
{
|
|
157
|
+
Min = std::move(_rhs.Min);
|
|
158
|
+
Max = std::move(_rhs.Max);
|
|
159
|
+
Average = std::move(_rhs.Average);
|
|
160
|
+
Last = std::move(_rhs.Last);
|
|
161
|
+
return (*this);
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
MeasurementData& operator=(const Exchange::IMemoryMonitor::Measurement& _rhs)
|
|
165
|
+
{
|
|
166
|
+
Min = _rhs.min;
|
|
167
|
+
Max = _rhs.max;
|
|
168
|
+
Average = _rhs.average;
|
|
169
|
+
Last = _rhs.last;
|
|
170
|
+
return (*this);
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
operator Exchange::IMemoryMonitor::Measurement() const
|
|
174
|
+
{
|
|
175
|
+
Exchange::IMemoryMonitor::Measurement _value{};
|
|
176
|
+
_value.min = Min;
|
|
177
|
+
_value.max = Max;
|
|
178
|
+
_value.average = Average;
|
|
179
|
+
_value.last = Last;
|
|
180
|
+
return (_value);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
~MeasurementData() = default;
|
|
184
|
+
|
|
185
|
+
public:
|
|
186
|
+
bool IsDataValid() const
|
|
187
|
+
{
|
|
188
|
+
return ((Min.IsSet() == true) && (Max.IsSet() == true) && (Average.IsSet() == true) && (Last.IsSet() == true));
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
private:
|
|
192
|
+
void _Init()
|
|
193
|
+
{
|
|
194
|
+
Add(_T("min"), &Min);
|
|
195
|
+
Add(_T("max"), &Max);
|
|
196
|
+
Add(_T("average"), &Average);
|
|
197
|
+
Add(_T("last"), &Last);
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
public:
|
|
201
|
+
Core::JSON::DecUInt64 Min; // Minimal value measured
|
|
202
|
+
Core::JSON::DecUInt64 Max; // Maximal value measured
|
|
203
|
+
Core::JSON::DecUInt64 Average; // Average of all measurements
|
|
204
|
+
Core::JSON::DecUInt64 Last; // Last measured value
|
|
205
|
+
}; // class MeasurementData
|
|
206
|
+
|
|
207
|
+
StatisticsData()
|
|
208
|
+
: Core::JSON::Container()
|
|
209
|
+
{
|
|
210
|
+
_Init();
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
StatisticsData(const StatisticsData& _other)
|
|
214
|
+
: Core::JSON::Container()
|
|
215
|
+
, Resident(_other.Resident)
|
|
216
|
+
, Allocated(_other.Allocated)
|
|
217
|
+
, Shared(_other.Shared)
|
|
218
|
+
, Process(_other.Process)
|
|
219
|
+
, Operational(_other.Operational)
|
|
220
|
+
, Count(_other.Count)
|
|
221
|
+
{
|
|
222
|
+
_Init();
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
StatisticsData(StatisticsData&& _other) noexcept
|
|
226
|
+
: Core::JSON::Container()
|
|
227
|
+
, Resident(std::move(_other.Resident))
|
|
228
|
+
, Allocated(std::move(_other.Allocated))
|
|
229
|
+
, Shared(std::move(_other.Shared))
|
|
230
|
+
, Process(std::move(_other.Process))
|
|
231
|
+
, Operational(std::move(_other.Operational))
|
|
232
|
+
, Count(std::move(_other.Count))
|
|
233
|
+
{
|
|
234
|
+
_Init();
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
StatisticsData(const Exchange::IMemoryMonitor::Statistics& _other)
|
|
238
|
+
: Core::JSON::Container()
|
|
239
|
+
{
|
|
240
|
+
Resident.Set(true);
|
|
241
|
+
Resident = _other.resident;
|
|
242
|
+
Allocated.Set(true);
|
|
243
|
+
Allocated = _other.allocated;
|
|
244
|
+
Shared.Set(true);
|
|
245
|
+
Shared = _other.shared;
|
|
246
|
+
Process.Set(true);
|
|
247
|
+
Process = _other.process;
|
|
248
|
+
Operational = _other.operational;
|
|
249
|
+
Count = _other.count;
|
|
250
|
+
_Init();
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
StatisticsData& operator=(const StatisticsData& _rhs)
|
|
254
|
+
{
|
|
255
|
+
Resident = _rhs.Resident;
|
|
256
|
+
Allocated = _rhs.Allocated;
|
|
257
|
+
Shared = _rhs.Shared;
|
|
258
|
+
Process = _rhs.Process;
|
|
259
|
+
Operational = _rhs.Operational;
|
|
260
|
+
Count = _rhs.Count;
|
|
261
|
+
return (*this);
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
StatisticsData& operator=(StatisticsData&& _rhs) noexcept
|
|
265
|
+
{
|
|
266
|
+
Resident = std::move(_rhs.Resident);
|
|
267
|
+
Allocated = std::move(_rhs.Allocated);
|
|
268
|
+
Shared = std::move(_rhs.Shared);
|
|
269
|
+
Process = std::move(_rhs.Process);
|
|
270
|
+
Operational = std::move(_rhs.Operational);
|
|
271
|
+
Count = std::move(_rhs.Count);
|
|
272
|
+
return (*this);
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
StatisticsData& operator=(const Exchange::IMemoryMonitor::Statistics& _rhs)
|
|
276
|
+
{
|
|
277
|
+
Resident.Set(true);
|
|
278
|
+
Resident = _rhs.resident;
|
|
279
|
+
Allocated.Set(true);
|
|
280
|
+
Allocated = _rhs.allocated;
|
|
281
|
+
Shared.Set(true);
|
|
282
|
+
Shared = _rhs.shared;
|
|
283
|
+
Process.Set(true);
|
|
284
|
+
Process = _rhs.process;
|
|
285
|
+
Operational = _rhs.operational;
|
|
286
|
+
Count = _rhs.count;
|
|
287
|
+
return (*this);
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
operator Exchange::IMemoryMonitor::Statistics() const
|
|
291
|
+
{
|
|
292
|
+
Exchange::IMemoryMonitor::Statistics _value{};
|
|
293
|
+
_value.resident = Resident;
|
|
294
|
+
_value.allocated = Allocated;
|
|
295
|
+
_value.shared = Shared;
|
|
296
|
+
_value.process = Process;
|
|
297
|
+
_value.operational = Operational;
|
|
298
|
+
_value.count = Count;
|
|
299
|
+
return (_value);
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
~StatisticsData() = default;
|
|
303
|
+
|
|
304
|
+
public:
|
|
305
|
+
bool IsDataValid() const
|
|
306
|
+
{
|
|
307
|
+
return (((Resident.IsSet() == true) && (Resident.IsDataValid() == true)) && ((Allocated.IsSet() == true) && (Allocated.IsDataValid() == true)) && ((Shared.IsSet() == true) && (Shared.IsDataValid() == true)) && ((Process.IsSet() == true) && (Process.IsDataValid() == true)) && (Operational.IsSet() == true) && (Count.IsSet() == true));
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
private:
|
|
311
|
+
void _Init()
|
|
312
|
+
{
|
|
313
|
+
Add(_T("resident"), &Resident);
|
|
314
|
+
Add(_T("allocated"), &Allocated);
|
|
315
|
+
Add(_T("shared"), &Shared);
|
|
316
|
+
Add(_T("process"), &Process);
|
|
317
|
+
Add(_T("operational"), &Operational);
|
|
318
|
+
Add(_T("count"), &Count);
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
public:
|
|
322
|
+
StatisticsData::MeasurementData Resident; // Resident memory measurement
|
|
323
|
+
MeasurementData Allocated; // Allocated memory measurement
|
|
324
|
+
MeasurementData Shared; // Shared memory measurement
|
|
325
|
+
MeasurementData Process; // Processes measurement
|
|
326
|
+
Core::JSON::Boolean Operational; // Whether the service is up and running
|
|
327
|
+
Core::JSON::DecUInt32 Count; // Number of measurements
|
|
328
|
+
}; // class StatisticsData
|
|
329
|
+
|
|
330
|
+
class ResetStatisticsParamsData : public Core::JSON::Container {
|
|
331
|
+
public:
|
|
332
|
+
ResetStatisticsParamsData()
|
|
333
|
+
: Core::JSON::Container()
|
|
334
|
+
{
|
|
335
|
+
Add(_T("callsign"), &Callsign);
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
ResetStatisticsParamsData(const ResetStatisticsParamsData&) = delete;
|
|
339
|
+
ResetStatisticsParamsData(ResetStatisticsParamsData&&) noexcept = delete;
|
|
340
|
+
|
|
341
|
+
ResetStatisticsParamsData& operator=(const ResetStatisticsParamsData&) = delete;
|
|
342
|
+
ResetStatisticsParamsData& operator=(ResetStatisticsParamsData&&) noexcept = delete;
|
|
343
|
+
|
|
344
|
+
~ResetStatisticsParamsData() = default;
|
|
345
|
+
|
|
346
|
+
public:
|
|
347
|
+
bool IsDataValid() const
|
|
348
|
+
{
|
|
349
|
+
return (Callsign.IsSet() == true);
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
public:
|
|
353
|
+
Core::JSON::String Callsign; // Callsign of the service
|
|
354
|
+
}; // class ResetStatisticsParamsData
|
|
355
|
+
|
|
356
|
+
class RestartingLimitsData : public Core::JSON::Container {
|
|
357
|
+
public:
|
|
358
|
+
RestartingLimitsData()
|
|
359
|
+
: Core::JSON::Container()
|
|
360
|
+
{
|
|
361
|
+
Add(_T("value"), &Value);
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
RestartingLimitsData(const RestartingLimitsData&) = delete;
|
|
365
|
+
RestartingLimitsData(RestartingLimitsData&&) noexcept = delete;
|
|
366
|
+
|
|
367
|
+
RestartingLimitsData& operator=(const RestartingLimitsData&) = delete;
|
|
368
|
+
RestartingLimitsData& operator=(RestartingLimitsData&&) noexcept = delete;
|
|
369
|
+
|
|
370
|
+
~RestartingLimitsData() = default;
|
|
371
|
+
|
|
372
|
+
public:
|
|
373
|
+
bool IsDataValid() const
|
|
374
|
+
{
|
|
375
|
+
return ((Value.IsSet() == true) && (Value.IsDataValid() == true));
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
public:
|
|
379
|
+
RestartInfo Value; // Limits of restarts applying to a given service
|
|
380
|
+
}; // class RestartingLimitsData
|
|
381
|
+
|
|
382
|
+
class StatusChangedParamsData : public Core::JSON::Container {
|
|
383
|
+
public:
|
|
384
|
+
StatusChangedParamsData()
|
|
385
|
+
: Core::JSON::Container()
|
|
386
|
+
{
|
|
387
|
+
Add(_T("callsign"), &Callsign);
|
|
388
|
+
Add(_T("action"), &Action);
|
|
389
|
+
Add(_T("reason"), &Reason);
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
StatusChangedParamsData(const StatusChangedParamsData&) = delete;
|
|
393
|
+
StatusChangedParamsData(StatusChangedParamsData&&) noexcept = delete;
|
|
394
|
+
|
|
395
|
+
StatusChangedParamsData& operator=(const StatusChangedParamsData&) = delete;
|
|
396
|
+
StatusChangedParamsData& operator=(StatusChangedParamsData&&) noexcept = delete;
|
|
397
|
+
|
|
398
|
+
~StatusChangedParamsData() = default;
|
|
399
|
+
|
|
400
|
+
public:
|
|
401
|
+
bool IsDataValid() const
|
|
402
|
+
{
|
|
403
|
+
return ((Callsign.IsSet() == true) && (Action.IsSet() == true));
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
public:
|
|
407
|
+
Core::JSON::String Callsign; // Callsign of the service the Monitor acted upon
|
|
408
|
+
Core::JSON::EnumType<Exchange::IMemoryMonitor::INotification::action> Action; // Ation executed by the Monitor on a service
|
|
409
|
+
Core::JSON::EnumType<Exchange::IMemoryMonitor::INotification::reason> Reason; // Mssage describing the reason the action was taken
|
|
410
|
+
}; // class StatusChangedParamsData
|
|
411
|
+
|
|
412
|
+
} // namespace MemoryMonitor
|
|
413
|
+
|
|
414
|
+
POP_WARNING()
|
|
415
|
+
|
|
416
|
+
} // namespace JsonData
|
|
417
|
+
|
|
418
|
+
// Enum conversion handlers
|
|
419
|
+
ENUM_CONVERSION_HANDLER(Exchange::IMemoryMonitor::INotification::action)
|
|
420
|
+
ENUM_CONVERSION_HANDLER(Exchange::IMemoryMonitor::INotification::reason)
|
|
421
|
+
|
|
422
|
+
}
|
|
423
|
+
|
|
@@ -0,0 +1,134 @@
|
|
|
1
|
+
// C++ types for MessagingControl API.
|
|
2
|
+
// Generated automatically from 'IMessagingControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IMessagingControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace MessagingControl {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ControlInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ControlInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ControlInfo(const ControlInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Type(_other.Type)
|
|
33
|
+
, Category(_other.Category)
|
|
34
|
+
, Module(_other.Module)
|
|
35
|
+
, Enabled(_other.Enabled)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
ControlInfo(ControlInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, Type(std::move(_other.Type))
|
|
43
|
+
, Category(std::move(_other.Category))
|
|
44
|
+
, Module(std::move(_other.Module))
|
|
45
|
+
, Enabled(std::move(_other.Enabled))
|
|
46
|
+
{
|
|
47
|
+
_Init();
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
ControlInfo(const Exchange::IMessagingControl::Control& _other)
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Type = _other.type;
|
|
54
|
+
Category = _other.category;
|
|
55
|
+
Module = _other.module;
|
|
56
|
+
Enabled = _other.enabled;
|
|
57
|
+
_Init();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
ControlInfo& operator=(const ControlInfo& _rhs)
|
|
61
|
+
{
|
|
62
|
+
Type = _rhs.Type;
|
|
63
|
+
Category = _rhs.Category;
|
|
64
|
+
Module = _rhs.Module;
|
|
65
|
+
Enabled = _rhs.Enabled;
|
|
66
|
+
return (*this);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
ControlInfo& operator=(ControlInfo&& _rhs) noexcept
|
|
70
|
+
{
|
|
71
|
+
Type = std::move(_rhs.Type);
|
|
72
|
+
Category = std::move(_rhs.Category);
|
|
73
|
+
Module = std::move(_rhs.Module);
|
|
74
|
+
Enabled = std::move(_rhs.Enabled);
|
|
75
|
+
return (*this);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
ControlInfo& operator=(const Exchange::IMessagingControl::Control& _rhs)
|
|
79
|
+
{
|
|
80
|
+
Type = _rhs.type;
|
|
81
|
+
Category = _rhs.category;
|
|
82
|
+
Module = _rhs.module;
|
|
83
|
+
Enabled = _rhs.enabled;
|
|
84
|
+
return (*this);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
operator Exchange::IMessagingControl::Control() const
|
|
88
|
+
{
|
|
89
|
+
Exchange::IMessagingControl::Control _value{};
|
|
90
|
+
_value.type = Type;
|
|
91
|
+
_value.category = Category;
|
|
92
|
+
_value.module = Module;
|
|
93
|
+
_value.enabled = Enabled;
|
|
94
|
+
return (_value);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
~ControlInfo() = default;
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
bool IsDataValid() const
|
|
101
|
+
{
|
|
102
|
+
return ((Type.IsSet() == true) && (Category.IsSet() == true) && (Module.IsSet() == true) && (Enabled.IsSet() == true));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
private:
|
|
106
|
+
void _Init()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("type"), &Type);
|
|
109
|
+
Add(_T("category"), &Category);
|
|
110
|
+
Add(_T("module"), &Module);
|
|
111
|
+
Add(_T("enabled"), &Enabled);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
public:
|
|
115
|
+
Core::JSON::EnumType<Exchange::IMessagingControl::messagetype> Type; // Type of message
|
|
116
|
+
Core::JSON::String Category; // Name of the message category
|
|
117
|
+
Core::JSON::String Module; // Name of the module the message is originating from
|
|
118
|
+
Core::JSON::Boolean Enabled; // Denotes if the control is enabled (true) or disabled (false)
|
|
119
|
+
}; // class ControlInfo
|
|
120
|
+
|
|
121
|
+
// Method params/result classes
|
|
122
|
+
//
|
|
123
|
+
|
|
124
|
+
} // namespace MessagingControl
|
|
125
|
+
|
|
126
|
+
POP_WARNING()
|
|
127
|
+
|
|
128
|
+
} // namespace JsonData
|
|
129
|
+
|
|
130
|
+
// Enum conversion handlers
|
|
131
|
+
ENUM_CONVERSION_HANDLER(Exchange::IMessagingControl::messagetype)
|
|
132
|
+
|
|
133
|
+
}
|
|
134
|
+
|
|
@@ -0,0 +1,206 @@
|
|
|
1
|
+
// C++ types for Messenger API.
|
|
2
|
+
// Generated automatically from 'IMessenger.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IMessenger.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Messenger {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class JoinParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
JoinParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("room"), &Room);
|
|
28
|
+
Add(_T("user"), &User);
|
|
29
|
+
Add(_T("secure"), &Secure);
|
|
30
|
+
Add(_T("acl"), &Acl);
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
JoinParamsData(const JoinParamsData&) = delete;
|
|
34
|
+
JoinParamsData(JoinParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
JoinParamsData& operator=(const JoinParamsData&) = delete;
|
|
37
|
+
JoinParamsData& operator=(JoinParamsData&&) noexcept = delete;
|
|
38
|
+
|
|
39
|
+
~JoinParamsData() = default;
|
|
40
|
+
|
|
41
|
+
public:
|
|
42
|
+
bool IsDataValid() const
|
|
43
|
+
{
|
|
44
|
+
return ((Room.IsSet() == true) && (User.IsSet() == true));
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
public:
|
|
48
|
+
Core::JSON::String Room; // Name of the room to join
|
|
49
|
+
Core::JSON::String User; // Name of ther user to join as
|
|
50
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::security> Secure; // Denotes if the room is secure (by default not secure)
|
|
51
|
+
Core::JSON::ArrayType<Core::JSON::String> Acl; // List of URL origins with possible wildcards
|
|
52
|
+
}; // class JoinParamsData
|
|
53
|
+
|
|
54
|
+
class LeaveParamsData : public Core::JSON::Container {
|
|
55
|
+
public:
|
|
56
|
+
LeaveParamsData()
|
|
57
|
+
: Core::JSON::Container()
|
|
58
|
+
{
|
|
59
|
+
Add(_T("roomid"), &RoomId);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
LeaveParamsData(const LeaveParamsData&) = delete;
|
|
63
|
+
LeaveParamsData(LeaveParamsData&&) noexcept = delete;
|
|
64
|
+
|
|
65
|
+
LeaveParamsData& operator=(const LeaveParamsData&) = delete;
|
|
66
|
+
LeaveParamsData& operator=(LeaveParamsData&&) noexcept = delete;
|
|
67
|
+
|
|
68
|
+
~LeaveParamsData() = default;
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
bool IsDataValid() const
|
|
72
|
+
{
|
|
73
|
+
return (RoomId.IsSet() == true);
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
public:
|
|
77
|
+
Core::JSON::String RoomId; // Token of the room to leave
|
|
78
|
+
}; // class LeaveParamsData
|
|
79
|
+
|
|
80
|
+
class MessageParamsData : public Core::JSON::Container {
|
|
81
|
+
public:
|
|
82
|
+
MessageParamsData()
|
|
83
|
+
: Core::JSON::Container()
|
|
84
|
+
{
|
|
85
|
+
Add(_T("user"), &User);
|
|
86
|
+
Add(_T("message"), &Message);
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
MessageParamsData(const MessageParamsData&) = delete;
|
|
90
|
+
MessageParamsData(MessageParamsData&&) noexcept = delete;
|
|
91
|
+
|
|
92
|
+
MessageParamsData& operator=(const MessageParamsData&) = delete;
|
|
93
|
+
MessageParamsData& operator=(MessageParamsData&&) noexcept = delete;
|
|
94
|
+
|
|
95
|
+
~MessageParamsData() = default;
|
|
96
|
+
|
|
97
|
+
public:
|
|
98
|
+
bool IsDataValid() const
|
|
99
|
+
{
|
|
100
|
+
return ((User.IsSet() == true) && (Message.IsSet() == true));
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
public:
|
|
104
|
+
Core::JSON::String User; // Name of the user that has sent the message
|
|
105
|
+
Core::JSON::String Message; // Contents of the sent message
|
|
106
|
+
}; // class MessageParamsData
|
|
107
|
+
|
|
108
|
+
class RoomUpdateParamsData : public Core::JSON::Container {
|
|
109
|
+
public:
|
|
110
|
+
RoomUpdateParamsData()
|
|
111
|
+
: Core::JSON::Container()
|
|
112
|
+
{
|
|
113
|
+
Add(_T("room"), &Room);
|
|
114
|
+
Add(_T("action"), &Action);
|
|
115
|
+
Add(_T("secure"), &Secure);
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
RoomUpdateParamsData(const RoomUpdateParamsData&) = delete;
|
|
119
|
+
RoomUpdateParamsData(RoomUpdateParamsData&&) noexcept = delete;
|
|
120
|
+
|
|
121
|
+
RoomUpdateParamsData& operator=(const RoomUpdateParamsData&) = delete;
|
|
122
|
+
RoomUpdateParamsData& operator=(RoomUpdateParamsData&&) noexcept = delete;
|
|
123
|
+
|
|
124
|
+
~RoomUpdateParamsData() = default;
|
|
125
|
+
|
|
126
|
+
public:
|
|
127
|
+
bool IsDataValid() const
|
|
128
|
+
{
|
|
129
|
+
return ((Room.IsSet() == true) && (Action.IsSet() == true) && (Secure.IsSet() == true));
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
public:
|
|
133
|
+
Core::JSON::String Room; // Name of the room that has changed its status
|
|
134
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::roomupdate> Action; // New room status
|
|
135
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::security> Secure; // Denotes if the room is secure
|
|
136
|
+
}; // class RoomUpdateParamsData
|
|
137
|
+
|
|
138
|
+
class SendParamsData : public Core::JSON::Container {
|
|
139
|
+
public:
|
|
140
|
+
SendParamsData()
|
|
141
|
+
: Core::JSON::Container()
|
|
142
|
+
{
|
|
143
|
+
Add(_T("roomid"), &RoomId);
|
|
144
|
+
Add(_T("message"), &Message);
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
SendParamsData(const SendParamsData&) = delete;
|
|
148
|
+
SendParamsData(SendParamsData&&) noexcept = delete;
|
|
149
|
+
|
|
150
|
+
SendParamsData& operator=(const SendParamsData&) = delete;
|
|
151
|
+
SendParamsData& operator=(SendParamsData&&) noexcept = delete;
|
|
152
|
+
|
|
153
|
+
~SendParamsData() = default;
|
|
154
|
+
|
|
155
|
+
public:
|
|
156
|
+
bool IsDataValid() const
|
|
157
|
+
{
|
|
158
|
+
return ((RoomId.IsSet() == true) && (Message.IsSet() == true));
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
public:
|
|
162
|
+
Core::JSON::String RoomId; // Token of the room to send the message to
|
|
163
|
+
Core::JSON::String Message; // Contents of the message to send
|
|
164
|
+
}; // class SendParamsData
|
|
165
|
+
|
|
166
|
+
class UserUpdateParamsData : public Core::JSON::Container {
|
|
167
|
+
public:
|
|
168
|
+
UserUpdateParamsData()
|
|
169
|
+
: Core::JSON::Container()
|
|
170
|
+
{
|
|
171
|
+
Add(_T("user"), &User);
|
|
172
|
+
Add(_T("action"), &Action);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
UserUpdateParamsData(const UserUpdateParamsData&) = delete;
|
|
176
|
+
UserUpdateParamsData(UserUpdateParamsData&&) noexcept = delete;
|
|
177
|
+
|
|
178
|
+
UserUpdateParamsData& operator=(const UserUpdateParamsData&) = delete;
|
|
179
|
+
UserUpdateParamsData& operator=(UserUpdateParamsData&&) noexcept = delete;
|
|
180
|
+
|
|
181
|
+
~UserUpdateParamsData() = default;
|
|
182
|
+
|
|
183
|
+
public:
|
|
184
|
+
bool IsDataValid() const
|
|
185
|
+
{
|
|
186
|
+
return ((User.IsSet() == true) && (Action.IsSet() == true));
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
public:
|
|
190
|
+
Core::JSON::String User; // Name of the user that has changed its status
|
|
191
|
+
Core::JSON::EnumType<Exchange::JSONRPC::IMessenger::INotification::userupdate> Action; // New user status
|
|
192
|
+
}; // class UserUpdateParamsData
|
|
193
|
+
|
|
194
|
+
} // namespace Messenger
|
|
195
|
+
|
|
196
|
+
POP_WARNING()
|
|
197
|
+
|
|
198
|
+
} // namespace JsonData
|
|
199
|
+
|
|
200
|
+
// Enum conversion handlers
|
|
201
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IMessenger::security)
|
|
202
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IMessenger::INotification::roomupdate)
|
|
203
|
+
ENUM_CONVERSION_HANDLER(Exchange::JSONRPC::IMessenger::INotification::userupdate)
|
|
204
|
+
|
|
205
|
+
}
|
|
206
|
+
|
|
@@ -0,0 +1,389 @@
|
|
|
1
|
+
// C++ types for Monitor API.
|
|
2
|
+
// Generated automatically from 'Monitor.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Monitor {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class MeasurementInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
MeasurementInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
_Init();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
MeasurementInfo(const MeasurementInfo& _other)
|
|
30
|
+
: Core::JSON::Container()
|
|
31
|
+
, Min(_other.Min)
|
|
32
|
+
, Max(_other.Max)
|
|
33
|
+
, Average(_other.Average)
|
|
34
|
+
, Last(_other.Last)
|
|
35
|
+
{
|
|
36
|
+
_Init();
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
MeasurementInfo(MeasurementInfo&& _other) noexcept
|
|
40
|
+
: Core::JSON::Container()
|
|
41
|
+
, Min(std::move(_other.Min))
|
|
42
|
+
, Max(std::move(_other.Max))
|
|
43
|
+
, Average(std::move(_other.Average))
|
|
44
|
+
, Last(std::move(_other.Last))
|
|
45
|
+
{
|
|
46
|
+
_Init();
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
MeasurementInfo& operator=(const MeasurementInfo& _rhs)
|
|
50
|
+
{
|
|
51
|
+
Min = _rhs.Min;
|
|
52
|
+
Max = _rhs.Max;
|
|
53
|
+
Average = _rhs.Average;
|
|
54
|
+
Last = _rhs.Last;
|
|
55
|
+
return (*this);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
MeasurementInfo& operator=(MeasurementInfo&& _rhs) noexcept
|
|
59
|
+
{
|
|
60
|
+
Min = std::move(_rhs.Min);
|
|
61
|
+
Max = std::move(_rhs.Max);
|
|
62
|
+
Average = std::move(_rhs.Average);
|
|
63
|
+
Last = std::move(_rhs.Last);
|
|
64
|
+
return (*this);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
~MeasurementInfo() = default;
|
|
68
|
+
|
|
69
|
+
public:
|
|
70
|
+
bool IsDataValid() const
|
|
71
|
+
{
|
|
72
|
+
return ((Min.IsSet() == true) && (Max.IsSet() == true) && (Average.IsSet() == true) && (Last.IsSet() == true));
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
private:
|
|
76
|
+
void _Init()
|
|
77
|
+
{
|
|
78
|
+
Add(_T("min"), &Min);
|
|
79
|
+
Add(_T("max"), &Max);
|
|
80
|
+
Add(_T("average"), &Average);
|
|
81
|
+
Add(_T("last"), &Last);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
public:
|
|
85
|
+
Core::JSON::DecUInt64 Min; // Minimal value measured
|
|
86
|
+
Core::JSON::DecUInt64 Max; // Maximal value measured
|
|
87
|
+
Core::JSON::DecUInt64 Average; // Average of all measurements
|
|
88
|
+
Core::JSON::DecUInt64 Last; // Last measured value
|
|
89
|
+
}; // class MeasurementInfo
|
|
90
|
+
|
|
91
|
+
class MeasurementsInfo : public Core::JSON::Container {
|
|
92
|
+
public:
|
|
93
|
+
MeasurementsInfo()
|
|
94
|
+
: Core::JSON::Container()
|
|
95
|
+
{
|
|
96
|
+
_Init();
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
MeasurementsInfo(const MeasurementsInfo& _other)
|
|
100
|
+
: Core::JSON::Container()
|
|
101
|
+
, Resident(_other.Resident)
|
|
102
|
+
, Allocated(_other.Allocated)
|
|
103
|
+
, Shared(_other.Shared)
|
|
104
|
+
, Process(_other.Process)
|
|
105
|
+
, Operational(_other.Operational)
|
|
106
|
+
, Count(_other.Count)
|
|
107
|
+
{
|
|
108
|
+
_Init();
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
MeasurementsInfo(MeasurementsInfo&& _other) noexcept
|
|
112
|
+
: Core::JSON::Container()
|
|
113
|
+
, Resident(std::move(_other.Resident))
|
|
114
|
+
, Allocated(std::move(_other.Allocated))
|
|
115
|
+
, Shared(std::move(_other.Shared))
|
|
116
|
+
, Process(std::move(_other.Process))
|
|
117
|
+
, Operational(std::move(_other.Operational))
|
|
118
|
+
, Count(std::move(_other.Count))
|
|
119
|
+
{
|
|
120
|
+
_Init();
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
MeasurementsInfo& operator=(const MeasurementsInfo& _rhs)
|
|
124
|
+
{
|
|
125
|
+
Resident = _rhs.Resident;
|
|
126
|
+
Allocated = _rhs.Allocated;
|
|
127
|
+
Shared = _rhs.Shared;
|
|
128
|
+
Process = _rhs.Process;
|
|
129
|
+
Operational = _rhs.Operational;
|
|
130
|
+
Count = _rhs.Count;
|
|
131
|
+
return (*this);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
MeasurementsInfo& operator=(MeasurementsInfo&& _rhs) noexcept
|
|
135
|
+
{
|
|
136
|
+
Resident = std::move(_rhs.Resident);
|
|
137
|
+
Allocated = std::move(_rhs.Allocated);
|
|
138
|
+
Shared = std::move(_rhs.Shared);
|
|
139
|
+
Process = std::move(_rhs.Process);
|
|
140
|
+
Operational = std::move(_rhs.Operational);
|
|
141
|
+
Count = std::move(_rhs.Count);
|
|
142
|
+
return (*this);
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
~MeasurementsInfo() = default;
|
|
146
|
+
|
|
147
|
+
public:
|
|
148
|
+
bool IsDataValid() const
|
|
149
|
+
{
|
|
150
|
+
return (((Resident.IsSet() == true) && (Resident.IsDataValid() == true)) && ((Allocated.IsSet() == true) && (Allocated.IsDataValid() == true)) && ((Shared.IsSet() == true) && (Shared.IsDataValid() == true)) && ((Process.IsSet() == true) && (Process.IsDataValid() == true)) && (Operational.IsSet() == true) && (Count.IsSet() == true));
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
private:
|
|
154
|
+
void _Init()
|
|
155
|
+
{
|
|
156
|
+
Add(_T("resident"), &Resident);
|
|
157
|
+
Add(_T("allocated"), &Allocated);
|
|
158
|
+
Add(_T("shared"), &Shared);
|
|
159
|
+
Add(_T("process"), &Process);
|
|
160
|
+
Add(_T("operational"), &Operational);
|
|
161
|
+
Add(_T("count"), &Count);
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
public:
|
|
165
|
+
MeasurementInfo Resident; // Resident memory measurement
|
|
166
|
+
MeasurementInfo Allocated; // Allocated memory measurement
|
|
167
|
+
MeasurementInfo Shared; // Shared memory measurement
|
|
168
|
+
MeasurementInfo Process; // Processes measurement
|
|
169
|
+
Core::JSON::Boolean Operational; // Whether the service is up and running
|
|
170
|
+
Core::JSON::DecUInt32 Count; // Number of measurements
|
|
171
|
+
}; // class MeasurementsInfo
|
|
172
|
+
|
|
173
|
+
class RestartInfo : public Core::JSON::Container {
|
|
174
|
+
public:
|
|
175
|
+
RestartInfo()
|
|
176
|
+
: Core::JSON::Container()
|
|
177
|
+
{
|
|
178
|
+
_Init();
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
RestartInfo(const RestartInfo& _other)
|
|
182
|
+
: Core::JSON::Container()
|
|
183
|
+
, Limit(_other.Limit)
|
|
184
|
+
, Window(_other.Window)
|
|
185
|
+
{
|
|
186
|
+
_Init();
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
RestartInfo(RestartInfo&& _other) noexcept
|
|
190
|
+
: Core::JSON::Container()
|
|
191
|
+
, Limit(std::move(_other.Limit))
|
|
192
|
+
, Window(std::move(_other.Window))
|
|
193
|
+
{
|
|
194
|
+
_Init();
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
RestartInfo& operator=(const RestartInfo& _rhs)
|
|
198
|
+
{
|
|
199
|
+
Limit = _rhs.Limit;
|
|
200
|
+
Window = _rhs.Window;
|
|
201
|
+
return (*this);
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
RestartInfo& operator=(RestartInfo&& _rhs) noexcept
|
|
205
|
+
{
|
|
206
|
+
Limit = std::move(_rhs.Limit);
|
|
207
|
+
Window = std::move(_rhs.Window);
|
|
208
|
+
return (*this);
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
~RestartInfo() = default;
|
|
212
|
+
|
|
213
|
+
public:
|
|
214
|
+
bool IsDataValid() const
|
|
215
|
+
{
|
|
216
|
+
return ((Limit.IsSet() == true) && (Window.IsSet() == true));
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
private:
|
|
220
|
+
void _Init()
|
|
221
|
+
{
|
|
222
|
+
Add(_T("limit"), &Limit);
|
|
223
|
+
Add(_T("window"), &Window);
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
public:
|
|
227
|
+
Core::JSON::DecUInt8 Limit; // Maximum number or restarts to be attempted
|
|
228
|
+
Core::JSON::DecUInt16 Window; // Time period (in seconds) within which failures must happen for the limit to be considered crossed
|
|
229
|
+
}; // class RestartInfo
|
|
230
|
+
|
|
231
|
+
class InfoInfo : public Core::JSON::Container {
|
|
232
|
+
public:
|
|
233
|
+
InfoInfo()
|
|
234
|
+
: Core::JSON::Container()
|
|
235
|
+
{
|
|
236
|
+
_Init();
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
InfoInfo(const InfoInfo& _other)
|
|
240
|
+
: Core::JSON::Container()
|
|
241
|
+
, Measurements(_other.Measurements)
|
|
242
|
+
, Observable(_other.Observable)
|
|
243
|
+
, Restart(_other.Restart)
|
|
244
|
+
{
|
|
245
|
+
_Init();
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
InfoInfo(InfoInfo&& _other) noexcept
|
|
249
|
+
: Core::JSON::Container()
|
|
250
|
+
, Measurements(std::move(_other.Measurements))
|
|
251
|
+
, Observable(std::move(_other.Observable))
|
|
252
|
+
, Restart(std::move(_other.Restart))
|
|
253
|
+
{
|
|
254
|
+
_Init();
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
InfoInfo& operator=(const InfoInfo& _rhs)
|
|
258
|
+
{
|
|
259
|
+
Measurements = _rhs.Measurements;
|
|
260
|
+
Observable = _rhs.Observable;
|
|
261
|
+
Restart = _rhs.Restart;
|
|
262
|
+
return (*this);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
InfoInfo& operator=(InfoInfo&& _rhs) noexcept
|
|
266
|
+
{
|
|
267
|
+
Measurements = std::move(_rhs.Measurements);
|
|
268
|
+
Observable = std::move(_rhs.Observable);
|
|
269
|
+
Restart = std::move(_rhs.Restart);
|
|
270
|
+
return (*this);
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
~InfoInfo() = default;
|
|
274
|
+
|
|
275
|
+
public:
|
|
276
|
+
bool IsDataValid() const
|
|
277
|
+
{
|
|
278
|
+
return (((Measurements.IsSet() == true) && (Measurements.IsDataValid() == true)) && (Observable.IsSet() == true) && ((Restart.IsSet() == true) && (Restart.IsDataValid() == true)));
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
private:
|
|
282
|
+
void _Init()
|
|
283
|
+
{
|
|
284
|
+
Add(_T("measurements"), &Measurements);
|
|
285
|
+
Add(_T("observable"), &Observable);
|
|
286
|
+
Add(_T("restart"), &Restart);
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
public:
|
|
290
|
+
MeasurementsInfo Measurements; // Measurements for the service
|
|
291
|
+
Core::JSON::String Observable; // A callsign of the watched service
|
|
292
|
+
RestartInfo Restart; // Restart limits for failures applying to the service
|
|
293
|
+
}; // class InfoInfo
|
|
294
|
+
|
|
295
|
+
// Method params/result classes
|
|
296
|
+
//
|
|
297
|
+
|
|
298
|
+
class ActionParamsData : public Core::JSON::Container {
|
|
299
|
+
public:
|
|
300
|
+
ActionParamsData()
|
|
301
|
+
: Core::JSON::Container()
|
|
302
|
+
{
|
|
303
|
+
Add(_T("callsign"), &Callsign);
|
|
304
|
+
Add(_T("action"), &Action);
|
|
305
|
+
Add(_T("reason"), &Reason);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
ActionParamsData(const ActionParamsData&) = delete;
|
|
309
|
+
ActionParamsData(ActionParamsData&&) noexcept = delete;
|
|
310
|
+
|
|
311
|
+
ActionParamsData& operator=(const ActionParamsData&) = delete;
|
|
312
|
+
ActionParamsData& operator=(ActionParamsData&&) noexcept = delete;
|
|
313
|
+
|
|
314
|
+
~ActionParamsData() = default;
|
|
315
|
+
|
|
316
|
+
public:
|
|
317
|
+
bool IsDataValid() const
|
|
318
|
+
{
|
|
319
|
+
return ((Callsign.IsSet() == true) && (Action.IsSet() == true) && (Reason.IsSet() == true));
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
public:
|
|
323
|
+
Core::JSON::String Callsign; // Callsign of the service the Monitor acted upon
|
|
324
|
+
Core::JSON::String Action; // The action executed by the Monitor on a service. One of: "Activate", "Deactivate", "StoppedRestarting"
|
|
325
|
+
Core::JSON::String Reason; // A message describing the reason the action was taken
|
|
326
|
+
}; // class ActionParamsData
|
|
327
|
+
|
|
328
|
+
class ResetstatsParamsData : public Core::JSON::Container {
|
|
329
|
+
public:
|
|
330
|
+
ResetstatsParamsData()
|
|
331
|
+
: Core::JSON::Container()
|
|
332
|
+
{
|
|
333
|
+
Add(_T("callsign"), &Callsign);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
ResetstatsParamsData(const ResetstatsParamsData&) = delete;
|
|
337
|
+
ResetstatsParamsData(ResetstatsParamsData&&) noexcept = delete;
|
|
338
|
+
|
|
339
|
+
ResetstatsParamsData& operator=(const ResetstatsParamsData&) = delete;
|
|
340
|
+
ResetstatsParamsData& operator=(ResetstatsParamsData&&) noexcept = delete;
|
|
341
|
+
|
|
342
|
+
~ResetstatsParamsData() = default;
|
|
343
|
+
|
|
344
|
+
public:
|
|
345
|
+
bool IsDataValid() const
|
|
346
|
+
{
|
|
347
|
+
return (Callsign.IsSet() == true);
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
public:
|
|
351
|
+
Core::JSON::String Callsign; // The callsign of a service to reset statistics of
|
|
352
|
+
}; // class ResetstatsParamsData
|
|
353
|
+
|
|
354
|
+
class RestartlimitsParamsData : public Core::JSON::Container {
|
|
355
|
+
public:
|
|
356
|
+
RestartlimitsParamsData()
|
|
357
|
+
: Core::JSON::Container()
|
|
358
|
+
{
|
|
359
|
+
Add(_T("callsign"), &Callsign);
|
|
360
|
+
Add(_T("restart"), &Restart);
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
RestartlimitsParamsData(const RestartlimitsParamsData&) = delete;
|
|
364
|
+
RestartlimitsParamsData(RestartlimitsParamsData&&) noexcept = delete;
|
|
365
|
+
|
|
366
|
+
RestartlimitsParamsData& operator=(const RestartlimitsParamsData&) = delete;
|
|
367
|
+
RestartlimitsParamsData& operator=(RestartlimitsParamsData&&) noexcept = delete;
|
|
368
|
+
|
|
369
|
+
~RestartlimitsParamsData() = default;
|
|
370
|
+
|
|
371
|
+
public:
|
|
372
|
+
bool IsDataValid() const
|
|
373
|
+
{
|
|
374
|
+
return ((Callsign.IsSet() == true) && ((Restart.IsSet() == true) && (Restart.IsDataValid() == true)));
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
public:
|
|
378
|
+
Core::JSON::String Callsign; // The callsign of a service to reset measurements snapshot of
|
|
379
|
+
RestartInfo Restart; // Restart limits for failures applying to the service
|
|
380
|
+
}; // class RestartlimitsParamsData
|
|
381
|
+
|
|
382
|
+
} // namespace Monitor
|
|
383
|
+
|
|
384
|
+
POP_WARNING()
|
|
385
|
+
|
|
386
|
+
} // namespace JsonData
|
|
387
|
+
|
|
388
|
+
}
|
|
389
|
+
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
// C++ types for Netflix API.
|
|
2
|
+
// Generated automatically from 'Netflix.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Netflix {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Current Netflix visibility
|
|
23
|
+
enum class VisibilityType : uint8_t {
|
|
24
|
+
VISIBLE,
|
|
25
|
+
HIDDEN
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// Method params/result classes
|
|
29
|
+
//
|
|
30
|
+
|
|
31
|
+
class PlaybackchangeParamsData : public Core::JSON::Container {
|
|
32
|
+
public:
|
|
33
|
+
PlaybackchangeParamsData()
|
|
34
|
+
: Core::JSON::Container()
|
|
35
|
+
{
|
|
36
|
+
Add(_T("playing"), &Playing);
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
PlaybackchangeParamsData(const PlaybackchangeParamsData&) = delete;
|
|
40
|
+
PlaybackchangeParamsData(PlaybackchangeParamsData&&) noexcept = delete;
|
|
41
|
+
|
|
42
|
+
PlaybackchangeParamsData& operator=(const PlaybackchangeParamsData&) = delete;
|
|
43
|
+
PlaybackchangeParamsData& operator=(PlaybackchangeParamsData&&) noexcept = delete;
|
|
44
|
+
|
|
45
|
+
~PlaybackchangeParamsData() = default;
|
|
46
|
+
|
|
47
|
+
public:
|
|
48
|
+
bool IsDataValid() const
|
|
49
|
+
{
|
|
50
|
+
return (Playing.IsSet() == true);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
public:
|
|
54
|
+
Core::JSON::Boolean Playing; // Determines if the Netflix is in playing mode (true) or not playing (false)
|
|
55
|
+
}; // class PlaybackchangeParamsData
|
|
56
|
+
|
|
57
|
+
class SystemcommandParamsData : public Core::JSON::Container {
|
|
58
|
+
public:
|
|
59
|
+
SystemcommandParamsData()
|
|
60
|
+
: Core::JSON::Container()
|
|
61
|
+
{
|
|
62
|
+
Add(_T("command"), &Command);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
SystemcommandParamsData(const SystemcommandParamsData&) = delete;
|
|
66
|
+
SystemcommandParamsData(SystemcommandParamsData&&) noexcept = delete;
|
|
67
|
+
|
|
68
|
+
SystemcommandParamsData& operator=(const SystemcommandParamsData&) = delete;
|
|
69
|
+
SystemcommandParamsData& operator=(SystemcommandParamsData&&) noexcept = delete;
|
|
70
|
+
|
|
71
|
+
~SystemcommandParamsData() = default;
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
bool IsDataValid() const
|
|
75
|
+
{
|
|
76
|
+
return (Command.IsSet() == true);
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
public:
|
|
80
|
+
Core::JSON::String Command; // Command to send to Netflix
|
|
81
|
+
}; // class SystemcommandParamsData
|
|
82
|
+
|
|
83
|
+
} // namespace Netflix
|
|
84
|
+
|
|
85
|
+
POP_WARNING()
|
|
86
|
+
|
|
87
|
+
} // namespace JsonData
|
|
88
|
+
|
|
89
|
+
// Enum conversion handlers
|
|
90
|
+
ENUM_CONVERSION_HANDLER(JsonData::Netflix::VisibilityType)
|
|
91
|
+
|
|
92
|
+
}
|
|
93
|
+
|
|
@@ -0,0 +1,265 @@
|
|
|
1
|
+
// C++ types for NetworkControl API.
|
|
2
|
+
// Generated automatically from 'INetworkControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/INetworkControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace NetworkControl {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class NetworkInfoInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
NetworkInfoInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
NetworkInfoInfo(const NetworkInfoInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Address(_other.Address)
|
|
33
|
+
, DefaultGateway(_other.DefaultGateway)
|
|
34
|
+
, Mask(_other.Mask)
|
|
35
|
+
, Mode(_other.Mode)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
NetworkInfoInfo(NetworkInfoInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, Address(std::move(_other.Address))
|
|
43
|
+
, DefaultGateway(std::move(_other.DefaultGateway))
|
|
44
|
+
, Mask(std::move(_other.Mask))
|
|
45
|
+
, Mode(std::move(_other.Mode))
|
|
46
|
+
{
|
|
47
|
+
_Init();
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
NetworkInfoInfo(const Exchange::INetworkControl::NetworkInfo& _other)
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Address = _other.address;
|
|
54
|
+
DefaultGateway = _other.defaultGateway;
|
|
55
|
+
Mask = _other.mask;
|
|
56
|
+
Mode = _other.mode;
|
|
57
|
+
_Init();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
NetworkInfoInfo& operator=(const NetworkInfoInfo& _rhs)
|
|
61
|
+
{
|
|
62
|
+
Address = _rhs.Address;
|
|
63
|
+
DefaultGateway = _rhs.DefaultGateway;
|
|
64
|
+
Mask = _rhs.Mask;
|
|
65
|
+
Mode = _rhs.Mode;
|
|
66
|
+
return (*this);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
NetworkInfoInfo& operator=(NetworkInfoInfo&& _rhs) noexcept
|
|
70
|
+
{
|
|
71
|
+
Address = std::move(_rhs.Address);
|
|
72
|
+
DefaultGateway = std::move(_rhs.DefaultGateway);
|
|
73
|
+
Mask = std::move(_rhs.Mask);
|
|
74
|
+
Mode = std::move(_rhs.Mode);
|
|
75
|
+
return (*this);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
NetworkInfoInfo& operator=(const Exchange::INetworkControl::NetworkInfo& _rhs)
|
|
79
|
+
{
|
|
80
|
+
Address = _rhs.address;
|
|
81
|
+
DefaultGateway = _rhs.defaultGateway;
|
|
82
|
+
Mask = _rhs.mask;
|
|
83
|
+
Mode = _rhs.mode;
|
|
84
|
+
return (*this);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
operator Exchange::INetworkControl::NetworkInfo() const
|
|
88
|
+
{
|
|
89
|
+
Exchange::INetworkControl::NetworkInfo _value{};
|
|
90
|
+
_value.address = Address;
|
|
91
|
+
_value.defaultGateway = DefaultGateway;
|
|
92
|
+
_value.mask = Mask;
|
|
93
|
+
_value.mode = Mode;
|
|
94
|
+
return (_value);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
~NetworkInfoInfo() = default;
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
bool IsDataValid() const
|
|
101
|
+
{
|
|
102
|
+
return ((Address.IsSet() == true) && (DefaultGateway.IsSet() == true) && (Mask.IsSet() == true) && (Mode.IsSet() == true));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
private:
|
|
106
|
+
void _Init()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("address"), &Address);
|
|
109
|
+
Add(_T("defaultgateway"), &DefaultGateway);
|
|
110
|
+
Add(_T("mask"), &Mask);
|
|
111
|
+
Add(_T("mode"), &Mode);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
public:
|
|
115
|
+
Core::JSON::String Address; // IP Address
|
|
116
|
+
Core::JSON::String DefaultGateway; // Default Gateway
|
|
117
|
+
Core::JSON::DecUInt8 Mask; // Network mask
|
|
118
|
+
Core::JSON::EnumType<Exchange::INetworkControl::ModeType> Mode; // Mode of interface activation Dynamic or Static
|
|
119
|
+
}; // class NetworkInfoInfo
|
|
120
|
+
|
|
121
|
+
// Method params/result classes
|
|
122
|
+
//
|
|
123
|
+
|
|
124
|
+
class DNSData : public Core::JSON::Container {
|
|
125
|
+
public:
|
|
126
|
+
DNSData()
|
|
127
|
+
: Core::JSON::Container()
|
|
128
|
+
{
|
|
129
|
+
Add(_T("value"), &Value);
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
DNSData(const DNSData&) = delete;
|
|
133
|
+
DNSData(DNSData&&) noexcept = delete;
|
|
134
|
+
|
|
135
|
+
DNSData& operator=(const DNSData&) = delete;
|
|
136
|
+
DNSData& operator=(DNSData&&) noexcept = delete;
|
|
137
|
+
|
|
138
|
+
~DNSData() = default;
|
|
139
|
+
|
|
140
|
+
public:
|
|
141
|
+
bool IsDataValid() const
|
|
142
|
+
{
|
|
143
|
+
return (Value.IsSet() == true);
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
public:
|
|
147
|
+
Core::JSON::ArrayType<Core::JSON::String> Value; // DNS list
|
|
148
|
+
}; // class DNSData
|
|
149
|
+
|
|
150
|
+
class FlushParamsData : public Core::JSON::Container {
|
|
151
|
+
public:
|
|
152
|
+
FlushParamsData()
|
|
153
|
+
: Core::JSON::Container()
|
|
154
|
+
{
|
|
155
|
+
Add(_T("interface"), &Interface);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
FlushParamsData(const FlushParamsData&) = delete;
|
|
159
|
+
FlushParamsData(FlushParamsData&&) noexcept = delete;
|
|
160
|
+
|
|
161
|
+
FlushParamsData& operator=(const FlushParamsData&) = delete;
|
|
162
|
+
FlushParamsData& operator=(FlushParamsData&&) noexcept = delete;
|
|
163
|
+
|
|
164
|
+
~FlushParamsData() = default;
|
|
165
|
+
|
|
166
|
+
public:
|
|
167
|
+
bool IsDataValid() const
|
|
168
|
+
{
|
|
169
|
+
return (Interface.IsSet() == true);
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
public:
|
|
173
|
+
Core::JSON::String Interface; // Name of the interface to be flushed
|
|
174
|
+
}; // class FlushParamsData
|
|
175
|
+
|
|
176
|
+
class NetworkData : public Core::JSON::Container {
|
|
177
|
+
public:
|
|
178
|
+
NetworkData()
|
|
179
|
+
: Core::JSON::Container()
|
|
180
|
+
{
|
|
181
|
+
Add(_T("value"), &Value);
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
NetworkData(const NetworkData&) = delete;
|
|
185
|
+
NetworkData(NetworkData&&) noexcept = delete;
|
|
186
|
+
|
|
187
|
+
NetworkData& operator=(const NetworkData&) = delete;
|
|
188
|
+
NetworkData& operator=(NetworkData&&) noexcept = delete;
|
|
189
|
+
|
|
190
|
+
~NetworkData() = default;
|
|
191
|
+
|
|
192
|
+
public:
|
|
193
|
+
bool IsDataValid() const
|
|
194
|
+
{
|
|
195
|
+
return (Value.IsSet() == true);
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
public:
|
|
199
|
+
Core::JSON::ArrayType<NetworkInfoInfo> Value; // Network info of requested interface
|
|
200
|
+
}; // class NetworkData
|
|
201
|
+
|
|
202
|
+
class UpData : public Core::JSON::Container {
|
|
203
|
+
public:
|
|
204
|
+
UpData()
|
|
205
|
+
: Core::JSON::Container()
|
|
206
|
+
{
|
|
207
|
+
Add(_T("value"), &Value);
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
UpData(const UpData&) = delete;
|
|
211
|
+
UpData(UpData&&) noexcept = delete;
|
|
212
|
+
|
|
213
|
+
UpData& operator=(const UpData&) = delete;
|
|
214
|
+
UpData& operator=(UpData&&) noexcept = delete;
|
|
215
|
+
|
|
216
|
+
~UpData() = default;
|
|
217
|
+
|
|
218
|
+
public:
|
|
219
|
+
bool IsDataValid() const
|
|
220
|
+
{
|
|
221
|
+
return (Value.IsSet() == true);
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
public:
|
|
225
|
+
Core::JSON::Boolean Value; // Provides given requested interface is up or not
|
|
226
|
+
}; // class UpData
|
|
227
|
+
|
|
228
|
+
class UpdateParamsData : public Core::JSON::Container {
|
|
229
|
+
public:
|
|
230
|
+
UpdateParamsData()
|
|
231
|
+
: Core::JSON::Container()
|
|
232
|
+
{
|
|
233
|
+
Add(_T("interfacename"), &InterfaceName);
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
UpdateParamsData(const UpdateParamsData&) = delete;
|
|
237
|
+
UpdateParamsData(UpdateParamsData&&) noexcept = delete;
|
|
238
|
+
|
|
239
|
+
UpdateParamsData& operator=(const UpdateParamsData&) = delete;
|
|
240
|
+
UpdateParamsData& operator=(UpdateParamsData&&) noexcept = delete;
|
|
241
|
+
|
|
242
|
+
~UpdateParamsData() = default;
|
|
243
|
+
|
|
244
|
+
public:
|
|
245
|
+
bool IsDataValid() const
|
|
246
|
+
{
|
|
247
|
+
return (InterfaceName.IsSet() == true);
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
public:
|
|
251
|
+
Core::JSON::String InterfaceName; // Name of the interface where an update occured
|
|
252
|
+
}; // class UpdateParamsData
|
|
253
|
+
|
|
254
|
+
} // namespace NetworkControl
|
|
255
|
+
|
|
256
|
+
POP_WARNING()
|
|
257
|
+
|
|
258
|
+
} // namespace JsonData
|
|
259
|
+
|
|
260
|
+
// Enum conversion handlers
|
|
261
|
+
ENUM_CONVERSION_HANDLER(Exchange::INetworkControl::StatusType)
|
|
262
|
+
ENUM_CONVERSION_HANDLER(Exchange::INetworkControl::ModeType)
|
|
263
|
+
|
|
264
|
+
}
|
|
265
|
+
|
|
@@ -0,0 +1,115 @@
|
|
|
1
|
+
// C++ types for NetworkTools API.
|
|
2
|
+
// Generated automatically from 'INetworkTools.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/INetworkTools.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace NetworkTools {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class PingParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
PingParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("destination"), &Destination);
|
|
28
|
+
Add(_T("timeOutInSeconds"), &TimeOutInSeconds);
|
|
29
|
+
Add(_T("count"), &Count);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
PingParamsData(const PingParamsData&) = delete;
|
|
33
|
+
PingParamsData(PingParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
PingParamsData& operator=(const PingParamsData&) = delete;
|
|
36
|
+
PingParamsData& operator=(PingParamsData&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~PingParamsData() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return ((Destination.IsSet() == true) && (TimeOutInSeconds.IsSet() == true) && (Count.IsSet() == true));
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::String Destination; // The node id of the host we would like to ping (ipv4/ipv6)
|
|
48
|
+
Core::JSON::DecUInt16 TimeOutInSeconds; // Time out, continue to ping for the given duration.
|
|
49
|
+
Core::JSON::DecUInt16 Count; // Maximum number of pings to send.
|
|
50
|
+
}; // class PingParamsData
|
|
51
|
+
|
|
52
|
+
class ReportParamsData : public Core::JSON::Container {
|
|
53
|
+
public:
|
|
54
|
+
ReportParamsData()
|
|
55
|
+
: Core::JSON::Container()
|
|
56
|
+
{
|
|
57
|
+
Add(_T("source"), &Source);
|
|
58
|
+
Add(_T("metadata"), &Metadata);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
ReportParamsData(const ReportParamsData&) = delete;
|
|
62
|
+
ReportParamsData(ReportParamsData&&) noexcept = delete;
|
|
63
|
+
|
|
64
|
+
ReportParamsData& operator=(const ReportParamsData&) = delete;
|
|
65
|
+
ReportParamsData& operator=(ReportParamsData&&) noexcept = delete;
|
|
66
|
+
|
|
67
|
+
~ReportParamsData() = default;
|
|
68
|
+
|
|
69
|
+
public:
|
|
70
|
+
bool IsDataValid() const
|
|
71
|
+
{
|
|
72
|
+
return ((Source.IsSet() == true) && (Metadata.IsSet() == true));
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
public:
|
|
76
|
+
Core::JSON::String Source; // The NodeId of the system that send the metadta presented in the next field.
|
|
77
|
+
Core::JSON::String Metadata; // Depending on the tool started, this JSON string will contain additional information on this notification.
|
|
78
|
+
}; // class ReportParamsData
|
|
79
|
+
|
|
80
|
+
class TraceRouteParamsData : public Core::JSON::Container {
|
|
81
|
+
public:
|
|
82
|
+
TraceRouteParamsData()
|
|
83
|
+
: Core::JSON::Container()
|
|
84
|
+
{
|
|
85
|
+
Add(_T("destination"), &Destination);
|
|
86
|
+
Add(_T("timeOutInSeconds"), &TimeOutInSeconds);
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
TraceRouteParamsData(const TraceRouteParamsData&) = delete;
|
|
90
|
+
TraceRouteParamsData(TraceRouteParamsData&&) noexcept = delete;
|
|
91
|
+
|
|
92
|
+
TraceRouteParamsData& operator=(const TraceRouteParamsData&) = delete;
|
|
93
|
+
TraceRouteParamsData& operator=(TraceRouteParamsData&&) noexcept = delete;
|
|
94
|
+
|
|
95
|
+
~TraceRouteParamsData() = default;
|
|
96
|
+
|
|
97
|
+
public:
|
|
98
|
+
bool IsDataValid() const
|
|
99
|
+
{
|
|
100
|
+
return ((Destination.IsSet() == true) && (TimeOutInSeconds.IsSet() == true));
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
public:
|
|
104
|
+
Core::JSON::String Destination; // The node id of the host we would like to ping (ipv4/ipv6)
|
|
105
|
+
Core::JSON::DecUInt16 TimeOutInSeconds; // Time out, continue to ping for the given duration.
|
|
106
|
+
}; // class TraceRouteParamsData
|
|
107
|
+
|
|
108
|
+
} // namespace NetworkTools
|
|
109
|
+
|
|
110
|
+
POP_WARNING()
|
|
111
|
+
|
|
112
|
+
} // namespace JsonData
|
|
113
|
+
|
|
114
|
+
}
|
|
115
|
+
|
|
@@ -0,0 +1,180 @@
|
|
|
1
|
+
// C++ types for OpenCDMi API.
|
|
2
|
+
// Generated automatically from 'OCDM.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace OCDM {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class SessionInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
SessionInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
SessionInfo(const SessionInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Drm(_other.Drm)
|
|
33
|
+
{
|
|
34
|
+
_Init();
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
SessionInfo(SessionInfo&& _other) noexcept
|
|
38
|
+
: Core::JSON::Container()
|
|
39
|
+
, Drm(std::move(_other.Drm))
|
|
40
|
+
{
|
|
41
|
+
_Init();
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
SessionInfo& operator=(const SessionInfo& _rhs)
|
|
45
|
+
{
|
|
46
|
+
Drm = _rhs.Drm;
|
|
47
|
+
return (*this);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
SessionInfo& operator=(SessionInfo&& _rhs) noexcept
|
|
51
|
+
{
|
|
52
|
+
Drm = std::move(_rhs.Drm);
|
|
53
|
+
return (*this);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
~SessionInfo() = default;
|
|
57
|
+
|
|
58
|
+
public:
|
|
59
|
+
bool IsDataValid() const
|
|
60
|
+
{
|
|
61
|
+
return (Drm.IsSet() == true);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
private:
|
|
65
|
+
void _Init()
|
|
66
|
+
{
|
|
67
|
+
Add(_T("drm"), &Drm);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String Drm; // Name of the DRM system
|
|
72
|
+
}; // class SessionInfo
|
|
73
|
+
|
|
74
|
+
// Method params/result classes
|
|
75
|
+
//
|
|
76
|
+
|
|
77
|
+
class DrminitializationstatusParamsData : public Core::JSON::Container {
|
|
78
|
+
public:
|
|
79
|
+
// BUSY - drm is used by another process, SUCCESS - recovered from BUSY state after retry, FAILED - not recovered after re-trying from BUSY
|
|
80
|
+
enum class StatusType : uint8_t {
|
|
81
|
+
BUSY,
|
|
82
|
+
SUCCESS,
|
|
83
|
+
FAILED
|
|
84
|
+
};
|
|
85
|
+
|
|
86
|
+
DrminitializationstatusParamsData()
|
|
87
|
+
: Core::JSON::Container()
|
|
88
|
+
{
|
|
89
|
+
Add(_T("status"), &Status);
|
|
90
|
+
Add(_T("drm"), &Drm);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
DrminitializationstatusParamsData(const DrminitializationstatusParamsData&) = delete;
|
|
94
|
+
DrminitializationstatusParamsData(DrminitializationstatusParamsData&&) noexcept = delete;
|
|
95
|
+
|
|
96
|
+
DrminitializationstatusParamsData& operator=(const DrminitializationstatusParamsData&) = delete;
|
|
97
|
+
DrminitializationstatusParamsData& operator=(DrminitializationstatusParamsData&&) noexcept = delete;
|
|
98
|
+
|
|
99
|
+
~DrminitializationstatusParamsData() = default;
|
|
100
|
+
|
|
101
|
+
public:
|
|
102
|
+
bool IsDataValid() const
|
|
103
|
+
{
|
|
104
|
+
return ((Status.IsSet() == true) && (Drm.IsSet() == true));
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
public:
|
|
108
|
+
Core::JSON::EnumType<DrminitializationstatusParamsData::StatusType> Status; // BUSY - drm is used by another process, SUCCESS - recovered from BUSY state after retry, FAILED - not recovered after re-trying from BUSY
|
|
109
|
+
Core::JSON::String Drm; // Name of the DRM system
|
|
110
|
+
}; // class DrminitializationstatusParamsData
|
|
111
|
+
|
|
112
|
+
class DrmData : public Core::JSON::Container {
|
|
113
|
+
public:
|
|
114
|
+
DrmData()
|
|
115
|
+
: Core::JSON::Container()
|
|
116
|
+
{
|
|
117
|
+
_Init();
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
DrmData(const DrmData& _other)
|
|
121
|
+
: Core::JSON::Container()
|
|
122
|
+
, Name(_other.Name)
|
|
123
|
+
, Keysystems(_other.Keysystems)
|
|
124
|
+
{
|
|
125
|
+
_Init();
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
DrmData(DrmData&& _other) noexcept
|
|
129
|
+
: Core::JSON::Container()
|
|
130
|
+
, Name(std::move(_other.Name))
|
|
131
|
+
, Keysystems(std::move(_other.Keysystems))
|
|
132
|
+
{
|
|
133
|
+
_Init();
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
DrmData& operator=(const DrmData& _rhs)
|
|
137
|
+
{
|
|
138
|
+
Name = _rhs.Name;
|
|
139
|
+
Keysystems = _rhs.Keysystems;
|
|
140
|
+
return (*this);
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
DrmData& operator=(DrmData&& _rhs) noexcept
|
|
144
|
+
{
|
|
145
|
+
Name = std::move(_rhs.Name);
|
|
146
|
+
Keysystems = std::move(_rhs.Keysystems);
|
|
147
|
+
return (*this);
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
~DrmData() = default;
|
|
151
|
+
|
|
152
|
+
public:
|
|
153
|
+
bool IsDataValid() const
|
|
154
|
+
{
|
|
155
|
+
return ((Name.IsSet() == true) && (Keysystems.IsSet() == true));
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
private:
|
|
159
|
+
void _Init()
|
|
160
|
+
{
|
|
161
|
+
Add(_T("name"), &Name);
|
|
162
|
+
Add(_T("keysystems"), &Keysystems);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
public:
|
|
166
|
+
Core::JSON::String Name; // Name of the DRM
|
|
167
|
+
Core::JSON::ArrayType<Core::JSON::String> Keysystems; // Key system identifier list
|
|
168
|
+
}; // class DrmData
|
|
169
|
+
|
|
170
|
+
} // namespace OCDM
|
|
171
|
+
|
|
172
|
+
POP_WARNING()
|
|
173
|
+
|
|
174
|
+
} // namespace JsonData
|
|
175
|
+
|
|
176
|
+
// Enum conversion handlers
|
|
177
|
+
ENUM_CONVERSION_HANDLER(JsonData::OCDM::DrminitializationstatusParamsData::StatusType)
|
|
178
|
+
|
|
179
|
+
}
|
|
180
|
+
|
|
@@ -0,0 +1,941 @@
|
|
|
1
|
+
// C++ types for PackageManager API.
|
|
2
|
+
// Generated automatically from 'IPackageManager.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IPackageManager.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace PackageManager {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class CancelParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
CancelParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("handle"), &Handle);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
CancelParamsInfo(const CancelParamsInfo&) = delete;
|
|
31
|
+
CancelParamsInfo(CancelParamsInfo&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
CancelParamsInfo& operator=(const CancelParamsInfo&) = delete;
|
|
34
|
+
CancelParamsInfo& operator=(CancelParamsInfo&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~CancelParamsInfo() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Handle.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Handle; // Handle of the currently progressing operation (i.e, install/uninstal/download)
|
|
46
|
+
}; // class CancelParamsInfo
|
|
47
|
+
|
|
48
|
+
class GetStorageDetailsParamsInfo : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
GetStorageDetailsParamsInfo()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("type"), &Type);
|
|
54
|
+
Add(_T("id"), &Id);
|
|
55
|
+
Add(_T("version"), &Version);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
GetStorageDetailsParamsInfo(const GetStorageDetailsParamsInfo&) = delete;
|
|
59
|
+
GetStorageDetailsParamsInfo(GetStorageDetailsParamsInfo&&) noexcept = delete;
|
|
60
|
+
|
|
61
|
+
GetStorageDetailsParamsInfo& operator=(const GetStorageDetailsParamsInfo&) = delete;
|
|
62
|
+
GetStorageDetailsParamsInfo& operator=(GetStorageDetailsParamsInfo&&) noexcept = delete;
|
|
63
|
+
|
|
64
|
+
~GetStorageDetailsParamsInfo() = default;
|
|
65
|
+
|
|
66
|
+
public:
|
|
67
|
+
bool IsDataValid() const
|
|
68
|
+
{
|
|
69
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true));
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
public:
|
|
73
|
+
Core::JSON::String Type; // Type of the package
|
|
74
|
+
Core::JSON::String Id; // Id of the package
|
|
75
|
+
Core::JSON::String Version; // Version of the package
|
|
76
|
+
}; // class GetStorageDetailsParamsInfo
|
|
77
|
+
|
|
78
|
+
class KeyValueInfo : public Core::JSON::Container {
|
|
79
|
+
public:
|
|
80
|
+
KeyValueInfo()
|
|
81
|
+
: Core::JSON::Container()
|
|
82
|
+
{
|
|
83
|
+
_Init();
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
KeyValueInfo(const KeyValueInfo& _other)
|
|
87
|
+
: Core::JSON::Container()
|
|
88
|
+
, Key(_other.Key)
|
|
89
|
+
, Value(_other.Value)
|
|
90
|
+
{
|
|
91
|
+
_Init();
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
KeyValueInfo(KeyValueInfo&& _other) noexcept
|
|
95
|
+
: Core::JSON::Container()
|
|
96
|
+
, Key(std::move(_other.Key))
|
|
97
|
+
, Value(std::move(_other.Value))
|
|
98
|
+
{
|
|
99
|
+
_Init();
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
KeyValueInfo(const Exchange::IPackageManager::KeyValue& _other)
|
|
103
|
+
: Core::JSON::Container()
|
|
104
|
+
{
|
|
105
|
+
Key = _other.key;
|
|
106
|
+
Value = _other.value;
|
|
107
|
+
_Init();
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
KeyValueInfo& operator=(const KeyValueInfo& _rhs)
|
|
111
|
+
{
|
|
112
|
+
Key = _rhs.Key;
|
|
113
|
+
Value = _rhs.Value;
|
|
114
|
+
return (*this);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
KeyValueInfo& operator=(KeyValueInfo&& _rhs) noexcept
|
|
118
|
+
{
|
|
119
|
+
Key = std::move(_rhs.Key);
|
|
120
|
+
Value = std::move(_rhs.Value);
|
|
121
|
+
return (*this);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
KeyValueInfo& operator=(const Exchange::IPackageManager::KeyValue& _rhs)
|
|
125
|
+
{
|
|
126
|
+
Key = _rhs.key;
|
|
127
|
+
Value = _rhs.value;
|
|
128
|
+
return (*this);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
operator Exchange::IPackageManager::KeyValue() const
|
|
132
|
+
{
|
|
133
|
+
Exchange::IPackageManager::KeyValue _value{};
|
|
134
|
+
_value.key = Key;
|
|
135
|
+
_value.value = Value;
|
|
136
|
+
return (_value);
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
~KeyValueInfo() = default;
|
|
140
|
+
|
|
141
|
+
public:
|
|
142
|
+
bool IsDataValid() const
|
|
143
|
+
{
|
|
144
|
+
return ((Key.IsSet() == true) && (Value.IsSet() == true));
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
private:
|
|
148
|
+
void _Init()
|
|
149
|
+
{
|
|
150
|
+
Add(_T("key"), &Key);
|
|
151
|
+
Add(_T("value"), &Value);
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
public:
|
|
155
|
+
Core::JSON::String Key; // Key
|
|
156
|
+
Core::JSON::String Value; // Value
|
|
157
|
+
}; // class KeyValueInfo
|
|
158
|
+
|
|
159
|
+
// Method params/result classes
|
|
160
|
+
//
|
|
161
|
+
|
|
162
|
+
class ClearAuxMetadataParamsData : public Core::JSON::Container {
|
|
163
|
+
public:
|
|
164
|
+
ClearAuxMetadataParamsData()
|
|
165
|
+
: Core::JSON::Container()
|
|
166
|
+
{
|
|
167
|
+
Add(_T("type"), &Type);
|
|
168
|
+
Add(_T("id"), &Id);
|
|
169
|
+
Add(_T("version"), &Version);
|
|
170
|
+
Add(_T("key"), &Key);
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
ClearAuxMetadataParamsData(const ClearAuxMetadataParamsData&) = delete;
|
|
174
|
+
ClearAuxMetadataParamsData(ClearAuxMetadataParamsData&&) noexcept = delete;
|
|
175
|
+
|
|
176
|
+
ClearAuxMetadataParamsData& operator=(const ClearAuxMetadataParamsData&) = delete;
|
|
177
|
+
ClearAuxMetadataParamsData& operator=(ClearAuxMetadataParamsData&&) noexcept = delete;
|
|
178
|
+
|
|
179
|
+
~ClearAuxMetadataParamsData() = default;
|
|
180
|
+
|
|
181
|
+
public:
|
|
182
|
+
bool IsDataValid() const
|
|
183
|
+
{
|
|
184
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Key.IsSet() == true));
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
public:
|
|
188
|
+
Core::JSON::String Type; // Type of the package
|
|
189
|
+
Core::JSON::String Id; // Id of the package
|
|
190
|
+
Core::JSON::String Version; // Version of the package
|
|
191
|
+
Core::JSON::String Key; // Key used to clear arbitrary meta data
|
|
192
|
+
}; // class ClearAuxMetadataParamsData
|
|
193
|
+
|
|
194
|
+
class DownloadParamsData : public Core::JSON::Container {
|
|
195
|
+
public:
|
|
196
|
+
DownloadParamsData()
|
|
197
|
+
: Core::JSON::Container()
|
|
198
|
+
{
|
|
199
|
+
Add(_T("type"), &Type);
|
|
200
|
+
Add(_T("id"), &Id);
|
|
201
|
+
Add(_T("version"), &Version);
|
|
202
|
+
Add(_T("resKey"), &ResKey);
|
|
203
|
+
Add(_T("url"), &Url);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
DownloadParamsData(const DownloadParamsData&) = delete;
|
|
207
|
+
DownloadParamsData(DownloadParamsData&&) noexcept = delete;
|
|
208
|
+
|
|
209
|
+
DownloadParamsData& operator=(const DownloadParamsData&) = delete;
|
|
210
|
+
DownloadParamsData& operator=(DownloadParamsData&&) noexcept = delete;
|
|
211
|
+
|
|
212
|
+
~DownloadParamsData() = default;
|
|
213
|
+
|
|
214
|
+
public:
|
|
215
|
+
bool IsDataValid() const
|
|
216
|
+
{
|
|
217
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (ResKey.IsSet() == true) && (Url.IsSet() == true));
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
public:
|
|
221
|
+
Core::JSON::String Type; // Type of the package
|
|
222
|
+
Core::JSON::String Id; // Id of the package
|
|
223
|
+
Core::JSON::String Version; // Version of the package
|
|
224
|
+
Core::JSON::String ResKey; // Resorce Key
|
|
225
|
+
Core::JSON::String Url; // URL used to download package
|
|
226
|
+
}; // class DownloadParamsData
|
|
227
|
+
|
|
228
|
+
class GetListParamsData : public Core::JSON::Container {
|
|
229
|
+
public:
|
|
230
|
+
GetListParamsData()
|
|
231
|
+
: Core::JSON::Container()
|
|
232
|
+
{
|
|
233
|
+
Add(_T("type"), &Type);
|
|
234
|
+
Add(_T("id"), &Id);
|
|
235
|
+
Add(_T("version"), &Version);
|
|
236
|
+
Add(_T("appName"), &AppName);
|
|
237
|
+
Add(_T("category"), &Category);
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
GetListParamsData(const GetListParamsData&) = delete;
|
|
241
|
+
GetListParamsData(GetListParamsData&&) noexcept = delete;
|
|
242
|
+
|
|
243
|
+
GetListParamsData& operator=(const GetListParamsData&) = delete;
|
|
244
|
+
GetListParamsData& operator=(GetListParamsData&&) noexcept = delete;
|
|
245
|
+
|
|
246
|
+
~GetListParamsData() = default;
|
|
247
|
+
|
|
248
|
+
public:
|
|
249
|
+
bool IsDataValid() const
|
|
250
|
+
{
|
|
251
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (AppName.IsSet() == true) && (Category.IsSet() == true));
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
public:
|
|
255
|
+
Core::JSON::String Type; // Type of the package
|
|
256
|
+
Core::JSON::String Id; // Id of the package
|
|
257
|
+
Core::JSON::String Version; // Version of the package
|
|
258
|
+
Core::JSON::String AppName; // Application Name
|
|
259
|
+
Core::JSON::String Category; // Category of the package
|
|
260
|
+
}; // class GetListParamsData
|
|
261
|
+
|
|
262
|
+
class PackageKeyData : public Core::JSON::Container {
|
|
263
|
+
public:
|
|
264
|
+
PackageKeyData()
|
|
265
|
+
: Core::JSON::Container()
|
|
266
|
+
{
|
|
267
|
+
_Init();
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
PackageKeyData(const PackageKeyData& _other)
|
|
271
|
+
: Core::JSON::Container()
|
|
272
|
+
, Id(_other.Id)
|
|
273
|
+
, Version(_other.Version)
|
|
274
|
+
{
|
|
275
|
+
_Init();
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
PackageKeyData(PackageKeyData&& _other) noexcept
|
|
279
|
+
: Core::JSON::Container()
|
|
280
|
+
, Id(std::move(_other.Id))
|
|
281
|
+
, Version(std::move(_other.Version))
|
|
282
|
+
{
|
|
283
|
+
_Init();
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
PackageKeyData(const Exchange::IPackageManager::PackageKey& _other)
|
|
287
|
+
: Core::JSON::Container()
|
|
288
|
+
{
|
|
289
|
+
Id = _other.id;
|
|
290
|
+
Version = _other.version;
|
|
291
|
+
_Init();
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
PackageKeyData& operator=(const PackageKeyData& _rhs)
|
|
295
|
+
{
|
|
296
|
+
Id = _rhs.Id;
|
|
297
|
+
Version = _rhs.Version;
|
|
298
|
+
return (*this);
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
PackageKeyData& operator=(PackageKeyData&& _rhs) noexcept
|
|
302
|
+
{
|
|
303
|
+
Id = std::move(_rhs.Id);
|
|
304
|
+
Version = std::move(_rhs.Version);
|
|
305
|
+
return (*this);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
PackageKeyData& operator=(const Exchange::IPackageManager::PackageKey& _rhs)
|
|
309
|
+
{
|
|
310
|
+
Id = _rhs.id;
|
|
311
|
+
Version = _rhs.version;
|
|
312
|
+
return (*this);
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
operator Exchange::IPackageManager::PackageKey() const
|
|
316
|
+
{
|
|
317
|
+
Exchange::IPackageManager::PackageKey _value{};
|
|
318
|
+
_value.id = Id;
|
|
319
|
+
_value.version = Version;
|
|
320
|
+
return (_value);
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
~PackageKeyData() = default;
|
|
324
|
+
|
|
325
|
+
public:
|
|
326
|
+
bool IsDataValid() const
|
|
327
|
+
{
|
|
328
|
+
return ((Id.IsSet() == true) && (Version.IsSet() == true));
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
private:
|
|
332
|
+
void _Init()
|
|
333
|
+
{
|
|
334
|
+
Add(_T("id"), &Id);
|
|
335
|
+
Add(_T("version"), &Version);
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
public:
|
|
339
|
+
Core::JSON::String Id; // Unique identifier of the package
|
|
340
|
+
Core::JSON::String Version; // Version of the package
|
|
341
|
+
}; // class PackageKeyData
|
|
342
|
+
|
|
343
|
+
class LockInfoData : public Core::JSON::Container {
|
|
344
|
+
public:
|
|
345
|
+
LockInfoData()
|
|
346
|
+
: Core::JSON::Container()
|
|
347
|
+
{
|
|
348
|
+
_Init();
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
LockInfoData(const LockInfoData& _other)
|
|
352
|
+
: Core::JSON::Container()
|
|
353
|
+
, Reason(_other.Reason)
|
|
354
|
+
, Owner(_other.Owner)
|
|
355
|
+
{
|
|
356
|
+
_Init();
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
LockInfoData(LockInfoData&& _other) noexcept
|
|
360
|
+
: Core::JSON::Container()
|
|
361
|
+
, Reason(std::move(_other.Reason))
|
|
362
|
+
, Owner(std::move(_other.Owner))
|
|
363
|
+
{
|
|
364
|
+
_Init();
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
LockInfoData(const Exchange::IPackageManager::LockInfo& _other)
|
|
368
|
+
: Core::JSON::Container()
|
|
369
|
+
{
|
|
370
|
+
Reason = _other.reason;
|
|
371
|
+
Owner = _other.owner;
|
|
372
|
+
_Init();
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
LockInfoData& operator=(const LockInfoData& _rhs)
|
|
376
|
+
{
|
|
377
|
+
Reason = _rhs.Reason;
|
|
378
|
+
Owner = _rhs.Owner;
|
|
379
|
+
return (*this);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
LockInfoData& operator=(LockInfoData&& _rhs) noexcept
|
|
383
|
+
{
|
|
384
|
+
Reason = std::move(_rhs.Reason);
|
|
385
|
+
Owner = std::move(_rhs.Owner);
|
|
386
|
+
return (*this);
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
LockInfoData& operator=(const Exchange::IPackageManager::LockInfo& _rhs)
|
|
390
|
+
{
|
|
391
|
+
Reason = _rhs.reason;
|
|
392
|
+
Owner = _rhs.owner;
|
|
393
|
+
return (*this);
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
operator Exchange::IPackageManager::LockInfo() const
|
|
397
|
+
{
|
|
398
|
+
Exchange::IPackageManager::LockInfo _value{};
|
|
399
|
+
_value.reason = Reason;
|
|
400
|
+
_value.owner = Owner;
|
|
401
|
+
return (_value);
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
~LockInfoData() = default;
|
|
405
|
+
|
|
406
|
+
public:
|
|
407
|
+
bool IsDataValid() const
|
|
408
|
+
{
|
|
409
|
+
return ((Reason.IsSet() == true) && (Owner.IsSet() == true));
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
private:
|
|
413
|
+
void _Init()
|
|
414
|
+
{
|
|
415
|
+
Add(_T("reason"), &Reason);
|
|
416
|
+
Add(_T("owner"), &Owner);
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
public:
|
|
420
|
+
Core::JSON::String Reason; // Reason of Locking
|
|
421
|
+
Core::JSON::String Owner; // Owner of Locking
|
|
422
|
+
}; // class LockInfoData
|
|
423
|
+
|
|
424
|
+
class GetMetadataResultData : public Core::JSON::Container {
|
|
425
|
+
public:
|
|
426
|
+
class MetadataPayloadData : public Core::JSON::Container {
|
|
427
|
+
public:
|
|
428
|
+
MetadataPayloadData()
|
|
429
|
+
: Core::JSON::Container()
|
|
430
|
+
{
|
|
431
|
+
_Init();
|
|
432
|
+
}
|
|
433
|
+
|
|
434
|
+
MetadataPayloadData(const MetadataPayloadData& _other)
|
|
435
|
+
: Core::JSON::Container()
|
|
436
|
+
, AppName(_other.AppName)
|
|
437
|
+
, Type(_other.Type)
|
|
438
|
+
, Category(_other.Category)
|
|
439
|
+
, Url(_other.Url)
|
|
440
|
+
{
|
|
441
|
+
_Init();
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
MetadataPayloadData(MetadataPayloadData&& _other) noexcept
|
|
445
|
+
: Core::JSON::Container()
|
|
446
|
+
, AppName(std::move(_other.AppName))
|
|
447
|
+
, Type(std::move(_other.Type))
|
|
448
|
+
, Category(std::move(_other.Category))
|
|
449
|
+
, Url(std::move(_other.Url))
|
|
450
|
+
{
|
|
451
|
+
_Init();
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
MetadataPayloadData(const Exchange::IPackageManager::MetadataPayload& _other)
|
|
455
|
+
: Core::JSON::Container()
|
|
456
|
+
{
|
|
457
|
+
AppName = _other.appName;
|
|
458
|
+
Type = _other.type;
|
|
459
|
+
Category = _other.category;
|
|
460
|
+
Url = _other.url;
|
|
461
|
+
_Init();
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
MetadataPayloadData& operator=(const MetadataPayloadData& _rhs)
|
|
465
|
+
{
|
|
466
|
+
AppName = _rhs.AppName;
|
|
467
|
+
Type = _rhs.Type;
|
|
468
|
+
Category = _rhs.Category;
|
|
469
|
+
Url = _rhs.Url;
|
|
470
|
+
return (*this);
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
MetadataPayloadData& operator=(MetadataPayloadData&& _rhs) noexcept
|
|
474
|
+
{
|
|
475
|
+
AppName = std::move(_rhs.AppName);
|
|
476
|
+
Type = std::move(_rhs.Type);
|
|
477
|
+
Category = std::move(_rhs.Category);
|
|
478
|
+
Url = std::move(_rhs.Url);
|
|
479
|
+
return (*this);
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
MetadataPayloadData& operator=(const Exchange::IPackageManager::MetadataPayload& _rhs)
|
|
483
|
+
{
|
|
484
|
+
AppName = _rhs.appName;
|
|
485
|
+
Type = _rhs.type;
|
|
486
|
+
Category = _rhs.category;
|
|
487
|
+
Url = _rhs.url;
|
|
488
|
+
return (*this);
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
operator Exchange::IPackageManager::MetadataPayload() const
|
|
492
|
+
{
|
|
493
|
+
Exchange::IPackageManager::MetadataPayload _value{};
|
|
494
|
+
_value.appName = AppName;
|
|
495
|
+
_value.type = Type;
|
|
496
|
+
_value.category = Category;
|
|
497
|
+
_value.url = Url;
|
|
498
|
+
return (_value);
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
~MetadataPayloadData() = default;
|
|
502
|
+
|
|
503
|
+
public:
|
|
504
|
+
bool IsDataValid() const
|
|
505
|
+
{
|
|
506
|
+
return ((AppName.IsSet() == true) && (Type.IsSet() == true) && (Category.IsSet() == true) && (Url.IsSet() == true));
|
|
507
|
+
}
|
|
508
|
+
|
|
509
|
+
private:
|
|
510
|
+
void _Init()
|
|
511
|
+
{
|
|
512
|
+
Add(_T("appName"), &AppName);
|
|
513
|
+
Add(_T("type"), &Type);
|
|
514
|
+
Add(_T("category"), &Category);
|
|
515
|
+
Add(_T("url"), &Url);
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
public:
|
|
519
|
+
Core::JSON::String AppName; // Name of the application
|
|
520
|
+
Core::JSON::String Type; // Type of the package
|
|
521
|
+
Core::JSON::String Category; // Category of the package
|
|
522
|
+
Core::JSON::String Url; // URL used for operation
|
|
523
|
+
}; // class MetadataPayloadData
|
|
524
|
+
|
|
525
|
+
GetMetadataResultData()
|
|
526
|
+
: Core::JSON::Container()
|
|
527
|
+
{
|
|
528
|
+
Add(_T("metadata"), &Metadata);
|
|
529
|
+
Add(_T("resources"), &Resources);
|
|
530
|
+
Add(_T("auxMetadata"), &AuxMetadata);
|
|
531
|
+
}
|
|
532
|
+
|
|
533
|
+
GetMetadataResultData(const GetMetadataResultData&) = delete;
|
|
534
|
+
GetMetadataResultData(GetMetadataResultData&&) noexcept = delete;
|
|
535
|
+
|
|
536
|
+
GetMetadataResultData& operator=(const GetMetadataResultData&) = delete;
|
|
537
|
+
GetMetadataResultData& operator=(GetMetadataResultData&&) noexcept = delete;
|
|
538
|
+
|
|
539
|
+
~GetMetadataResultData() = default;
|
|
540
|
+
|
|
541
|
+
public:
|
|
542
|
+
bool IsDataValid() const
|
|
543
|
+
{
|
|
544
|
+
return (((Metadata.IsSet() == true) && (Metadata.IsDataValid() == true)) && (Resources.IsSet() == true) && (AuxMetadata.IsSet() == true));
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
public:
|
|
548
|
+
GetMetadataResultData::MetadataPayloadData Metadata; // Payload of meta data
|
|
549
|
+
Core::JSON::ArrayType<KeyValueInfo> Resources; // Resources
|
|
550
|
+
Core::JSON::ArrayType<KeyValueInfo> AuxMetadata; // Arbitrary metadata
|
|
551
|
+
}; // class GetMetadataResultData
|
|
552
|
+
|
|
553
|
+
class StorageInfoData : public Core::JSON::Container {
|
|
554
|
+
public:
|
|
555
|
+
class StorageDetailsData : public Core::JSON::Container {
|
|
556
|
+
public:
|
|
557
|
+
StorageDetailsData()
|
|
558
|
+
: Core::JSON::Container()
|
|
559
|
+
{
|
|
560
|
+
_Init();
|
|
561
|
+
}
|
|
562
|
+
|
|
563
|
+
StorageDetailsData(const StorageDetailsData& _other)
|
|
564
|
+
: Core::JSON::Container()
|
|
565
|
+
, Path(_other.Path)
|
|
566
|
+
, QuotaKB(_other.QuotaKB)
|
|
567
|
+
, UsedKB(_other.UsedKB)
|
|
568
|
+
{
|
|
569
|
+
_Init();
|
|
570
|
+
}
|
|
571
|
+
|
|
572
|
+
StorageDetailsData(StorageDetailsData&& _other) noexcept
|
|
573
|
+
: Core::JSON::Container()
|
|
574
|
+
, Path(std::move(_other.Path))
|
|
575
|
+
, QuotaKB(std::move(_other.QuotaKB))
|
|
576
|
+
, UsedKB(std::move(_other.UsedKB))
|
|
577
|
+
{
|
|
578
|
+
_Init();
|
|
579
|
+
}
|
|
580
|
+
|
|
581
|
+
StorageDetailsData(const Exchange::IPackageManager::StorageInfo::StorageDetails& _other)
|
|
582
|
+
: Core::JSON::Container()
|
|
583
|
+
{
|
|
584
|
+
Path = _other.path;
|
|
585
|
+
QuotaKB = _other.quotaKB;
|
|
586
|
+
UsedKB = _other.usedKB;
|
|
587
|
+
_Init();
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
StorageDetailsData& operator=(const StorageDetailsData& _rhs)
|
|
591
|
+
{
|
|
592
|
+
Path = _rhs.Path;
|
|
593
|
+
QuotaKB = _rhs.QuotaKB;
|
|
594
|
+
UsedKB = _rhs.UsedKB;
|
|
595
|
+
return (*this);
|
|
596
|
+
}
|
|
597
|
+
|
|
598
|
+
StorageDetailsData& operator=(StorageDetailsData&& _rhs) noexcept
|
|
599
|
+
{
|
|
600
|
+
Path = std::move(_rhs.Path);
|
|
601
|
+
QuotaKB = std::move(_rhs.QuotaKB);
|
|
602
|
+
UsedKB = std::move(_rhs.UsedKB);
|
|
603
|
+
return (*this);
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
StorageDetailsData& operator=(const Exchange::IPackageManager::StorageInfo::StorageDetails& _rhs)
|
|
607
|
+
{
|
|
608
|
+
Path = _rhs.path;
|
|
609
|
+
QuotaKB = _rhs.quotaKB;
|
|
610
|
+
UsedKB = _rhs.usedKB;
|
|
611
|
+
return (*this);
|
|
612
|
+
}
|
|
613
|
+
|
|
614
|
+
operator Exchange::IPackageManager::StorageInfo::StorageDetails() const
|
|
615
|
+
{
|
|
616
|
+
Exchange::IPackageManager::StorageInfo::StorageDetails _value{};
|
|
617
|
+
_value.path = Path;
|
|
618
|
+
_value.quotaKB = QuotaKB;
|
|
619
|
+
_value.usedKB = UsedKB;
|
|
620
|
+
return (_value);
|
|
621
|
+
}
|
|
622
|
+
|
|
623
|
+
~StorageDetailsData() = default;
|
|
624
|
+
|
|
625
|
+
public:
|
|
626
|
+
bool IsDataValid() const
|
|
627
|
+
{
|
|
628
|
+
return ((Path.IsSet() == true) && (QuotaKB.IsSet() == true) && (UsedKB.IsSet() == true));
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
private:
|
|
632
|
+
void _Init()
|
|
633
|
+
{
|
|
634
|
+
Add(_T("path"), &Path);
|
|
635
|
+
Add(_T("quotaKB"), &QuotaKB);
|
|
636
|
+
Add(_T("usedKB"), &UsedKB);
|
|
637
|
+
}
|
|
638
|
+
|
|
639
|
+
public:
|
|
640
|
+
Core::JSON::String Path; // Path of Storage
|
|
641
|
+
Core::JSON::String QuotaKB; // Total Space allowed in KB
|
|
642
|
+
Core::JSON::String UsedKB; // Used Space in KB
|
|
643
|
+
}; // class StorageDetailsData
|
|
644
|
+
|
|
645
|
+
StorageInfoData()
|
|
646
|
+
: Core::JSON::Container()
|
|
647
|
+
{
|
|
648
|
+
_Init();
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
StorageInfoData(const StorageInfoData& _other)
|
|
652
|
+
: Core::JSON::Container()
|
|
653
|
+
, Apps(_other.Apps)
|
|
654
|
+
, Persistent(_other.Persistent)
|
|
655
|
+
{
|
|
656
|
+
_Init();
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
StorageInfoData(StorageInfoData&& _other) noexcept
|
|
660
|
+
: Core::JSON::Container()
|
|
661
|
+
, Apps(std::move(_other.Apps))
|
|
662
|
+
, Persistent(std::move(_other.Persistent))
|
|
663
|
+
{
|
|
664
|
+
_Init();
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
StorageInfoData(const Exchange::IPackageManager::StorageInfo& _other)
|
|
668
|
+
: Core::JSON::Container()
|
|
669
|
+
{
|
|
670
|
+
Apps.Set(true);
|
|
671
|
+
Apps = _other.apps;
|
|
672
|
+
Persistent.Set(true);
|
|
673
|
+
Persistent = _other.persistent;
|
|
674
|
+
_Init();
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
StorageInfoData& operator=(const StorageInfoData& _rhs)
|
|
678
|
+
{
|
|
679
|
+
Apps = _rhs.Apps;
|
|
680
|
+
Persistent = _rhs.Persistent;
|
|
681
|
+
return (*this);
|
|
682
|
+
}
|
|
683
|
+
|
|
684
|
+
StorageInfoData& operator=(StorageInfoData&& _rhs) noexcept
|
|
685
|
+
{
|
|
686
|
+
Apps = std::move(_rhs.Apps);
|
|
687
|
+
Persistent = std::move(_rhs.Persistent);
|
|
688
|
+
return (*this);
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
StorageInfoData& operator=(const Exchange::IPackageManager::StorageInfo& _rhs)
|
|
692
|
+
{
|
|
693
|
+
Apps.Set(true);
|
|
694
|
+
Apps = _rhs.apps;
|
|
695
|
+
Persistent.Set(true);
|
|
696
|
+
Persistent = _rhs.persistent;
|
|
697
|
+
return (*this);
|
|
698
|
+
}
|
|
699
|
+
|
|
700
|
+
operator Exchange::IPackageManager::StorageInfo() const
|
|
701
|
+
{
|
|
702
|
+
Exchange::IPackageManager::StorageInfo _value{};
|
|
703
|
+
_value.apps = Apps;
|
|
704
|
+
_value.persistent = Persistent;
|
|
705
|
+
return (_value);
|
|
706
|
+
}
|
|
707
|
+
|
|
708
|
+
~StorageInfoData() = default;
|
|
709
|
+
|
|
710
|
+
public:
|
|
711
|
+
bool IsDataValid() const
|
|
712
|
+
{
|
|
713
|
+
return (((Apps.IsSet() == true) && (Apps.IsDataValid() == true)) && ((Persistent.IsSet() == true) && (Persistent.IsDataValid() == true)));
|
|
714
|
+
}
|
|
715
|
+
|
|
716
|
+
private:
|
|
717
|
+
void _Init()
|
|
718
|
+
{
|
|
719
|
+
Add(_T("apps"), &Apps);
|
|
720
|
+
Add(_T("persistent"), &Persistent);
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
public:
|
|
724
|
+
StorageInfoData::StorageDetailsData Apps; // Storage details of application
|
|
725
|
+
StorageDetailsData Persistent; // Storage details of persistent
|
|
726
|
+
}; // class StorageInfoData
|
|
727
|
+
|
|
728
|
+
class InstallParamsData : public Core::JSON::Container {
|
|
729
|
+
public:
|
|
730
|
+
InstallParamsData()
|
|
731
|
+
: Core::JSON::Container()
|
|
732
|
+
{
|
|
733
|
+
Add(_T("type"), &Type);
|
|
734
|
+
Add(_T("id"), &Id);
|
|
735
|
+
Add(_T("version"), &Version);
|
|
736
|
+
Add(_T("url"), &Url);
|
|
737
|
+
Add(_T("appName"), &AppName);
|
|
738
|
+
Add(_T("category"), &Category);
|
|
739
|
+
}
|
|
740
|
+
|
|
741
|
+
InstallParamsData(const InstallParamsData&) = delete;
|
|
742
|
+
InstallParamsData(InstallParamsData&&) noexcept = delete;
|
|
743
|
+
|
|
744
|
+
InstallParamsData& operator=(const InstallParamsData&) = delete;
|
|
745
|
+
InstallParamsData& operator=(InstallParamsData&&) noexcept = delete;
|
|
746
|
+
|
|
747
|
+
~InstallParamsData() = default;
|
|
748
|
+
|
|
749
|
+
public:
|
|
750
|
+
bool IsDataValid() const
|
|
751
|
+
{
|
|
752
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Url.IsSet() == true) && (AppName.IsSet() == true) && (Category.IsSet() == true));
|
|
753
|
+
}
|
|
754
|
+
|
|
755
|
+
public:
|
|
756
|
+
Core::JSON::String Type; // Type of the package
|
|
757
|
+
Core::JSON::String Id; // Id of the package
|
|
758
|
+
Core::JSON::String Version; // Version of the package
|
|
759
|
+
Core::JSON::String Url; // URL used to install package
|
|
760
|
+
Core::JSON::String AppName; // Application Name
|
|
761
|
+
Core::JSON::String Category; // Category of the package
|
|
762
|
+
}; // class InstallParamsData
|
|
763
|
+
|
|
764
|
+
class LockParamsData : public Core::JSON::Container {
|
|
765
|
+
public:
|
|
766
|
+
LockParamsData()
|
|
767
|
+
: Core::JSON::Container()
|
|
768
|
+
{
|
|
769
|
+
Add(_T("type"), &Type);
|
|
770
|
+
Add(_T("id"), &Id);
|
|
771
|
+
Add(_T("version"), &Version);
|
|
772
|
+
Add(_T("reason"), &Reason);
|
|
773
|
+
Add(_T("owner"), &Owner);
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
LockParamsData(const LockParamsData&) = delete;
|
|
777
|
+
LockParamsData(LockParamsData&&) noexcept = delete;
|
|
778
|
+
|
|
779
|
+
LockParamsData& operator=(const LockParamsData&) = delete;
|
|
780
|
+
LockParamsData& operator=(LockParamsData&&) noexcept = delete;
|
|
781
|
+
|
|
782
|
+
~LockParamsData() = default;
|
|
783
|
+
|
|
784
|
+
public:
|
|
785
|
+
bool IsDataValid() const
|
|
786
|
+
{
|
|
787
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Reason.IsSet() == true) && (Owner.IsSet() == true));
|
|
788
|
+
}
|
|
789
|
+
|
|
790
|
+
public:
|
|
791
|
+
Core::JSON::String Type; // Type of the package
|
|
792
|
+
Core::JSON::String Id; // Id of the package
|
|
793
|
+
Core::JSON::String Version; // Version of the package
|
|
794
|
+
Core::JSON::String Reason; // Reason to lock the application
|
|
795
|
+
Core::JSON::String Owner; // Owner used to lock
|
|
796
|
+
}; // class LockParamsData
|
|
797
|
+
|
|
798
|
+
class OperationStatusParamsData : public Core::JSON::Container {
|
|
799
|
+
public:
|
|
800
|
+
OperationStatusParamsData()
|
|
801
|
+
: Core::JSON::Container()
|
|
802
|
+
{
|
|
803
|
+
Add(_T("handle"), &Handle);
|
|
804
|
+
Add(_T("operation"), &Operation);
|
|
805
|
+
Add(_T("type"), &Type);
|
|
806
|
+
Add(_T("id"), &Id);
|
|
807
|
+
Add(_T("version"), &Version);
|
|
808
|
+
Add(_T("status"), &Status);
|
|
809
|
+
Add(_T("details"), &Details);
|
|
810
|
+
}
|
|
811
|
+
|
|
812
|
+
OperationStatusParamsData(const OperationStatusParamsData&) = delete;
|
|
813
|
+
OperationStatusParamsData(OperationStatusParamsData&&) noexcept = delete;
|
|
814
|
+
|
|
815
|
+
OperationStatusParamsData& operator=(const OperationStatusParamsData&) = delete;
|
|
816
|
+
OperationStatusParamsData& operator=(OperationStatusParamsData&&) noexcept = delete;
|
|
817
|
+
|
|
818
|
+
~OperationStatusParamsData() = default;
|
|
819
|
+
|
|
820
|
+
public:
|
|
821
|
+
bool IsDataValid() const
|
|
822
|
+
{
|
|
823
|
+
return ((Handle.IsSet() == true) && (Operation.IsSet() == true) && (Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Status.IsSet() == true) && (Details.IsSet() == true));
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
public:
|
|
827
|
+
Core::JSON::String Handle; // Handle of the currently progressing operation (i.e, install/uninstal/download)
|
|
828
|
+
Core::JSON::String Operation; // Type of the operation
|
|
829
|
+
Core::JSON::String Type; // Type of the package
|
|
830
|
+
Core::JSON::String Id; // Id of the package
|
|
831
|
+
Core::JSON::String Version; // Version of the package
|
|
832
|
+
Core::JSON::String Status; // Current status of the operation
|
|
833
|
+
Core::JSON::String Details; // Details about the operation
|
|
834
|
+
}; // class OperationStatusParamsData
|
|
835
|
+
|
|
836
|
+
class ResetParamsData : public Core::JSON::Container {
|
|
837
|
+
public:
|
|
838
|
+
ResetParamsData()
|
|
839
|
+
: Core::JSON::Container()
|
|
840
|
+
{
|
|
841
|
+
Add(_T("type"), &Type);
|
|
842
|
+
Add(_T("id"), &Id);
|
|
843
|
+
Add(_T("version"), &Version);
|
|
844
|
+
Add(_T("resetType"), &ResetType);
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
ResetParamsData(const ResetParamsData&) = delete;
|
|
848
|
+
ResetParamsData(ResetParamsData&&) noexcept = delete;
|
|
849
|
+
|
|
850
|
+
ResetParamsData& operator=(const ResetParamsData&) = delete;
|
|
851
|
+
ResetParamsData& operator=(ResetParamsData&&) noexcept = delete;
|
|
852
|
+
|
|
853
|
+
~ResetParamsData() = default;
|
|
854
|
+
|
|
855
|
+
public:
|
|
856
|
+
bool IsDataValid() const
|
|
857
|
+
{
|
|
858
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (ResetType.IsSet() == true));
|
|
859
|
+
}
|
|
860
|
+
|
|
861
|
+
public:
|
|
862
|
+
Core::JSON::String Type; // Type of the package
|
|
863
|
+
Core::JSON::String Id; // Id of the package
|
|
864
|
+
Core::JSON::String Version; // Version of the package
|
|
865
|
+
Core::JSON::String ResetType; // Type of Reset
|
|
866
|
+
}; // class ResetParamsData
|
|
867
|
+
|
|
868
|
+
class SetAuxMetadataParamsData : public Core::JSON::Container {
|
|
869
|
+
public:
|
|
870
|
+
SetAuxMetadataParamsData()
|
|
871
|
+
: Core::JSON::Container()
|
|
872
|
+
{
|
|
873
|
+
Add(_T("type"), &Type);
|
|
874
|
+
Add(_T("id"), &Id);
|
|
875
|
+
Add(_T("version"), &Version);
|
|
876
|
+
Add(_T("key"), &Key);
|
|
877
|
+
Add(_T("value"), &Value);
|
|
878
|
+
}
|
|
879
|
+
|
|
880
|
+
SetAuxMetadataParamsData(const SetAuxMetadataParamsData&) = delete;
|
|
881
|
+
SetAuxMetadataParamsData(SetAuxMetadataParamsData&&) noexcept = delete;
|
|
882
|
+
|
|
883
|
+
SetAuxMetadataParamsData& operator=(const SetAuxMetadataParamsData&) = delete;
|
|
884
|
+
SetAuxMetadataParamsData& operator=(SetAuxMetadataParamsData&&) noexcept = delete;
|
|
885
|
+
|
|
886
|
+
~SetAuxMetadataParamsData() = default;
|
|
887
|
+
|
|
888
|
+
public:
|
|
889
|
+
bool IsDataValid() const
|
|
890
|
+
{
|
|
891
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true));
|
|
892
|
+
}
|
|
893
|
+
|
|
894
|
+
public:
|
|
895
|
+
Core::JSON::String Type; // Type of the package
|
|
896
|
+
Core::JSON::String Id; // Id of the package
|
|
897
|
+
Core::JSON::String Version; // Version of the package
|
|
898
|
+
Core::JSON::String Key; // Key used to set arbitrary meta data
|
|
899
|
+
Core::JSON::String Value; // Value of given key
|
|
900
|
+
}; // class SetAuxMetadataParamsData
|
|
901
|
+
|
|
902
|
+
class UninstallParamsData : public Core::JSON::Container {
|
|
903
|
+
public:
|
|
904
|
+
UninstallParamsData()
|
|
905
|
+
: Core::JSON::Container()
|
|
906
|
+
{
|
|
907
|
+
Add(_T("type"), &Type);
|
|
908
|
+
Add(_T("id"), &Id);
|
|
909
|
+
Add(_T("version"), &Version);
|
|
910
|
+
Add(_T("uninstallType"), &UninstallType);
|
|
911
|
+
}
|
|
912
|
+
|
|
913
|
+
UninstallParamsData(const UninstallParamsData&) = delete;
|
|
914
|
+
UninstallParamsData(UninstallParamsData&&) noexcept = delete;
|
|
915
|
+
|
|
916
|
+
UninstallParamsData& operator=(const UninstallParamsData&) = delete;
|
|
917
|
+
UninstallParamsData& operator=(UninstallParamsData&&) noexcept = delete;
|
|
918
|
+
|
|
919
|
+
~UninstallParamsData() = default;
|
|
920
|
+
|
|
921
|
+
public:
|
|
922
|
+
bool IsDataValid() const
|
|
923
|
+
{
|
|
924
|
+
return ((Type.IsSet() == true) && (Id.IsSet() == true) && (Version.IsSet() == true) && (UninstallType.IsSet() == true));
|
|
925
|
+
}
|
|
926
|
+
|
|
927
|
+
public:
|
|
928
|
+
Core::JSON::String Type; // Type of the package
|
|
929
|
+
Core::JSON::String Id; // Id of the package
|
|
930
|
+
Core::JSON::String Version; // Version of the package
|
|
931
|
+
Core::JSON::String UninstallType; // Type of uninstall
|
|
932
|
+
}; // class UninstallParamsData
|
|
933
|
+
|
|
934
|
+
} // namespace PackageManager
|
|
935
|
+
|
|
936
|
+
POP_WARNING()
|
|
937
|
+
|
|
938
|
+
} // namespace JsonData
|
|
939
|
+
|
|
940
|
+
}
|
|
941
|
+
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
// C++ types for Packager API.
|
|
2
|
+
// Generated automatically from 'IPackager.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IPackager.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Packager {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class InstallParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
InstallParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("name"), &Name);
|
|
28
|
+
Add(_T("version"), &Version);
|
|
29
|
+
Add(_T("arch"), &Arch);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
InstallParamsData(const InstallParamsData&) = delete;
|
|
33
|
+
InstallParamsData(InstallParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
InstallParamsData& operator=(const InstallParamsData&) = delete;
|
|
36
|
+
InstallParamsData& operator=(InstallParamsData&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~InstallParamsData() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return ((Name.IsSet() == true) && (Version.IsSet() == true) && (Arch.IsSet() == true));
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::String Name; // Name, URL or file path of the package to install
|
|
48
|
+
Core::JSON::String Version; // Version of the package to install
|
|
49
|
+
Core::JSON::String Arch; // Architecture of the package to install
|
|
50
|
+
}; // class InstallParamsData
|
|
51
|
+
|
|
52
|
+
} // namespace Packager
|
|
53
|
+
|
|
54
|
+
POP_WARNING()
|
|
55
|
+
|
|
56
|
+
} // namespace JsonData
|
|
57
|
+
|
|
58
|
+
}
|
|
59
|
+
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
// C++ types for Performance Monitor API.
|
|
2
|
+
// Generated automatically from 'PerformanceMonitor.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace PerformanceMonitor {
|
|
17
|
+
|
|
18
|
+
// Common classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class BufferInfo : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
BufferInfo()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("data"), &Data);
|
|
27
|
+
Add(_T("length"), &Length);
|
|
28
|
+
Add(_T("duration"), &Duration);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
BufferInfo(const BufferInfo&) = delete;
|
|
32
|
+
BufferInfo(BufferInfo&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
BufferInfo& operator=(const BufferInfo&) = delete;
|
|
35
|
+
BufferInfo& operator=(BufferInfo&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~BufferInfo() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((Data.IsSet() == true) && (Length.IsSet() == true) && (Duration.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::String Data; // Any string data upto the size specified in the length
|
|
47
|
+
Core::JSON::DecUInt16 Length; // Size of the data
|
|
48
|
+
Core::JSON::DecUInt16 Duration; // Duration of the measurements
|
|
49
|
+
}; // class BufferInfo
|
|
50
|
+
|
|
51
|
+
// Method params/result classes
|
|
52
|
+
//
|
|
53
|
+
|
|
54
|
+
class MeasurementData : public Core::JSON::Container {
|
|
55
|
+
public:
|
|
56
|
+
class StatisticsData : public Core::JSON::Container {
|
|
57
|
+
public:
|
|
58
|
+
StatisticsData()
|
|
59
|
+
: Core::JSON::Container()
|
|
60
|
+
{
|
|
61
|
+
Add(_T("minimum"), &Minimum);
|
|
62
|
+
Add(_T("maximum"), &Maximum);
|
|
63
|
+
Add(_T("average"), &Average);
|
|
64
|
+
Add(_T("count"), &Count);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
StatisticsData(const StatisticsData&) = delete;
|
|
68
|
+
StatisticsData(StatisticsData&&) noexcept = delete;
|
|
69
|
+
|
|
70
|
+
StatisticsData& operator=(const StatisticsData&) = delete;
|
|
71
|
+
StatisticsData& operator=(StatisticsData&&) noexcept = delete;
|
|
72
|
+
|
|
73
|
+
~StatisticsData() = default;
|
|
74
|
+
|
|
75
|
+
public:
|
|
76
|
+
bool IsDataValid() const
|
|
77
|
+
{
|
|
78
|
+
return ((Minimum.IsSet() == true) && (Maximum.IsSet() == true) && (Average.IsSet() == true) && (Count.IsSet() == true));
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
public:
|
|
82
|
+
Core::JSON::DecUInt32 Minimum; // Minimum value of measurements
|
|
83
|
+
Core::JSON::DecUInt32 Maximum; // Maximum value of measurements
|
|
84
|
+
Core::JSON::DecUInt32 Average; // Average value of measurements
|
|
85
|
+
Core::JSON::DecUInt32 Count; // How many times measurement has been collected
|
|
86
|
+
}; // class StatisticsData
|
|
87
|
+
|
|
88
|
+
MeasurementData()
|
|
89
|
+
: Core::JSON::Container()
|
|
90
|
+
{
|
|
91
|
+
Add(_T("serialization"), &Serialization);
|
|
92
|
+
Add(_T("deserialization"), &Deserialization);
|
|
93
|
+
Add(_T("execution"), &Execution);
|
|
94
|
+
Add(_T("threadpool"), &Threadpool);
|
|
95
|
+
Add(_T("communication"), &Communication);
|
|
96
|
+
Add(_T("total"), &Total);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
MeasurementData(const MeasurementData&) = delete;
|
|
100
|
+
MeasurementData(MeasurementData&&) noexcept = delete;
|
|
101
|
+
|
|
102
|
+
MeasurementData& operator=(const MeasurementData&) = delete;
|
|
103
|
+
MeasurementData& operator=(MeasurementData&&) noexcept = delete;
|
|
104
|
+
|
|
105
|
+
~MeasurementData() = default;
|
|
106
|
+
|
|
107
|
+
public:
|
|
108
|
+
bool IsDataValid() const
|
|
109
|
+
{
|
|
110
|
+
return (((Serialization.IsSet() == true) && (Serialization.IsDataValid() == true)) && ((Deserialization.IsSet() == true) && (Deserialization.IsDataValid() == true)) && ((Execution.IsSet() == true) && (Execution.IsDataValid() == true)) && ((Threadpool.IsSet() == true) && (Threadpool.IsDataValid() == true)) && ((Communication.IsSet() == true) && (Communication.IsDataValid() == true)) && ((Total.IsSet() == true) && (Total.IsDataValid() == true)));
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
public:
|
|
114
|
+
MeasurementData::StatisticsData Serialization; // Time taken to complete serialization
|
|
115
|
+
StatisticsData Deserialization; // Time taken to complete deserialization
|
|
116
|
+
StatisticsData Execution; // Time taken to complete execution
|
|
117
|
+
StatisticsData Threadpool; // Time taken to complete threadpool wait
|
|
118
|
+
StatisticsData Communication; // Time taken to complete communication
|
|
119
|
+
StatisticsData Total; // Time taken to complete whole jsonrpc process
|
|
120
|
+
}; // class MeasurementData
|
|
121
|
+
|
|
122
|
+
} // namespace PerformanceMonitor
|
|
123
|
+
|
|
124
|
+
POP_WARNING()
|
|
125
|
+
|
|
126
|
+
} // namespace JsonData
|
|
127
|
+
|
|
128
|
+
}
|
|
129
|
+
|
|
@@ -0,0 +1,446 @@
|
|
|
1
|
+
// C++ types for PertsistentStore API.
|
|
2
|
+
// Generated automatically from 'PersistentStore.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace PersistentStore {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Scope
|
|
23
|
+
enum class ScopeType : uint8_t {
|
|
24
|
+
DEVICE,
|
|
25
|
+
ACCOUNT
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// Common classes
|
|
29
|
+
//
|
|
30
|
+
|
|
31
|
+
class DeleteKeyParamsInfo : public Core::JSON::Container {
|
|
32
|
+
public:
|
|
33
|
+
DeleteKeyParamsInfo()
|
|
34
|
+
: Core::JSON::Container()
|
|
35
|
+
{
|
|
36
|
+
Add(_T("namespace"), &Namespace);
|
|
37
|
+
Add(_T("key"), &Key);
|
|
38
|
+
Add(_T("scope"), &Scope);
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
DeleteKeyParamsInfo(const DeleteKeyParamsInfo&) = delete;
|
|
42
|
+
DeleteKeyParamsInfo(DeleteKeyParamsInfo&&) noexcept = delete;
|
|
43
|
+
|
|
44
|
+
DeleteKeyParamsInfo& operator=(const DeleteKeyParamsInfo&) = delete;
|
|
45
|
+
DeleteKeyParamsInfo& operator=(DeleteKeyParamsInfo&&) noexcept = delete;
|
|
46
|
+
|
|
47
|
+
~DeleteKeyParamsInfo() = default;
|
|
48
|
+
|
|
49
|
+
public:
|
|
50
|
+
bool IsDataValid() const
|
|
51
|
+
{
|
|
52
|
+
return ((Namespace.IsSet() == true) && (Key.IsSet() == true));
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
public:
|
|
56
|
+
Core::JSON::String Namespace; // Namespace
|
|
57
|
+
Core::JSON::String Key; // Key
|
|
58
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
59
|
+
}; // class DeleteKeyParamsInfo
|
|
60
|
+
|
|
61
|
+
class DeleteKeyResultInfo : public Core::JSON::Container {
|
|
62
|
+
public:
|
|
63
|
+
DeleteKeyResultInfo()
|
|
64
|
+
: Core::JSON::Container()
|
|
65
|
+
{
|
|
66
|
+
Add(_T("success"), &Success);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
DeleteKeyResultInfo(const DeleteKeyResultInfo&) = delete;
|
|
70
|
+
DeleteKeyResultInfo(DeleteKeyResultInfo&&) noexcept = delete;
|
|
71
|
+
|
|
72
|
+
DeleteKeyResultInfo& operator=(const DeleteKeyResultInfo&) = delete;
|
|
73
|
+
DeleteKeyResultInfo& operator=(DeleteKeyResultInfo&&) noexcept = delete;
|
|
74
|
+
|
|
75
|
+
~DeleteKeyResultInfo() = default;
|
|
76
|
+
|
|
77
|
+
public:
|
|
78
|
+
bool IsDataValid() const
|
|
79
|
+
{
|
|
80
|
+
return (Success.IsSet() == true);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
public:
|
|
84
|
+
Core::JSON::Boolean Success; // Legacy parameter (always true)
|
|
85
|
+
}; // class DeleteKeyResultInfo
|
|
86
|
+
|
|
87
|
+
class DeleteNamespaceParamsInfo : public Core::JSON::Container {
|
|
88
|
+
public:
|
|
89
|
+
DeleteNamespaceParamsInfo()
|
|
90
|
+
: Core::JSON::Container()
|
|
91
|
+
{
|
|
92
|
+
Add(_T("namespace"), &Namespace);
|
|
93
|
+
Add(_T("scope"), &Scope);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
DeleteNamespaceParamsInfo(const DeleteNamespaceParamsInfo&) = delete;
|
|
97
|
+
DeleteNamespaceParamsInfo(DeleteNamespaceParamsInfo&&) noexcept = delete;
|
|
98
|
+
|
|
99
|
+
DeleteNamespaceParamsInfo& operator=(const DeleteNamespaceParamsInfo&) = delete;
|
|
100
|
+
DeleteNamespaceParamsInfo& operator=(DeleteNamespaceParamsInfo&&) noexcept = delete;
|
|
101
|
+
|
|
102
|
+
~DeleteNamespaceParamsInfo() = default;
|
|
103
|
+
|
|
104
|
+
public:
|
|
105
|
+
bool IsDataValid() const
|
|
106
|
+
{
|
|
107
|
+
return (Namespace.IsSet() == true);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
public:
|
|
111
|
+
Core::JSON::String Namespace; // Namespace
|
|
112
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
113
|
+
}; // class DeleteNamespaceParamsInfo
|
|
114
|
+
|
|
115
|
+
class GetNamespacesParamsInfo : public Core::JSON::Container {
|
|
116
|
+
public:
|
|
117
|
+
GetNamespacesParamsInfo()
|
|
118
|
+
: Core::JSON::Container()
|
|
119
|
+
{
|
|
120
|
+
Add(_T("scope"), &Scope);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
GetNamespacesParamsInfo(const GetNamespacesParamsInfo&) = delete;
|
|
124
|
+
GetNamespacesParamsInfo(GetNamespacesParamsInfo&&) noexcept = delete;
|
|
125
|
+
|
|
126
|
+
GetNamespacesParamsInfo& operator=(const GetNamespacesParamsInfo&) = delete;
|
|
127
|
+
GetNamespacesParamsInfo& operator=(GetNamespacesParamsInfo&&) noexcept = delete;
|
|
128
|
+
|
|
129
|
+
~GetNamespacesParamsInfo() = default;
|
|
130
|
+
|
|
131
|
+
public:
|
|
132
|
+
bool IsDataValid() const
|
|
133
|
+
{
|
|
134
|
+
return (true);
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
public:
|
|
138
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
139
|
+
}; // class GetNamespacesParamsInfo
|
|
140
|
+
|
|
141
|
+
// Method params/result classes
|
|
142
|
+
//
|
|
143
|
+
|
|
144
|
+
class GetKeysResultData : public Core::JSON::Container {
|
|
145
|
+
public:
|
|
146
|
+
GetKeysResultData()
|
|
147
|
+
: Core::JSON::Container()
|
|
148
|
+
{
|
|
149
|
+
Add(_T("keys"), &Keys);
|
|
150
|
+
Add(_T("success"), &Success);
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
GetKeysResultData(const GetKeysResultData&) = delete;
|
|
154
|
+
GetKeysResultData(GetKeysResultData&&) noexcept = delete;
|
|
155
|
+
|
|
156
|
+
GetKeysResultData& operator=(const GetKeysResultData&) = delete;
|
|
157
|
+
GetKeysResultData& operator=(GetKeysResultData&&) noexcept = delete;
|
|
158
|
+
|
|
159
|
+
~GetKeysResultData() = default;
|
|
160
|
+
|
|
161
|
+
public:
|
|
162
|
+
bool IsDataValid() const
|
|
163
|
+
{
|
|
164
|
+
return ((Keys.IsSet() == true) && (Success.IsSet() == true));
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
public:
|
|
168
|
+
Core::JSON::ArrayType<Core::JSON::String> Keys; // Returns the keys that are stored in the specified namespace
|
|
169
|
+
Core::JSON::Boolean Success; // Legacy parameter (always true)
|
|
170
|
+
}; // class GetKeysResultData
|
|
171
|
+
|
|
172
|
+
class GetNamespaceStorageLimitResultData : public Core::JSON::Container {
|
|
173
|
+
public:
|
|
174
|
+
GetNamespaceStorageLimitResultData()
|
|
175
|
+
: Core::JSON::Container()
|
|
176
|
+
{
|
|
177
|
+
Add(_T("storageLimit"), &StorageLimit);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
GetNamespaceStorageLimitResultData(const GetNamespaceStorageLimitResultData&) = delete;
|
|
181
|
+
GetNamespaceStorageLimitResultData(GetNamespaceStorageLimitResultData&&) noexcept = delete;
|
|
182
|
+
|
|
183
|
+
GetNamespaceStorageLimitResultData& operator=(const GetNamespaceStorageLimitResultData&) = delete;
|
|
184
|
+
GetNamespaceStorageLimitResultData& operator=(GetNamespaceStorageLimitResultData&&) noexcept = delete;
|
|
185
|
+
|
|
186
|
+
~GetNamespaceStorageLimitResultData() = default;
|
|
187
|
+
|
|
188
|
+
public:
|
|
189
|
+
bool IsDataValid() const
|
|
190
|
+
{
|
|
191
|
+
return (StorageLimit.IsSet() == true);
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
public:
|
|
195
|
+
Core::JSON::DecUInt32 StorageLimit; // Size in bytes
|
|
196
|
+
}; // class GetNamespaceStorageLimitResultData
|
|
197
|
+
|
|
198
|
+
class GetNamespacesResultData : public Core::JSON::Container {
|
|
199
|
+
public:
|
|
200
|
+
GetNamespacesResultData()
|
|
201
|
+
: Core::JSON::Container()
|
|
202
|
+
{
|
|
203
|
+
Add(_T("namespaces"), &Namespaces);
|
|
204
|
+
Add(_T("success"), &Success);
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
GetNamespacesResultData(const GetNamespacesResultData&) = delete;
|
|
208
|
+
GetNamespacesResultData(GetNamespacesResultData&&) noexcept = delete;
|
|
209
|
+
|
|
210
|
+
GetNamespacesResultData& operator=(const GetNamespacesResultData&) = delete;
|
|
211
|
+
GetNamespacesResultData& operator=(GetNamespacesResultData&&) noexcept = delete;
|
|
212
|
+
|
|
213
|
+
~GetNamespacesResultData() = default;
|
|
214
|
+
|
|
215
|
+
public:
|
|
216
|
+
bool IsDataValid() const
|
|
217
|
+
{
|
|
218
|
+
return ((Namespaces.IsSet() == true) && (Success.IsSet() == true));
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
public:
|
|
222
|
+
Core::JSON::ArrayType<Core::JSON::String> Namespaces; // Returns the namespaces
|
|
223
|
+
Core::JSON::Boolean Success; // Legacy parameter (always true)
|
|
224
|
+
}; // class GetNamespacesResultData
|
|
225
|
+
|
|
226
|
+
class GetStorageSizesResultData : public Core::JSON::Container {
|
|
227
|
+
public:
|
|
228
|
+
class StorageListDataElem : public Core::JSON::Container {
|
|
229
|
+
public:
|
|
230
|
+
StorageListDataElem()
|
|
231
|
+
: Core::JSON::Container()
|
|
232
|
+
{
|
|
233
|
+
_Init();
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
StorageListDataElem(const StorageListDataElem& _other)
|
|
237
|
+
: Core::JSON::Container()
|
|
238
|
+
, Namespace(_other.Namespace)
|
|
239
|
+
, Size(_other.Size)
|
|
240
|
+
{
|
|
241
|
+
_Init();
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
StorageListDataElem(StorageListDataElem&& _other) noexcept
|
|
245
|
+
: Core::JSON::Container()
|
|
246
|
+
, Namespace(std::move(_other.Namespace))
|
|
247
|
+
, Size(std::move(_other.Size))
|
|
248
|
+
{
|
|
249
|
+
_Init();
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
StorageListDataElem& operator=(const StorageListDataElem& _rhs)
|
|
253
|
+
{
|
|
254
|
+
Namespace = _rhs.Namespace;
|
|
255
|
+
Size = _rhs.Size;
|
|
256
|
+
return (*this);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
StorageListDataElem& operator=(StorageListDataElem&& _rhs) noexcept
|
|
260
|
+
{
|
|
261
|
+
Namespace = std::move(_rhs.Namespace);
|
|
262
|
+
Size = std::move(_rhs.Size);
|
|
263
|
+
return (*this);
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
~StorageListDataElem() = default;
|
|
267
|
+
|
|
268
|
+
public:
|
|
269
|
+
bool IsDataValid() const
|
|
270
|
+
{
|
|
271
|
+
return ((Namespace.IsSet() == true) && (Size.IsSet() == true));
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
private:
|
|
275
|
+
void _Init()
|
|
276
|
+
{
|
|
277
|
+
Add(_T("namespace"), &Namespace);
|
|
278
|
+
Add(_T("size"), &Size);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
public:
|
|
282
|
+
Core::JSON::String Namespace; // Namespace
|
|
283
|
+
Core::JSON::DecUInt32 Size; // Size in bytes
|
|
284
|
+
}; // class StorageListDataElem
|
|
285
|
+
|
|
286
|
+
GetStorageSizesResultData()
|
|
287
|
+
: Core::JSON::Container()
|
|
288
|
+
{
|
|
289
|
+
Add(_T("storageList"), &StorageList);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
GetStorageSizesResultData(const GetStorageSizesResultData&) = delete;
|
|
293
|
+
GetStorageSizesResultData(GetStorageSizesResultData&&) noexcept = delete;
|
|
294
|
+
|
|
295
|
+
GetStorageSizesResultData& operator=(const GetStorageSizesResultData&) = delete;
|
|
296
|
+
GetStorageSizesResultData& operator=(GetStorageSizesResultData&&) noexcept = delete;
|
|
297
|
+
|
|
298
|
+
~GetStorageSizesResultData() = default;
|
|
299
|
+
|
|
300
|
+
public:
|
|
301
|
+
bool IsDataValid() const
|
|
302
|
+
{
|
|
303
|
+
return (StorageList.IsSet() == true);
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
public:
|
|
307
|
+
Core::JSON::ArrayType<GetStorageSizesResultData::StorageListDataElem> StorageList; // Returns the size occupied by each namespace
|
|
308
|
+
}; // class GetStorageSizesResultData
|
|
309
|
+
|
|
310
|
+
class GetValueResultData : public Core::JSON::Container {
|
|
311
|
+
public:
|
|
312
|
+
GetValueResultData()
|
|
313
|
+
: Core::JSON::Container()
|
|
314
|
+
{
|
|
315
|
+
Add(_T("value"), &Value);
|
|
316
|
+
Add(_T("success"), &Success);
|
|
317
|
+
Add(_T("ttl"), &Ttl);
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
GetValueResultData(const GetValueResultData&) = delete;
|
|
321
|
+
GetValueResultData(GetValueResultData&&) noexcept = delete;
|
|
322
|
+
|
|
323
|
+
GetValueResultData& operator=(const GetValueResultData&) = delete;
|
|
324
|
+
GetValueResultData& operator=(GetValueResultData&&) noexcept = delete;
|
|
325
|
+
|
|
326
|
+
~GetValueResultData() = default;
|
|
327
|
+
|
|
328
|
+
public:
|
|
329
|
+
bool IsDataValid() const
|
|
330
|
+
{
|
|
331
|
+
return ((Value.IsSet() == true) && (Success.IsSet() == true));
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
public:
|
|
335
|
+
Core::JSON::String Value; // Value
|
|
336
|
+
Core::JSON::Boolean Success; // Legacy parameter (always true)
|
|
337
|
+
Core::JSON::DecUInt32 Ttl; // Time in seconds
|
|
338
|
+
}; // class GetValueResultData
|
|
339
|
+
|
|
340
|
+
class OnValueChangedParamsData : public Core::JSON::Container {
|
|
341
|
+
public:
|
|
342
|
+
OnValueChangedParamsData()
|
|
343
|
+
: Core::JSON::Container()
|
|
344
|
+
{
|
|
345
|
+
Add(_T("namespace"), &Namespace);
|
|
346
|
+
Add(_T("key"), &Key);
|
|
347
|
+
Add(_T("value"), &Value);
|
|
348
|
+
Add(_T("scope"), &Scope);
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
OnValueChangedParamsData(const OnValueChangedParamsData&) = delete;
|
|
352
|
+
OnValueChangedParamsData(OnValueChangedParamsData&&) noexcept = delete;
|
|
353
|
+
|
|
354
|
+
OnValueChangedParamsData& operator=(const OnValueChangedParamsData&) = delete;
|
|
355
|
+
OnValueChangedParamsData& operator=(OnValueChangedParamsData&&) noexcept = delete;
|
|
356
|
+
|
|
357
|
+
~OnValueChangedParamsData() = default;
|
|
358
|
+
|
|
359
|
+
public:
|
|
360
|
+
bool IsDataValid() const
|
|
361
|
+
{
|
|
362
|
+
return ((Namespace.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true) && (Scope.IsSet() == true));
|
|
363
|
+
}
|
|
364
|
+
|
|
365
|
+
public:
|
|
366
|
+
Core::JSON::String Namespace; // Namespace
|
|
367
|
+
Core::JSON::String Key; // Key
|
|
368
|
+
Core::JSON::String Value; // Value
|
|
369
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
370
|
+
}; // class OnValueChangedParamsData
|
|
371
|
+
|
|
372
|
+
class SetNamespaceStorageLimitParamsData : public Core::JSON::Container {
|
|
373
|
+
public:
|
|
374
|
+
SetNamespaceStorageLimitParamsData()
|
|
375
|
+
: Core::JSON::Container()
|
|
376
|
+
{
|
|
377
|
+
Add(_T("namespace"), &Namespace);
|
|
378
|
+
Add(_T("storageLimit"), &StorageLimit);
|
|
379
|
+
Add(_T("scope"), &Scope);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
SetNamespaceStorageLimitParamsData(const SetNamespaceStorageLimitParamsData&) = delete;
|
|
383
|
+
SetNamespaceStorageLimitParamsData(SetNamespaceStorageLimitParamsData&&) noexcept = delete;
|
|
384
|
+
|
|
385
|
+
SetNamespaceStorageLimitParamsData& operator=(const SetNamespaceStorageLimitParamsData&) = delete;
|
|
386
|
+
SetNamespaceStorageLimitParamsData& operator=(SetNamespaceStorageLimitParamsData&&) noexcept = delete;
|
|
387
|
+
|
|
388
|
+
~SetNamespaceStorageLimitParamsData() = default;
|
|
389
|
+
|
|
390
|
+
public:
|
|
391
|
+
bool IsDataValid() const
|
|
392
|
+
{
|
|
393
|
+
return ((Namespace.IsSet() == true) && (StorageLimit.IsSet() == true));
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
public:
|
|
397
|
+
Core::JSON::String Namespace; // Namespace
|
|
398
|
+
Core::JSON::DecUInt32 StorageLimit; // Size in bytes
|
|
399
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
400
|
+
}; // class SetNamespaceStorageLimitParamsData
|
|
401
|
+
|
|
402
|
+
class SetValueParamsData : public Core::JSON::Container {
|
|
403
|
+
public:
|
|
404
|
+
SetValueParamsData()
|
|
405
|
+
: Core::JSON::Container()
|
|
406
|
+
{
|
|
407
|
+
Add(_T("namespace"), &Namespace);
|
|
408
|
+
Add(_T("key"), &Key);
|
|
409
|
+
Add(_T("value"), &Value);
|
|
410
|
+
Add(_T("scope"), &Scope);
|
|
411
|
+
Add(_T("ttl"), &Ttl);
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
SetValueParamsData(const SetValueParamsData&) = delete;
|
|
415
|
+
SetValueParamsData(SetValueParamsData&&) noexcept = delete;
|
|
416
|
+
|
|
417
|
+
SetValueParamsData& operator=(const SetValueParamsData&) = delete;
|
|
418
|
+
SetValueParamsData& operator=(SetValueParamsData&&) noexcept = delete;
|
|
419
|
+
|
|
420
|
+
~SetValueParamsData() = default;
|
|
421
|
+
|
|
422
|
+
public:
|
|
423
|
+
bool IsDataValid() const
|
|
424
|
+
{
|
|
425
|
+
return ((Namespace.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true));
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
public:
|
|
429
|
+
Core::JSON::String Namespace; // Namespace
|
|
430
|
+
Core::JSON::String Key; // Key
|
|
431
|
+
Core::JSON::String Value; // Value
|
|
432
|
+
Core::JSON::EnumType<ScopeType> Scope; // Scope
|
|
433
|
+
Core::JSON::DecUInt32 Ttl; // Time in seconds
|
|
434
|
+
}; // class SetValueParamsData
|
|
435
|
+
|
|
436
|
+
} // namespace PersistentStore
|
|
437
|
+
|
|
438
|
+
POP_WARNING()
|
|
439
|
+
|
|
440
|
+
} // namespace JsonData
|
|
441
|
+
|
|
442
|
+
// Enum conversion handlers
|
|
443
|
+
ENUM_CONVERSION_HANDLER(JsonData::PersistentStore::ScopeType)
|
|
444
|
+
|
|
445
|
+
}
|
|
446
|
+
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
// C++ types for PlayerProperties API.
|
|
2
|
+
// Generated automatically from 'IPlayerInfo.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IPlayerInfo.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace PlayerProperties {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace PlayerProperties
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(Exchange::IPlayerProperties::AudioCodec)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(Exchange::IPlayerProperties::VideoCodec)
|
|
31
|
+
ENUM_CONVERSION_HANDLER(Exchange::IPlayerProperties::PlaybackResolution)
|
|
32
|
+
|
|
33
|
+
}
|
|
34
|
+
|
|
@@ -0,0 +1,91 @@
|
|
|
1
|
+
// C++ types for Power API.
|
|
2
|
+
// Generated automatically from 'IPower.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IPower.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Power {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class SetStateParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
SetStateParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("state"), &State);
|
|
28
|
+
Add(_T("waittime"), &WaitTime);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
SetStateParamsData(const SetStateParamsData&) = delete;
|
|
32
|
+
SetStateParamsData(SetStateParamsData&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
SetStateParamsData& operator=(const SetStateParamsData&) = delete;
|
|
35
|
+
SetStateParamsData& operator=(SetStateParamsData&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~SetStateParamsData() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((State.IsSet() == true) && (WaitTime.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::EnumType<Exchange::IPower::PCState> State; // The power state to set
|
|
47
|
+
Core::JSON::DecUInt32 WaitTime; // The time to wait for the power state to be set in seconds
|
|
48
|
+
}; // class SetStateParamsData
|
|
49
|
+
|
|
50
|
+
class StateChangeParamsData : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
StateChangeParamsData()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("origin"), &Origin);
|
|
56
|
+
Add(_T("destination"), &Destination);
|
|
57
|
+
Add(_T("phase"), &Phase);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
StateChangeParamsData(const StateChangeParamsData&) = delete;
|
|
61
|
+
StateChangeParamsData(StateChangeParamsData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
StateChangeParamsData& operator=(const StateChangeParamsData&) = delete;
|
|
64
|
+
StateChangeParamsData& operator=(StateChangeParamsData&&) noexcept = delete;
|
|
65
|
+
|
|
66
|
+
~StateChangeParamsData() = default;
|
|
67
|
+
|
|
68
|
+
public:
|
|
69
|
+
bool IsDataValid() const
|
|
70
|
+
{
|
|
71
|
+
return ((Origin.IsSet() == true) && (Destination.IsSet() == true) && (Phase.IsSet() == true));
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
public:
|
|
75
|
+
Core::JSON::EnumType<Exchange::IPower::PCState> Origin; // The state the device is transitioning from
|
|
76
|
+
Core::JSON::EnumType<Exchange::IPower::PCState> Destination; // The state the device is transitioning to
|
|
77
|
+
Core::JSON::EnumType<Exchange::IPower::PCPhase> Phase; // The phase of the transition
|
|
78
|
+
}; // class StateChangeParamsData
|
|
79
|
+
|
|
80
|
+
} // namespace Power
|
|
81
|
+
|
|
82
|
+
POP_WARNING()
|
|
83
|
+
|
|
84
|
+
} // namespace JsonData
|
|
85
|
+
|
|
86
|
+
// Enum conversion handlers
|
|
87
|
+
ENUM_CONVERSION_HANDLER(Exchange::IPower::PCState)
|
|
88
|
+
ENUM_CONVERSION_HANDLER(Exchange::IPower::PCPhase)
|
|
89
|
+
|
|
90
|
+
}
|
|
91
|
+
|
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
// C++ types for Provisioning API.
|
|
2
|
+
// Generated automatically from 'Provisioning.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace Provisioning {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class IndexParamsData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
IndexParamsData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("label"), &Label);
|
|
27
|
+
Add(_T("index"), &Index);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
IndexParamsData(const IndexParamsData&) = delete;
|
|
31
|
+
IndexParamsData(IndexParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
IndexParamsData& operator=(const IndexParamsData&) = delete;
|
|
34
|
+
IndexParamsData& operator=(IndexParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~IndexParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return ((Label.IsSet() == true) && (Index.IsSet() == true));
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Label; // The label name for which the index should be changed
|
|
46
|
+
Core::JSON::DecUInt32 Index; // Index to be used for the key
|
|
47
|
+
}; // class IndexParamsData
|
|
48
|
+
|
|
49
|
+
class ProvisioningchangeParamsData : public Core::JSON::Container {
|
|
50
|
+
public:
|
|
51
|
+
ProvisioningchangeParamsData()
|
|
52
|
+
: Core::JSON::Container()
|
|
53
|
+
{
|
|
54
|
+
Add(_T("status"), &Status);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
ProvisioningchangeParamsData(const ProvisioningchangeParamsData&) = delete;
|
|
58
|
+
ProvisioningchangeParamsData(ProvisioningchangeParamsData&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
ProvisioningchangeParamsData& operator=(const ProvisioningchangeParamsData&) = delete;
|
|
61
|
+
ProvisioningchangeParamsData& operator=(ProvisioningchangeParamsData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~ProvisioningchangeParamsData() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return (Status.IsSet() == true);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::DecUInt32 Status; // Provision status
|
|
73
|
+
}; // class ProvisioningchangeParamsData
|
|
74
|
+
|
|
75
|
+
class StateData : public Core::JSON::Container {
|
|
76
|
+
public:
|
|
77
|
+
StateData()
|
|
78
|
+
: Core::JSON::Container()
|
|
79
|
+
{
|
|
80
|
+
Add(_T("id"), &Id);
|
|
81
|
+
Add(_T("status"), &Status);
|
|
82
|
+
Add(_T("tokens"), &Tokens);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
StateData(const StateData&) = delete;
|
|
86
|
+
StateData(StateData&&) noexcept = delete;
|
|
87
|
+
|
|
88
|
+
StateData& operator=(const StateData&) = delete;
|
|
89
|
+
StateData& operator=(StateData&&) noexcept = delete;
|
|
90
|
+
|
|
91
|
+
~StateData() = default;
|
|
92
|
+
|
|
93
|
+
public:
|
|
94
|
+
bool IsDataValid() const
|
|
95
|
+
{
|
|
96
|
+
return ((Id.IsSet() == true) && (Status.IsSet() == true) && (Tokens.IsSet() == true));
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
Core::JSON::String Id; // Provision ID value
|
|
101
|
+
Core::JSON::DecUInt32 Status; // Provision status
|
|
102
|
+
Core::JSON::ArrayType<Core::JSON::String> Tokens; // List of provisioned systems
|
|
103
|
+
}; // class StateData
|
|
104
|
+
|
|
105
|
+
} // namespace Provisioning
|
|
106
|
+
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
|
|
109
|
+
} // namespace JsonData
|
|
110
|
+
|
|
111
|
+
}
|
|
112
|
+
|
|
@@ -0,0 +1,244 @@
|
|
|
1
|
+
// C++ types for Remote Control API.
|
|
2
|
+
// Generated automatically from 'RemoteControl.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace RemoteControl {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Key modifier
|
|
23
|
+
enum ModifiersType : uint8_t {
|
|
24
|
+
LEFTSHIFT = 1,
|
|
25
|
+
RIGHTSHIFT = 2,
|
|
26
|
+
LEFTALT = 4,
|
|
27
|
+
RIGHTALT = 8,
|
|
28
|
+
LEFTCTRL = 16,
|
|
29
|
+
RIGHTCTRL = 32
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
// Common classes
|
|
33
|
+
//
|
|
34
|
+
|
|
35
|
+
class KeyobjInfo : public Core::JSON::Container {
|
|
36
|
+
public:
|
|
37
|
+
KeyobjInfo()
|
|
38
|
+
: Core::JSON::Container()
|
|
39
|
+
{
|
|
40
|
+
Add(_T("device"), &Device);
|
|
41
|
+
Add(_T("code"), &Code);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
KeyobjInfo(const KeyobjInfo&) = delete;
|
|
45
|
+
KeyobjInfo(KeyobjInfo&&) noexcept = delete;
|
|
46
|
+
|
|
47
|
+
KeyobjInfo& operator=(const KeyobjInfo&) = delete;
|
|
48
|
+
KeyobjInfo& operator=(KeyobjInfo&&) noexcept = delete;
|
|
49
|
+
|
|
50
|
+
~KeyobjInfo() = default;
|
|
51
|
+
|
|
52
|
+
public:
|
|
53
|
+
bool IsDataValid() const
|
|
54
|
+
{
|
|
55
|
+
return ((Device.IsSet() == true) && (Code.IsSet() == true));
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
public:
|
|
59
|
+
Core::JSON::String Device; // Device name
|
|
60
|
+
Core::JSON::DecUInt32 Code; // Key code
|
|
61
|
+
}; // class KeyobjInfo
|
|
62
|
+
|
|
63
|
+
class LoadParamsInfo : public Core::JSON::Container {
|
|
64
|
+
public:
|
|
65
|
+
LoadParamsInfo()
|
|
66
|
+
: Core::JSON::Container()
|
|
67
|
+
{
|
|
68
|
+
Add(_T("device"), &Device);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
LoadParamsInfo(const LoadParamsInfo&) = delete;
|
|
72
|
+
LoadParamsInfo(LoadParamsInfo&&) noexcept = delete;
|
|
73
|
+
|
|
74
|
+
LoadParamsInfo& operator=(const LoadParamsInfo&) = delete;
|
|
75
|
+
LoadParamsInfo& operator=(LoadParamsInfo&&) noexcept = delete;
|
|
76
|
+
|
|
77
|
+
~LoadParamsInfo() = default;
|
|
78
|
+
|
|
79
|
+
public:
|
|
80
|
+
bool IsDataValid() const
|
|
81
|
+
{
|
|
82
|
+
return (Device.IsSet() == true);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
public:
|
|
86
|
+
Core::JSON::String Device; // Device name
|
|
87
|
+
}; // class LoadParamsInfo
|
|
88
|
+
|
|
89
|
+
class RcobjInfo : public Core::JSON::Container {
|
|
90
|
+
public:
|
|
91
|
+
RcobjInfo()
|
|
92
|
+
: Core::JSON::Container()
|
|
93
|
+
{
|
|
94
|
+
Add(_T("device"), &Device);
|
|
95
|
+
Add(_T("code"), &Code);
|
|
96
|
+
Add(_T("key"), &Key);
|
|
97
|
+
Add(_T("modifiers"), &Modifiers);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
RcobjInfo(const RcobjInfo&) = delete;
|
|
101
|
+
RcobjInfo(RcobjInfo&&) noexcept = delete;
|
|
102
|
+
|
|
103
|
+
RcobjInfo& operator=(const RcobjInfo&) = delete;
|
|
104
|
+
RcobjInfo& operator=(RcobjInfo&&) noexcept = delete;
|
|
105
|
+
|
|
106
|
+
~RcobjInfo() = default;
|
|
107
|
+
|
|
108
|
+
public:
|
|
109
|
+
bool IsDataValid() const
|
|
110
|
+
{
|
|
111
|
+
return ((Device.IsSet() == true) && (Code.IsSet() == true) && (Key.IsSet() == true));
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
public:
|
|
115
|
+
Core::JSON::String Device; // Device name
|
|
116
|
+
Core::JSON::DecUInt32 Code; // Key code
|
|
117
|
+
Core::JSON::DecUInt16 Key; // Key ingest value
|
|
118
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<ModifiersType>> Modifiers; // List of key modifiers
|
|
119
|
+
}; // class RcobjInfo
|
|
120
|
+
|
|
121
|
+
// Method params/result classes
|
|
122
|
+
//
|
|
123
|
+
|
|
124
|
+
class DeviceData : public Core::JSON::Container {
|
|
125
|
+
public:
|
|
126
|
+
DeviceData()
|
|
127
|
+
: Core::JSON::Container()
|
|
128
|
+
{
|
|
129
|
+
Add(_T("metadata"), &Metadata);
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
DeviceData(const DeviceData&) = delete;
|
|
133
|
+
DeviceData(DeviceData&&) noexcept = delete;
|
|
134
|
+
|
|
135
|
+
DeviceData& operator=(const DeviceData&) = delete;
|
|
136
|
+
DeviceData& operator=(DeviceData&&) noexcept = delete;
|
|
137
|
+
|
|
138
|
+
~DeviceData() = default;
|
|
139
|
+
|
|
140
|
+
public:
|
|
141
|
+
bool IsDataValid() const
|
|
142
|
+
{
|
|
143
|
+
return (Metadata.IsSet() == true);
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
public:
|
|
147
|
+
Core::JSON::String Metadata; // Device metadata
|
|
148
|
+
}; // class DeviceData
|
|
149
|
+
|
|
150
|
+
class KeyResultData : public Core::JSON::Container {
|
|
151
|
+
public:
|
|
152
|
+
KeyResultData()
|
|
153
|
+
: Core::JSON::Container()
|
|
154
|
+
{
|
|
155
|
+
Add(_T("code"), &Code);
|
|
156
|
+
Add(_T("key"), &Key);
|
|
157
|
+
Add(_T("modifiers"), &Modifiers);
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
KeyResultData(const KeyResultData&) = delete;
|
|
161
|
+
KeyResultData(KeyResultData&&) noexcept = delete;
|
|
162
|
+
|
|
163
|
+
KeyResultData& operator=(const KeyResultData&) = delete;
|
|
164
|
+
KeyResultData& operator=(KeyResultData&&) noexcept = delete;
|
|
165
|
+
|
|
166
|
+
~KeyResultData() = default;
|
|
167
|
+
|
|
168
|
+
public:
|
|
169
|
+
bool IsDataValid() const
|
|
170
|
+
{
|
|
171
|
+
return ((Code.IsSet() == true) && (Key.IsSet() == true));
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
public:
|
|
175
|
+
Core::JSON::DecUInt32 Code; // Key code
|
|
176
|
+
Core::JSON::DecUInt16 Key; // Key ingest value
|
|
177
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<ModifiersType>> Modifiers; // List of key modifiers
|
|
178
|
+
}; // class KeyResultData
|
|
179
|
+
|
|
180
|
+
class KeypressedParamsData : public Core::JSON::Container {
|
|
181
|
+
public:
|
|
182
|
+
KeypressedParamsData()
|
|
183
|
+
: Core::JSON::Container()
|
|
184
|
+
{
|
|
185
|
+
Add(_T("pressed"), &Pressed);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
KeypressedParamsData(const KeypressedParamsData&) = delete;
|
|
189
|
+
KeypressedParamsData(KeypressedParamsData&&) noexcept = delete;
|
|
190
|
+
|
|
191
|
+
KeypressedParamsData& operator=(const KeypressedParamsData&) = delete;
|
|
192
|
+
KeypressedParamsData& operator=(KeypressedParamsData&&) noexcept = delete;
|
|
193
|
+
|
|
194
|
+
~KeypressedParamsData() = default;
|
|
195
|
+
|
|
196
|
+
public:
|
|
197
|
+
bool IsDataValid() const
|
|
198
|
+
{
|
|
199
|
+
return (Pressed.IsSet() == true);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
public:
|
|
203
|
+
Core::JSON::Boolean Pressed; // Denotes if the key was pressed (true) or released (false)
|
|
204
|
+
}; // class KeypressedParamsData
|
|
205
|
+
|
|
206
|
+
class UnpairParamsData : public Core::JSON::Container {
|
|
207
|
+
public:
|
|
208
|
+
UnpairParamsData()
|
|
209
|
+
: Core::JSON::Container()
|
|
210
|
+
{
|
|
211
|
+
Add(_T("device"), &Device);
|
|
212
|
+
Add(_T("bindid"), &Bindid);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
UnpairParamsData(const UnpairParamsData&) = delete;
|
|
216
|
+
UnpairParamsData(UnpairParamsData&&) noexcept = delete;
|
|
217
|
+
|
|
218
|
+
UnpairParamsData& operator=(const UnpairParamsData&) = delete;
|
|
219
|
+
UnpairParamsData& operator=(UnpairParamsData&&) noexcept = delete;
|
|
220
|
+
|
|
221
|
+
~UnpairParamsData() = default;
|
|
222
|
+
|
|
223
|
+
public:
|
|
224
|
+
bool IsDataValid() const
|
|
225
|
+
{
|
|
226
|
+
return ((Device.IsSet() == true) && (Bindid.IsSet() == true));
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
public:
|
|
230
|
+
Core::JSON::String Device; // Device name
|
|
231
|
+
Core::JSON::String Bindid; // Binding ID
|
|
232
|
+
}; // class UnpairParamsData
|
|
233
|
+
|
|
234
|
+
} // namespace RemoteControl
|
|
235
|
+
|
|
236
|
+
POP_WARNING()
|
|
237
|
+
|
|
238
|
+
} // namespace JsonData
|
|
239
|
+
|
|
240
|
+
// Enum conversion handlers
|
|
241
|
+
ENUM_CONVERSION_HANDLER(JsonData::RemoteControl::ModifiersType)
|
|
242
|
+
|
|
243
|
+
}
|
|
244
|
+
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
// C++ types for ScriptEngine API.
|
|
2
|
+
// Generated automatically from 'IScriptEngine.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IScriptEngine.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ScriptEngine {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class URLChangedParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
URLChangedParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("url"), &URL);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
URLChangedParamsData(const URLChangedParamsData&) = delete;
|
|
31
|
+
URLChangedParamsData(URLChangedParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
URLChangedParamsData& operator=(const URLChangedParamsData&) = delete;
|
|
34
|
+
URLChangedParamsData& operator=(URLChangedParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~URLChangedParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (URL.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String URL; // Loaded URL
|
|
46
|
+
}; // class URLChangedParamsData
|
|
47
|
+
|
|
48
|
+
class URLData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
URLData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("value"), &Value);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
URLData(const URLData&) = delete;
|
|
57
|
+
URLData(URLData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
URLData& operator=(const URLData&) = delete;
|
|
60
|
+
URLData& operator=(URLData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~URLData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Value.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String Value; // Script to be loaded into the engine and to be executed.
|
|
72
|
+
}; // class URLData
|
|
73
|
+
|
|
74
|
+
} // namespace ScriptEngine
|
|
75
|
+
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
|
|
78
|
+
} // namespace JsonData
|
|
79
|
+
|
|
80
|
+
}
|
|
81
|
+
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
// C++ types for SecureShell Server API.
|
|
2
|
+
// Generated automatically from 'SecureShellServer.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace SecureShellServer {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class CloseclientsessionParamsData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
CloseclientsessionParamsData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("clientpid"), &Clientpid);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
CloseclientsessionParamsData(const CloseclientsessionParamsData&) = delete;
|
|
30
|
+
CloseclientsessionParamsData(CloseclientsessionParamsData&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
CloseclientsessionParamsData& operator=(const CloseclientsessionParamsData&) = delete;
|
|
33
|
+
CloseclientsessionParamsData& operator=(CloseclientsessionParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~CloseclientsessionParamsData() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (Clientpid.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Clientpid; // SSH client process id
|
|
45
|
+
}; // class CloseclientsessionParamsData
|
|
46
|
+
|
|
47
|
+
class GetactivesessionsinfoResultDataElem : public Core::JSON::Container {
|
|
48
|
+
public:
|
|
49
|
+
GetactivesessionsinfoResultDataElem()
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
_Init();
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
GetactivesessionsinfoResultDataElem(const GetactivesessionsinfoResultDataElem& _other)
|
|
56
|
+
: Core::JSON::Container()
|
|
57
|
+
, Pid(_other.Pid)
|
|
58
|
+
, Ipaddress(_other.Ipaddress)
|
|
59
|
+
, Timestamp(_other.Timestamp)
|
|
60
|
+
{
|
|
61
|
+
_Init();
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
GetactivesessionsinfoResultDataElem(GetactivesessionsinfoResultDataElem&& _other) noexcept
|
|
65
|
+
: Core::JSON::Container()
|
|
66
|
+
, Pid(std::move(_other.Pid))
|
|
67
|
+
, Ipaddress(std::move(_other.Ipaddress))
|
|
68
|
+
, Timestamp(std::move(_other.Timestamp))
|
|
69
|
+
{
|
|
70
|
+
_Init();
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
GetactivesessionsinfoResultDataElem& operator=(const GetactivesessionsinfoResultDataElem& _rhs)
|
|
74
|
+
{
|
|
75
|
+
Pid = _rhs.Pid;
|
|
76
|
+
Ipaddress = _rhs.Ipaddress;
|
|
77
|
+
Timestamp = _rhs.Timestamp;
|
|
78
|
+
return (*this);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
GetactivesessionsinfoResultDataElem& operator=(GetactivesessionsinfoResultDataElem&& _rhs) noexcept
|
|
82
|
+
{
|
|
83
|
+
Pid = std::move(_rhs.Pid);
|
|
84
|
+
Ipaddress = std::move(_rhs.Ipaddress);
|
|
85
|
+
Timestamp = std::move(_rhs.Timestamp);
|
|
86
|
+
return (*this);
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
~GetactivesessionsinfoResultDataElem() = default;
|
|
90
|
+
|
|
91
|
+
public:
|
|
92
|
+
bool IsDataValid() const
|
|
93
|
+
{
|
|
94
|
+
return ((Pid.IsSet() == true) && (Ipaddress.IsSet() == true) && (Timestamp.IsSet() == true));
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
private:
|
|
98
|
+
void _Init()
|
|
99
|
+
{
|
|
100
|
+
Add(_T("pid"), &Pid);
|
|
101
|
+
Add(_T("ipaddress"), &Ipaddress);
|
|
102
|
+
Add(_T("timestamp"), &Timestamp);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
public:
|
|
106
|
+
Core::JSON::DecUInt64 Pid; // SSH client process ID
|
|
107
|
+
Core::JSON::String Ipaddress; // SSH client connected from this IP address
|
|
108
|
+
Core::JSON::String Timestamp; // SSH client connected at this timestamp
|
|
109
|
+
}; // class GetactivesessionsinfoResultDataElem
|
|
110
|
+
|
|
111
|
+
} // namespace SecureShellServer
|
|
112
|
+
|
|
113
|
+
POP_WARNING()
|
|
114
|
+
|
|
115
|
+
} // namespace JsonData
|
|
116
|
+
|
|
117
|
+
}
|
|
118
|
+
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
// C++ types for SecurityAgent API.
|
|
2
|
+
// Generated automatically from 'ISecurityAgent.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/ISecurityAgent.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SecurityAgent {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ValidateParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ValidateParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("token"), &Token);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ValidateParamsData(const ValidateParamsData&) = delete;
|
|
31
|
+
ValidateParamsData(ValidateParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
ValidateParamsData& operator=(const ValidateParamsData&) = delete;
|
|
34
|
+
ValidateParamsData& operator=(ValidateParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~ValidateParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Token.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Token; // Token that will be validated
|
|
46
|
+
}; // class ValidateParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace SecurityAgent
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
// C++ types for StateControl API.
|
|
2
|
+
// Generated automatically from 'StateControl.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace StateControl {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Running state of the service
|
|
23
|
+
enum class StateType : uint8_t {
|
|
24
|
+
RESUMED,
|
|
25
|
+
SUSPENDED
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// Method params/result classes
|
|
29
|
+
//
|
|
30
|
+
|
|
31
|
+
class StatechangeParamsData : public Core::JSON::Container {
|
|
32
|
+
public:
|
|
33
|
+
StatechangeParamsData()
|
|
34
|
+
: Core::JSON::Container()
|
|
35
|
+
{
|
|
36
|
+
Add(_T("suspended"), &Suspended);
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
StatechangeParamsData(const StatechangeParamsData&) = delete;
|
|
40
|
+
StatechangeParamsData(StatechangeParamsData&&) noexcept = delete;
|
|
41
|
+
|
|
42
|
+
StatechangeParamsData& operator=(const StatechangeParamsData&) = delete;
|
|
43
|
+
StatechangeParamsData& operator=(StatechangeParamsData&&) noexcept = delete;
|
|
44
|
+
|
|
45
|
+
~StatechangeParamsData() = default;
|
|
46
|
+
|
|
47
|
+
public:
|
|
48
|
+
bool IsDataValid() const
|
|
49
|
+
{
|
|
50
|
+
return (Suspended.IsSet() == true);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
public:
|
|
54
|
+
Core::JSON::Boolean Suspended; // Determines if the service has entered suspended state (true) or resumed state (false)
|
|
55
|
+
}; // class StatechangeParamsData
|
|
56
|
+
|
|
57
|
+
} // namespace StateControl
|
|
58
|
+
|
|
59
|
+
POP_WARNING()
|
|
60
|
+
|
|
61
|
+
} // namespace JsonData
|
|
62
|
+
|
|
63
|
+
// Enum conversion handlers
|
|
64
|
+
ENUM_CONVERSION_HANDLER(JsonData::StateControl::StateType)
|
|
65
|
+
|
|
66
|
+
}
|
|
67
|
+
|
|
@@ -0,0 +1,187 @@
|
|
|
1
|
+
// C++ types for Store2 API.
|
|
2
|
+
// Generated automatically from 'IStore2.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IStore2.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Store2 {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class GetValueParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
GetValueParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("scope"), &Scope);
|
|
28
|
+
Add(_T("namespace"), &Ns);
|
|
29
|
+
Add(_T("key"), &Key);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
GetValueParamsInfo(const GetValueParamsInfo&) = delete;
|
|
33
|
+
GetValueParamsInfo(GetValueParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
GetValueParamsInfo& operator=(const GetValueParamsInfo&) = delete;
|
|
36
|
+
GetValueParamsInfo& operator=(GetValueParamsInfo&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~GetValueParamsInfo() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return ((Scope.IsSet() == true) && (Ns.IsSet() == true) && (Key.IsSet() == true));
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::EnumType<Exchange::IStore2::ScopeType> Scope;
|
|
48
|
+
Core::JSON::String Ns;
|
|
49
|
+
Core::JSON::String Key;
|
|
50
|
+
}; // class GetValueParamsInfo
|
|
51
|
+
|
|
52
|
+
// Method params/result classes
|
|
53
|
+
//
|
|
54
|
+
|
|
55
|
+
class DeleteNamespaceParamsData : public Core::JSON::Container {
|
|
56
|
+
public:
|
|
57
|
+
DeleteNamespaceParamsData()
|
|
58
|
+
: Core::JSON::Container()
|
|
59
|
+
{
|
|
60
|
+
Add(_T("scope"), &Scope);
|
|
61
|
+
Add(_T("namespace"), &Ns);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
DeleteNamespaceParamsData(const DeleteNamespaceParamsData&) = delete;
|
|
65
|
+
DeleteNamespaceParamsData(DeleteNamespaceParamsData&&) noexcept = delete;
|
|
66
|
+
|
|
67
|
+
DeleteNamespaceParamsData& operator=(const DeleteNamespaceParamsData&) = delete;
|
|
68
|
+
DeleteNamespaceParamsData& operator=(DeleteNamespaceParamsData&&) noexcept = delete;
|
|
69
|
+
|
|
70
|
+
~DeleteNamespaceParamsData() = default;
|
|
71
|
+
|
|
72
|
+
public:
|
|
73
|
+
bool IsDataValid() const
|
|
74
|
+
{
|
|
75
|
+
return ((Scope.IsSet() == true) && (Ns.IsSet() == true));
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
public:
|
|
79
|
+
Core::JSON::EnumType<Exchange::IStore2::ScopeType> Scope;
|
|
80
|
+
Core::JSON::String Ns;
|
|
81
|
+
}; // class DeleteNamespaceParamsData
|
|
82
|
+
|
|
83
|
+
class GetValueResultData : public Core::JSON::Container {
|
|
84
|
+
public:
|
|
85
|
+
GetValueResultData()
|
|
86
|
+
: Core::JSON::Container()
|
|
87
|
+
{
|
|
88
|
+
Add(_T("value"), &Value);
|
|
89
|
+
Add(_T("ttl"), &Ttl);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
GetValueResultData(const GetValueResultData&) = delete;
|
|
93
|
+
GetValueResultData(GetValueResultData&&) noexcept = delete;
|
|
94
|
+
|
|
95
|
+
GetValueResultData& operator=(const GetValueResultData&) = delete;
|
|
96
|
+
GetValueResultData& operator=(GetValueResultData&&) noexcept = delete;
|
|
97
|
+
|
|
98
|
+
~GetValueResultData() = default;
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
bool IsDataValid() const
|
|
102
|
+
{
|
|
103
|
+
return ((Value.IsSet() == true) && (Ttl.IsSet() == true));
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
public:
|
|
107
|
+
Core::JSON::String Value;
|
|
108
|
+
Core::JSON::DecUInt32 Ttl;
|
|
109
|
+
}; // class GetValueResultData
|
|
110
|
+
|
|
111
|
+
class SetValueParamsData : public Core::JSON::Container {
|
|
112
|
+
public:
|
|
113
|
+
SetValueParamsData()
|
|
114
|
+
: Core::JSON::Container()
|
|
115
|
+
{
|
|
116
|
+
Add(_T("scope"), &Scope);
|
|
117
|
+
Add(_T("namespace"), &Ns);
|
|
118
|
+
Add(_T("key"), &Key);
|
|
119
|
+
Add(_T("value"), &Value);
|
|
120
|
+
Add(_T("ttl"), &Ttl);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
SetValueParamsData(const SetValueParamsData&) = delete;
|
|
124
|
+
SetValueParamsData(SetValueParamsData&&) noexcept = delete;
|
|
125
|
+
|
|
126
|
+
SetValueParamsData& operator=(const SetValueParamsData&) = delete;
|
|
127
|
+
SetValueParamsData& operator=(SetValueParamsData&&) noexcept = delete;
|
|
128
|
+
|
|
129
|
+
~SetValueParamsData() = default;
|
|
130
|
+
|
|
131
|
+
public:
|
|
132
|
+
bool IsDataValid() const
|
|
133
|
+
{
|
|
134
|
+
return ((Scope.IsSet() == true) && (Ns.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true) && (Ttl.IsSet() == true));
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
public:
|
|
138
|
+
Core::JSON::EnumType<Exchange::IStore2::ScopeType> Scope;
|
|
139
|
+
Core::JSON::String Ns;
|
|
140
|
+
Core::JSON::String Key;
|
|
141
|
+
Core::JSON::String Value;
|
|
142
|
+
Core::JSON::DecUInt32 Ttl;
|
|
143
|
+
}; // class SetValueParamsData
|
|
144
|
+
|
|
145
|
+
class ValueChangedParamsData : public Core::JSON::Container {
|
|
146
|
+
public:
|
|
147
|
+
ValueChangedParamsData()
|
|
148
|
+
: Core::JSON::Container()
|
|
149
|
+
{
|
|
150
|
+
Add(_T("scope"), &Scope);
|
|
151
|
+
Add(_T("namespace"), &Ns);
|
|
152
|
+
Add(_T("key"), &Key);
|
|
153
|
+
Add(_T("value"), &Value);
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
ValueChangedParamsData(const ValueChangedParamsData&) = delete;
|
|
157
|
+
ValueChangedParamsData(ValueChangedParamsData&&) noexcept = delete;
|
|
158
|
+
|
|
159
|
+
ValueChangedParamsData& operator=(const ValueChangedParamsData&) = delete;
|
|
160
|
+
ValueChangedParamsData& operator=(ValueChangedParamsData&&) noexcept = delete;
|
|
161
|
+
|
|
162
|
+
~ValueChangedParamsData() = default;
|
|
163
|
+
|
|
164
|
+
public:
|
|
165
|
+
bool IsDataValid() const
|
|
166
|
+
{
|
|
167
|
+
return ((Scope.IsSet() == true) && (Ns.IsSet() == true) && (Key.IsSet() == true) && (Value.IsSet() == true));
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
public:
|
|
171
|
+
Core::JSON::EnumType<Exchange::IStore2::ScopeType> Scope;
|
|
172
|
+
Core::JSON::String Ns;
|
|
173
|
+
Core::JSON::String Key;
|
|
174
|
+
Core::JSON::String Value;
|
|
175
|
+
}; // class ValueChangedParamsData
|
|
176
|
+
|
|
177
|
+
} // namespace Store2
|
|
178
|
+
|
|
179
|
+
POP_WARNING()
|
|
180
|
+
|
|
181
|
+
} // namespace JsonData
|
|
182
|
+
|
|
183
|
+
// Enum conversion handlers
|
|
184
|
+
ENUM_CONVERSION_HANDLER(Exchange::IStore2::ScopeType)
|
|
185
|
+
|
|
186
|
+
}
|
|
187
|
+
|
|
@@ -0,0 +1,324 @@
|
|
|
1
|
+
// C++ types for Streamer API.
|
|
2
|
+
// Generated automatically from 'Streamer.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Streamer {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// DRM used
|
|
23
|
+
enum class DrmType : uint8_t {
|
|
24
|
+
NONE,
|
|
25
|
+
CLEARKEY,
|
|
26
|
+
PLAYREADY,
|
|
27
|
+
WIDEVINE,
|
|
28
|
+
UNKNOWN
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
// Stream state
|
|
32
|
+
enum class StateType : uint8_t {
|
|
33
|
+
IDLE,
|
|
34
|
+
LOADING,
|
|
35
|
+
PREPARED,
|
|
36
|
+
CONTROLLED,
|
|
37
|
+
ERROR
|
|
38
|
+
};
|
|
39
|
+
|
|
40
|
+
// Stream type
|
|
41
|
+
enum class StreamType : uint8_t {
|
|
42
|
+
UNDEFINED = 0,
|
|
43
|
+
CABLE = 1,
|
|
44
|
+
HANDHELD = 2,
|
|
45
|
+
SATELLITE = 4,
|
|
46
|
+
TERRESTRIAL = 8,
|
|
47
|
+
DAB = 16,
|
|
48
|
+
RF = 31,
|
|
49
|
+
UNICAST = 32,
|
|
50
|
+
MULTICAST = 64,
|
|
51
|
+
IP = 96
|
|
52
|
+
};
|
|
53
|
+
|
|
54
|
+
// Common classes
|
|
55
|
+
//
|
|
56
|
+
|
|
57
|
+
class IdInfo : public Core::JSON::Container {
|
|
58
|
+
public:
|
|
59
|
+
IdInfo()
|
|
60
|
+
: Core::JSON::Container()
|
|
61
|
+
{
|
|
62
|
+
Add(_T("id"), &Id);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
IdInfo(const IdInfo&) = delete;
|
|
66
|
+
IdInfo(IdInfo&&) noexcept = delete;
|
|
67
|
+
|
|
68
|
+
IdInfo& operator=(const IdInfo&) = delete;
|
|
69
|
+
IdInfo& operator=(IdInfo&&) noexcept = delete;
|
|
70
|
+
|
|
71
|
+
~IdInfo() = default;
|
|
72
|
+
|
|
73
|
+
public:
|
|
74
|
+
bool IsDataValid() const
|
|
75
|
+
{
|
|
76
|
+
return (Id.IsSet() == true);
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
public:
|
|
80
|
+
Core::JSON::DecUInt8 Id; // Stream ID
|
|
81
|
+
}; // class IdInfo
|
|
82
|
+
|
|
83
|
+
class StreamParamsInfo : public Core::JSON::Container {
|
|
84
|
+
public:
|
|
85
|
+
StreamParamsInfo()
|
|
86
|
+
: Core::JSON::Container()
|
|
87
|
+
{
|
|
88
|
+
Add(_T("code"), &Code);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
StreamParamsInfo(const StreamParamsInfo&) = delete;
|
|
92
|
+
StreamParamsInfo(StreamParamsInfo&&) noexcept = delete;
|
|
93
|
+
|
|
94
|
+
StreamParamsInfo& operator=(const StreamParamsInfo&) = delete;
|
|
95
|
+
StreamParamsInfo& operator=(StreamParamsInfo&&) noexcept = delete;
|
|
96
|
+
|
|
97
|
+
~StreamParamsInfo() = default;
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
bool IsDataValid() const
|
|
101
|
+
{
|
|
102
|
+
return (Code.IsSet() == true);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
public:
|
|
106
|
+
Core::JSON::DecUInt32 Code; // Implementation-specific incident code
|
|
107
|
+
}; // class StreamParamsInfo
|
|
108
|
+
|
|
109
|
+
// Method params/result classes
|
|
110
|
+
//
|
|
111
|
+
|
|
112
|
+
class CreateParamsData : public Core::JSON::Container {
|
|
113
|
+
public:
|
|
114
|
+
CreateParamsData()
|
|
115
|
+
: Core::JSON::Container()
|
|
116
|
+
{
|
|
117
|
+
Add(_T("type"), &Type);
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
CreateParamsData(const CreateParamsData&) = delete;
|
|
121
|
+
CreateParamsData(CreateParamsData&&) noexcept = delete;
|
|
122
|
+
|
|
123
|
+
CreateParamsData& operator=(const CreateParamsData&) = delete;
|
|
124
|
+
CreateParamsData& operator=(CreateParamsData&&) noexcept = delete;
|
|
125
|
+
|
|
126
|
+
~CreateParamsData() = default;
|
|
127
|
+
|
|
128
|
+
public:
|
|
129
|
+
bool IsDataValid() const
|
|
130
|
+
{
|
|
131
|
+
return (Type.IsSet() == true);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
public:
|
|
135
|
+
Core::JSON::EnumType<StreamType> Type; // Stream type
|
|
136
|
+
}; // class CreateParamsData
|
|
137
|
+
|
|
138
|
+
class StreamelementData : public Core::JSON::Container {
|
|
139
|
+
public:
|
|
140
|
+
// Stream element type
|
|
141
|
+
enum class ElementType : uint8_t {
|
|
142
|
+
VIDEO,
|
|
143
|
+
AUDIO,
|
|
144
|
+
SUBTITLES,
|
|
145
|
+
TELETEXT,
|
|
146
|
+
DATA
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
StreamelementData()
|
|
150
|
+
: Core::JSON::Container()
|
|
151
|
+
{
|
|
152
|
+
_Init();
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
StreamelementData(const StreamelementData& _other)
|
|
156
|
+
: Core::JSON::Container()
|
|
157
|
+
, Type(_other.Type)
|
|
158
|
+
{
|
|
159
|
+
_Init();
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
StreamelementData(StreamelementData&& _other) noexcept
|
|
163
|
+
: Core::JSON::Container()
|
|
164
|
+
, Type(std::move(_other.Type))
|
|
165
|
+
{
|
|
166
|
+
_Init();
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
StreamelementData& operator=(const StreamelementData& _rhs)
|
|
170
|
+
{
|
|
171
|
+
Type = _rhs.Type;
|
|
172
|
+
return (*this);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
StreamelementData& operator=(StreamelementData&& _rhs) noexcept
|
|
176
|
+
{
|
|
177
|
+
Type = std::move(_rhs.Type);
|
|
178
|
+
return (*this);
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
~StreamelementData() = default;
|
|
182
|
+
|
|
183
|
+
public:
|
|
184
|
+
bool IsDataValid() const
|
|
185
|
+
{
|
|
186
|
+
return (Type.IsSet() == true);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
private:
|
|
190
|
+
void _Init()
|
|
191
|
+
{
|
|
192
|
+
Add(_T("type"), &Type);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
public:
|
|
196
|
+
Core::JSON::EnumType<StreamelementData::ElementType> Type; // Stream element type
|
|
197
|
+
}; // class StreamelementData
|
|
198
|
+
|
|
199
|
+
class LoadParamsData : public Core::JSON::Container {
|
|
200
|
+
public:
|
|
201
|
+
LoadParamsData()
|
|
202
|
+
: Core::JSON::Container()
|
|
203
|
+
{
|
|
204
|
+
Add(_T("id"), &Id);
|
|
205
|
+
Add(_T("location"), &Location);
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
LoadParamsData(const LoadParamsData&) = delete;
|
|
209
|
+
LoadParamsData(LoadParamsData&&) noexcept = delete;
|
|
210
|
+
|
|
211
|
+
LoadParamsData& operator=(const LoadParamsData&) = delete;
|
|
212
|
+
LoadParamsData& operator=(LoadParamsData&&) noexcept = delete;
|
|
213
|
+
|
|
214
|
+
~LoadParamsData() = default;
|
|
215
|
+
|
|
216
|
+
public:
|
|
217
|
+
bool IsDataValid() const
|
|
218
|
+
{
|
|
219
|
+
return ((Id.IsSet() == true) && (Location.IsSet() == true));
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
public:
|
|
223
|
+
Core::JSON::DecUInt8 Id; // Stream ID
|
|
224
|
+
Core::JSON::String Location; // Location of the source to load
|
|
225
|
+
}; // class LoadParamsData
|
|
226
|
+
|
|
227
|
+
class StatechangeParamsData : public Core::JSON::Container {
|
|
228
|
+
public:
|
|
229
|
+
StatechangeParamsData()
|
|
230
|
+
: Core::JSON::Container()
|
|
231
|
+
{
|
|
232
|
+
Add(_T("state"), &State);
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
StatechangeParamsData(const StatechangeParamsData&) = delete;
|
|
236
|
+
StatechangeParamsData(StatechangeParamsData&&) noexcept = delete;
|
|
237
|
+
|
|
238
|
+
StatechangeParamsData& operator=(const StatechangeParamsData&) = delete;
|
|
239
|
+
StatechangeParamsData& operator=(StatechangeParamsData&&) noexcept = delete;
|
|
240
|
+
|
|
241
|
+
~StatechangeParamsData() = default;
|
|
242
|
+
|
|
243
|
+
public:
|
|
244
|
+
bool IsDataValid() const
|
|
245
|
+
{
|
|
246
|
+
return (State.IsSet() == true);
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
public:
|
|
250
|
+
Core::JSON::EnumType<StateType> State; // Stream state
|
|
251
|
+
}; // class StatechangeParamsData
|
|
252
|
+
|
|
253
|
+
class TimeupdateParamsData : public Core::JSON::Container {
|
|
254
|
+
public:
|
|
255
|
+
TimeupdateParamsData()
|
|
256
|
+
: Core::JSON::Container()
|
|
257
|
+
{
|
|
258
|
+
Add(_T("time"), &Time);
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
TimeupdateParamsData(const TimeupdateParamsData&) = delete;
|
|
262
|
+
TimeupdateParamsData(TimeupdateParamsData&&) noexcept = delete;
|
|
263
|
+
|
|
264
|
+
TimeupdateParamsData& operator=(const TimeupdateParamsData&) = delete;
|
|
265
|
+
TimeupdateParamsData& operator=(TimeupdateParamsData&&) noexcept = delete;
|
|
266
|
+
|
|
267
|
+
~TimeupdateParamsData() = default;
|
|
268
|
+
|
|
269
|
+
public:
|
|
270
|
+
bool IsDataValid() const
|
|
271
|
+
{
|
|
272
|
+
return (Time.IsSet() == true);
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
public:
|
|
276
|
+
Core::JSON::DecUInt64 Time; // Stream position in miliseconds
|
|
277
|
+
}; // class TimeupdateParamsData
|
|
278
|
+
|
|
279
|
+
class WindowData : public Core::JSON::Container {
|
|
280
|
+
public:
|
|
281
|
+
WindowData()
|
|
282
|
+
: Core::JSON::Container()
|
|
283
|
+
{
|
|
284
|
+
Add(_T("x"), &X);
|
|
285
|
+
Add(_T("y"), &Y);
|
|
286
|
+
Add(_T("width"), &Width);
|
|
287
|
+
Add(_T("height"), &Height);
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
WindowData(const WindowData&) = delete;
|
|
291
|
+
WindowData(WindowData&&) noexcept = delete;
|
|
292
|
+
|
|
293
|
+
WindowData& operator=(const WindowData&) = delete;
|
|
294
|
+
WindowData& operator=(WindowData&&) noexcept = delete;
|
|
295
|
+
|
|
296
|
+
~WindowData() = default;
|
|
297
|
+
|
|
298
|
+
public:
|
|
299
|
+
bool IsDataValid() const
|
|
300
|
+
{
|
|
301
|
+
return ((X.IsSet() == true) && (Y.IsSet() == true) && (Width.IsSet() == true) && (Height.IsSet() == true));
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
public:
|
|
305
|
+
Core::JSON::DecUInt32 X; // Horizontal position of the window (in pixels)
|
|
306
|
+
Core::JSON::DecUInt32 Y; // Vertical position of the window (in pixels)
|
|
307
|
+
Core::JSON::DecUInt32 Width; // Width of the window (in pixels)
|
|
308
|
+
Core::JSON::DecUInt32 Height; // Height of the window (in pixels)
|
|
309
|
+
}; // class WindowData
|
|
310
|
+
|
|
311
|
+
} // namespace Streamer
|
|
312
|
+
|
|
313
|
+
POP_WARNING()
|
|
314
|
+
|
|
315
|
+
} // namespace JsonData
|
|
316
|
+
|
|
317
|
+
// Enum conversion handlers
|
|
318
|
+
ENUM_CONVERSION_HANDLER(JsonData::Streamer::StreamType)
|
|
319
|
+
ENUM_CONVERSION_HANDLER(JsonData::Streamer::DrmType)
|
|
320
|
+
ENUM_CONVERSION_HANDLER(JsonData::Streamer::StateType)
|
|
321
|
+
ENUM_CONVERSION_HANDLER(JsonData::Streamer::StreamelementData::ElementType)
|
|
322
|
+
|
|
323
|
+
}
|
|
324
|
+
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
// C++ types for SubsystemControl API.
|
|
2
|
+
// Generated automatically from 'ISubsystemControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/ISubsystemControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SubsystemControl {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ActivateParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ActivateParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("subsystem"), &Subsystem);
|
|
28
|
+
Add(_T("configuration"), &Configuration);
|
|
29
|
+
Configuration.SetQuoted(false);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
ActivateParamsData(const ActivateParamsData&) = delete;
|
|
33
|
+
ActivateParamsData(ActivateParamsData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
ActivateParamsData& operator=(const ActivateParamsData&) = delete;
|
|
36
|
+
ActivateParamsData& operator=(ActivateParamsData&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~ActivateParamsData() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return (Subsystem.IsSet() == true);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::EnumType<PluginHost::ISubSystem::subsystem> Subsystem; // Subsystem to activate
|
|
48
|
+
Core::JSON::String Configuration; // A JSON string that holds the information applicable to the subsystem to be activated
|
|
49
|
+
}; // class ActivateParamsData
|
|
50
|
+
|
|
51
|
+
} // namespace SubsystemControl
|
|
52
|
+
|
|
53
|
+
POP_WARNING()
|
|
54
|
+
|
|
55
|
+
} // namespace JsonData
|
|
56
|
+
|
|
57
|
+
// Enum conversion handlers
|
|
58
|
+
ENUM_CONVERSION_HANDLER(PluginHost::ISubSystem::subsystem)
|
|
59
|
+
|
|
60
|
+
}
|
|
61
|
+
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
// C++ types for SystemCommands API.
|
|
2
|
+
// Generated automatically from 'ISystemCommands.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/ISystemCommands.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace SystemCommands {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class USBResetParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
USBResetParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("device"), &Device);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
USBResetParamsData(const USBResetParamsData&) = delete;
|
|
31
|
+
USBResetParamsData(USBResetParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
USBResetParamsData& operator=(const USBResetParamsData&) = delete;
|
|
34
|
+
USBResetParamsData& operator=(USBResetParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~USBResetParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Device.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Device; // USB device to reset
|
|
46
|
+
}; // class USBResetParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace SystemCommands
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
@@ -0,0 +1,144 @@
|
|
|
1
|
+
// C++ types for TimeSync API.
|
|
2
|
+
// Generated automatically from 'ITimeSync.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/ITimeSync.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TimeSync {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class TimeInfoData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
TimeInfoData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
TimeInfoData(const TimeInfoData& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Time(_other.Time)
|
|
33
|
+
, Source(_other.Source)
|
|
34
|
+
{
|
|
35
|
+
_Init();
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
TimeInfoData(TimeInfoData&& _other) noexcept
|
|
39
|
+
: Core::JSON::Container()
|
|
40
|
+
, Time(std::move(_other.Time))
|
|
41
|
+
, Source(std::move(_other.Source))
|
|
42
|
+
{
|
|
43
|
+
_Init();
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
TimeInfoData(const Exchange::ITimeSync::TimeInfo& _other)
|
|
47
|
+
: Core::JSON::Container()
|
|
48
|
+
{
|
|
49
|
+
Time = _other.time.ToISO8601();
|
|
50
|
+
if (_other.source.IsSet() == true) {
|
|
51
|
+
Source = _other.source.Value();
|
|
52
|
+
}
|
|
53
|
+
_Init();
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
TimeInfoData& operator=(const TimeInfoData& _rhs)
|
|
57
|
+
{
|
|
58
|
+
Time = _rhs.Time;
|
|
59
|
+
if (_rhs.Source.IsSet() == true) {
|
|
60
|
+
Source = _rhs.Source;
|
|
61
|
+
}
|
|
62
|
+
return (*this);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
TimeInfoData& operator=(TimeInfoData&& _rhs) noexcept
|
|
66
|
+
{
|
|
67
|
+
Time = std::move(_rhs.Time);
|
|
68
|
+
Source = std::move(_rhs.Source);
|
|
69
|
+
return (*this);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
TimeInfoData& operator=(const Exchange::ITimeSync::TimeInfo& _rhs)
|
|
73
|
+
{
|
|
74
|
+
Time = _rhs.time.ToISO8601();
|
|
75
|
+
if (_rhs.source.IsSet() == true) {
|
|
76
|
+
Source = _rhs.source.Value();
|
|
77
|
+
}
|
|
78
|
+
return (*this);
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
operator Exchange::ITimeSync::TimeInfo() const
|
|
82
|
+
{
|
|
83
|
+
Exchange::ITimeSync::TimeInfo _value{};
|
|
84
|
+
_value.time.FromISO8601(Time);
|
|
85
|
+
if (Source.IsSet() == true) {
|
|
86
|
+
_value.source = Source;
|
|
87
|
+
}
|
|
88
|
+
return (_value);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
~TimeInfoData() = default;
|
|
92
|
+
|
|
93
|
+
public:
|
|
94
|
+
bool IsDataValid() const
|
|
95
|
+
{
|
|
96
|
+
return (Time.IsSet() == true);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
private:
|
|
100
|
+
void _Init()
|
|
101
|
+
{
|
|
102
|
+
Add(_T("time"), &Time);
|
|
103
|
+
Add(_T("source"), &Source);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
public:
|
|
107
|
+
Core::JSON::String Time; // Synchronized time (in ISO8601 format); empty string if the time has never been synchronized
|
|
108
|
+
Core::JSON::String Source; // The synchronization source like an NTP server
|
|
109
|
+
}; // class TimeInfoData
|
|
110
|
+
|
|
111
|
+
class TimeData : public Core::JSON::Container {
|
|
112
|
+
public:
|
|
113
|
+
TimeData()
|
|
114
|
+
: Core::JSON::Container()
|
|
115
|
+
{
|
|
116
|
+
Add(_T("value"), &Value);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
TimeData(const TimeData&) = delete;
|
|
120
|
+
TimeData(TimeData&&) noexcept = delete;
|
|
121
|
+
|
|
122
|
+
TimeData& operator=(const TimeData&) = delete;
|
|
123
|
+
TimeData& operator=(TimeData&&) noexcept = delete;
|
|
124
|
+
|
|
125
|
+
~TimeData() = default;
|
|
126
|
+
|
|
127
|
+
public:
|
|
128
|
+
bool IsDataValid() const
|
|
129
|
+
{
|
|
130
|
+
return (Value.IsSet() == true);
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
public:
|
|
134
|
+
Core::JSON::String Value; // Current system time
|
|
135
|
+
}; // class TimeData
|
|
136
|
+
|
|
137
|
+
} // namespace TimeSync
|
|
138
|
+
|
|
139
|
+
POP_WARNING()
|
|
140
|
+
|
|
141
|
+
} // namespace JsonData
|
|
142
|
+
|
|
143
|
+
}
|
|
144
|
+
|
|
@@ -0,0 +1,467 @@
|
|
|
1
|
+
// C++ types for USBHub API.
|
|
2
|
+
// Generated automatically from 'IUSBHub.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IUSBHub.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace USBHub {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ProductMetadataInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ProductMetadataInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ProductMetadataInfo(const ProductMetadataInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, LanguageId(_other.LanguageId)
|
|
33
|
+
, SerialNumber(_other.SerialNumber)
|
|
34
|
+
, Manufacturer(_other.Manufacturer)
|
|
35
|
+
, Product(_other.Product)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
ProductMetadataInfo(ProductMetadataInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, LanguageId(std::move(_other.LanguageId))
|
|
43
|
+
, SerialNumber(std::move(_other.SerialNumber))
|
|
44
|
+
, Manufacturer(std::move(_other.Manufacturer))
|
|
45
|
+
, Product(std::move(_other.Product))
|
|
46
|
+
{
|
|
47
|
+
_Init();
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
ProductMetadataInfo(const Exchange::IUSBHub::ProductMetadata& _other)
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
LanguageId = _other.languageId;
|
|
54
|
+
SerialNumber = _other.serialNumber;
|
|
55
|
+
Manufacturer = _other.manufacturer;
|
|
56
|
+
Product = _other.product;
|
|
57
|
+
_Init();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
ProductMetadataInfo& operator=(const ProductMetadataInfo& _rhs)
|
|
61
|
+
{
|
|
62
|
+
LanguageId = _rhs.LanguageId;
|
|
63
|
+
SerialNumber = _rhs.SerialNumber;
|
|
64
|
+
Manufacturer = _rhs.Manufacturer;
|
|
65
|
+
Product = _rhs.Product;
|
|
66
|
+
return (*this);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
ProductMetadataInfo& operator=(ProductMetadataInfo&& _rhs) noexcept
|
|
70
|
+
{
|
|
71
|
+
LanguageId = std::move(_rhs.LanguageId);
|
|
72
|
+
SerialNumber = std::move(_rhs.SerialNumber);
|
|
73
|
+
Manufacturer = std::move(_rhs.Manufacturer);
|
|
74
|
+
Product = std::move(_rhs.Product);
|
|
75
|
+
return (*this);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
ProductMetadataInfo& operator=(const Exchange::IUSBHub::ProductMetadata& _rhs)
|
|
79
|
+
{
|
|
80
|
+
LanguageId = _rhs.languageId;
|
|
81
|
+
SerialNumber = _rhs.serialNumber;
|
|
82
|
+
Manufacturer = _rhs.manufacturer;
|
|
83
|
+
Product = _rhs.product;
|
|
84
|
+
return (*this);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
operator Exchange::IUSBHub::ProductMetadata() const
|
|
88
|
+
{
|
|
89
|
+
Exchange::IUSBHub::ProductMetadata _value{};
|
|
90
|
+
_value.languageId = LanguageId;
|
|
91
|
+
_value.serialNumber = SerialNumber;
|
|
92
|
+
_value.manufacturer = Manufacturer;
|
|
93
|
+
_value.product = Product;
|
|
94
|
+
return (_value);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
~ProductMetadataInfo() = default;
|
|
98
|
+
|
|
99
|
+
public:
|
|
100
|
+
bool IsDataValid() const
|
|
101
|
+
{
|
|
102
|
+
return ((LanguageId.IsSet() == true) && (SerialNumber.IsSet() == true) && (Manufacturer.IsSet() == true) && (Product.IsSet() == true));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
private:
|
|
106
|
+
void _Init()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("languageId"), &LanguageId);
|
|
109
|
+
Add(_T("serialNumber"), &SerialNumber);
|
|
110
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
111
|
+
Add(_T("product"), &Product);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
public:
|
|
115
|
+
Core::JSON::DecUInt8 LanguageId; // language id present on the device
|
|
116
|
+
Core::JSON::String SerialNumber; // unicode string representing the serial number of the device
|
|
117
|
+
Core::JSON::String Manufacturer; // unicode string representing the manufacturer of the device
|
|
118
|
+
Core::JSON::String Product; // unicode string representing the product
|
|
119
|
+
}; // class ProductMetadataInfo
|
|
120
|
+
|
|
121
|
+
class DeviceMetadataInfo : public Core::JSON::Container {
|
|
122
|
+
public:
|
|
123
|
+
DeviceMetadataInfo()
|
|
124
|
+
: Core::JSON::Container()
|
|
125
|
+
{
|
|
126
|
+
_Init();
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
DeviceMetadataInfo(const DeviceMetadataInfo& _other)
|
|
130
|
+
: Core::JSON::Container()
|
|
131
|
+
, DeviceName(_other.DeviceName)
|
|
132
|
+
, ParentId(_other.ParentId)
|
|
133
|
+
, Status(_other.Status)
|
|
134
|
+
, DeviceLevel(_other.DeviceLevel)
|
|
135
|
+
, PortNumber(_other.PortNumber)
|
|
136
|
+
, Protocol(_other.Protocol)
|
|
137
|
+
, BusSpeed(_other.BusSpeed)
|
|
138
|
+
, SerialNumber(_other.SerialNumber)
|
|
139
|
+
, Flags(_other.Flags)
|
|
140
|
+
, VendorId(_other.VendorId)
|
|
141
|
+
, ProductId(_other.ProductId)
|
|
142
|
+
, DeviceClass(_other.DeviceClass)
|
|
143
|
+
, DeviceSubclass(_other.DeviceSubclass)
|
|
144
|
+
, DevicePath(_other.DevicePath)
|
|
145
|
+
, Features(_other.Features)
|
|
146
|
+
, NumLanguageIds(_other.NumLanguageIds)
|
|
147
|
+
, ProductInfo1(_other.ProductInfo1)
|
|
148
|
+
, ProductInfo2(_other.ProductInfo2)
|
|
149
|
+
, ProductInfo3(_other.ProductInfo3)
|
|
150
|
+
, ProductInfo4(_other.ProductInfo4)
|
|
151
|
+
{
|
|
152
|
+
_Init();
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
DeviceMetadataInfo(DeviceMetadataInfo&& _other) noexcept
|
|
156
|
+
: Core::JSON::Container()
|
|
157
|
+
, DeviceName(std::move(_other.DeviceName))
|
|
158
|
+
, ParentId(std::move(_other.ParentId))
|
|
159
|
+
, Status(std::move(_other.Status))
|
|
160
|
+
, DeviceLevel(std::move(_other.DeviceLevel))
|
|
161
|
+
, PortNumber(std::move(_other.PortNumber))
|
|
162
|
+
, Protocol(std::move(_other.Protocol))
|
|
163
|
+
, BusSpeed(std::move(_other.BusSpeed))
|
|
164
|
+
, SerialNumber(std::move(_other.SerialNumber))
|
|
165
|
+
, Flags(std::move(_other.Flags))
|
|
166
|
+
, VendorId(std::move(_other.VendorId))
|
|
167
|
+
, ProductId(std::move(_other.ProductId))
|
|
168
|
+
, DeviceClass(std::move(_other.DeviceClass))
|
|
169
|
+
, DeviceSubclass(std::move(_other.DeviceSubclass))
|
|
170
|
+
, DevicePath(std::move(_other.DevicePath))
|
|
171
|
+
, Features(std::move(_other.Features))
|
|
172
|
+
, NumLanguageIds(std::move(_other.NumLanguageIds))
|
|
173
|
+
, ProductInfo1(std::move(_other.ProductInfo1))
|
|
174
|
+
, ProductInfo2(std::move(_other.ProductInfo2))
|
|
175
|
+
, ProductInfo3(std::move(_other.ProductInfo3))
|
|
176
|
+
, ProductInfo4(std::move(_other.ProductInfo4))
|
|
177
|
+
{
|
|
178
|
+
_Init();
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
DeviceMetadataInfo(const Exchange::IUSBHub::DeviceMetadata& _other)
|
|
182
|
+
: Core::JSON::Container()
|
|
183
|
+
{
|
|
184
|
+
DeviceName = _other.deviceName;
|
|
185
|
+
ParentId = _other.parentId;
|
|
186
|
+
Status = _other.status;
|
|
187
|
+
DeviceLevel = _other.deviceLevel;
|
|
188
|
+
PortNumber = _other.portNumber;
|
|
189
|
+
Protocol = _other.protocol;
|
|
190
|
+
BusSpeed = _other.busSpeed;
|
|
191
|
+
SerialNumber = _other.serialNumber;
|
|
192
|
+
Flags = _other.flags;
|
|
193
|
+
VendorId = _other.vendorId;
|
|
194
|
+
ProductId = _other.productId;
|
|
195
|
+
DeviceClass = _other.deviceClass;
|
|
196
|
+
DeviceSubclass = _other.deviceSubclass;
|
|
197
|
+
DevicePath = _other.devicePath;
|
|
198
|
+
Features = _other.features;
|
|
199
|
+
NumLanguageIds = _other.numLanguageIds;
|
|
200
|
+
ProductInfo1.Set(true);
|
|
201
|
+
ProductInfo1 = _other.productInfo1;
|
|
202
|
+
ProductInfo2.Set(true);
|
|
203
|
+
ProductInfo2 = _other.productInfo2;
|
|
204
|
+
ProductInfo3.Set(true);
|
|
205
|
+
ProductInfo3 = _other.productInfo3;
|
|
206
|
+
ProductInfo4.Set(true);
|
|
207
|
+
ProductInfo4 = _other.productInfo4;
|
|
208
|
+
_Init();
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
DeviceMetadataInfo& operator=(const DeviceMetadataInfo& _rhs)
|
|
212
|
+
{
|
|
213
|
+
DeviceName = _rhs.DeviceName;
|
|
214
|
+
ParentId = _rhs.ParentId;
|
|
215
|
+
Status = _rhs.Status;
|
|
216
|
+
DeviceLevel = _rhs.DeviceLevel;
|
|
217
|
+
PortNumber = _rhs.PortNumber;
|
|
218
|
+
Protocol = _rhs.Protocol;
|
|
219
|
+
BusSpeed = _rhs.BusSpeed;
|
|
220
|
+
SerialNumber = _rhs.SerialNumber;
|
|
221
|
+
Flags = _rhs.Flags;
|
|
222
|
+
VendorId = _rhs.VendorId;
|
|
223
|
+
ProductId = _rhs.ProductId;
|
|
224
|
+
DeviceClass = _rhs.DeviceClass;
|
|
225
|
+
DeviceSubclass = _rhs.DeviceSubclass;
|
|
226
|
+
DevicePath = _rhs.DevicePath;
|
|
227
|
+
Features = _rhs.Features;
|
|
228
|
+
NumLanguageIds = _rhs.NumLanguageIds;
|
|
229
|
+
ProductInfo1 = _rhs.ProductInfo1;
|
|
230
|
+
ProductInfo2 = _rhs.ProductInfo2;
|
|
231
|
+
ProductInfo3 = _rhs.ProductInfo3;
|
|
232
|
+
ProductInfo4 = _rhs.ProductInfo4;
|
|
233
|
+
return (*this);
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
DeviceMetadataInfo& operator=(DeviceMetadataInfo&& _rhs) noexcept
|
|
237
|
+
{
|
|
238
|
+
DeviceName = std::move(_rhs.DeviceName);
|
|
239
|
+
ParentId = std::move(_rhs.ParentId);
|
|
240
|
+
Status = std::move(_rhs.Status);
|
|
241
|
+
DeviceLevel = std::move(_rhs.DeviceLevel);
|
|
242
|
+
PortNumber = std::move(_rhs.PortNumber);
|
|
243
|
+
Protocol = std::move(_rhs.Protocol);
|
|
244
|
+
BusSpeed = std::move(_rhs.BusSpeed);
|
|
245
|
+
SerialNumber = std::move(_rhs.SerialNumber);
|
|
246
|
+
Flags = std::move(_rhs.Flags);
|
|
247
|
+
VendorId = std::move(_rhs.VendorId);
|
|
248
|
+
ProductId = std::move(_rhs.ProductId);
|
|
249
|
+
DeviceClass = std::move(_rhs.DeviceClass);
|
|
250
|
+
DeviceSubclass = std::move(_rhs.DeviceSubclass);
|
|
251
|
+
DevicePath = std::move(_rhs.DevicePath);
|
|
252
|
+
Features = std::move(_rhs.Features);
|
|
253
|
+
NumLanguageIds = std::move(_rhs.NumLanguageIds);
|
|
254
|
+
ProductInfo1 = std::move(_rhs.ProductInfo1);
|
|
255
|
+
ProductInfo2 = std::move(_rhs.ProductInfo2);
|
|
256
|
+
ProductInfo3 = std::move(_rhs.ProductInfo3);
|
|
257
|
+
ProductInfo4 = std::move(_rhs.ProductInfo4);
|
|
258
|
+
return (*this);
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
DeviceMetadataInfo& operator=(const Exchange::IUSBHub::DeviceMetadata& _rhs)
|
|
262
|
+
{
|
|
263
|
+
DeviceName = _rhs.deviceName;
|
|
264
|
+
ParentId = _rhs.parentId;
|
|
265
|
+
Status = _rhs.status;
|
|
266
|
+
DeviceLevel = _rhs.deviceLevel;
|
|
267
|
+
PortNumber = _rhs.portNumber;
|
|
268
|
+
Protocol = _rhs.protocol;
|
|
269
|
+
BusSpeed = _rhs.busSpeed;
|
|
270
|
+
SerialNumber = _rhs.serialNumber;
|
|
271
|
+
Flags = _rhs.flags;
|
|
272
|
+
VendorId = _rhs.vendorId;
|
|
273
|
+
ProductId = _rhs.productId;
|
|
274
|
+
DeviceClass = _rhs.deviceClass;
|
|
275
|
+
DeviceSubclass = _rhs.deviceSubclass;
|
|
276
|
+
DevicePath = _rhs.devicePath;
|
|
277
|
+
Features = _rhs.features;
|
|
278
|
+
NumLanguageIds = _rhs.numLanguageIds;
|
|
279
|
+
ProductInfo1.Set(true);
|
|
280
|
+
ProductInfo1 = _rhs.productInfo1;
|
|
281
|
+
ProductInfo2.Set(true);
|
|
282
|
+
ProductInfo2 = _rhs.productInfo2;
|
|
283
|
+
ProductInfo3.Set(true);
|
|
284
|
+
ProductInfo3 = _rhs.productInfo3;
|
|
285
|
+
ProductInfo4.Set(true);
|
|
286
|
+
ProductInfo4 = _rhs.productInfo4;
|
|
287
|
+
return (*this);
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
operator Exchange::IUSBHub::DeviceMetadata() const
|
|
291
|
+
{
|
|
292
|
+
Exchange::IUSBHub::DeviceMetadata _value{};
|
|
293
|
+
_value.deviceName = DeviceName;
|
|
294
|
+
_value.parentId = ParentId;
|
|
295
|
+
_value.status = Status;
|
|
296
|
+
_value.deviceLevel = DeviceLevel;
|
|
297
|
+
_value.portNumber = PortNumber;
|
|
298
|
+
_value.protocol = Protocol;
|
|
299
|
+
_value.busSpeed = BusSpeed;
|
|
300
|
+
_value.serialNumber = SerialNumber;
|
|
301
|
+
_value.flags = Flags;
|
|
302
|
+
_value.vendorId = VendorId;
|
|
303
|
+
_value.productId = ProductId;
|
|
304
|
+
_value.deviceClass = DeviceClass;
|
|
305
|
+
_value.deviceSubclass = DeviceSubclass;
|
|
306
|
+
_value.devicePath = DevicePath;
|
|
307
|
+
_value.features = Features;
|
|
308
|
+
_value.numLanguageIds = NumLanguageIds;
|
|
309
|
+
_value.productInfo1 = ProductInfo1;
|
|
310
|
+
_value.productInfo2 = ProductInfo2;
|
|
311
|
+
_value.productInfo3 = ProductInfo3;
|
|
312
|
+
_value.productInfo4 = ProductInfo4;
|
|
313
|
+
return (_value);
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
~DeviceMetadataInfo() = default;
|
|
317
|
+
|
|
318
|
+
public:
|
|
319
|
+
bool IsDataValid() const
|
|
320
|
+
{
|
|
321
|
+
return ((DeviceName.IsSet() == true) && (ParentId.IsSet() == true) && (Status.IsSet() == true) && (DeviceLevel.IsSet() == true) && (PortNumber.IsSet() == true) && (Protocol.IsSet() == true) && (BusSpeed.IsSet() == true) && (SerialNumber.IsSet() == true) && (Flags.IsSet() == true) && (VendorId.IsSet() == true) && (ProductId.IsSet() == true) && (DeviceClass.IsSet() == true) && (DeviceSubclass.IsSet() == true) && (DevicePath.IsSet() == true) && (Features.IsSet() == true) && (NumLanguageIds.IsSet() == true) && ((ProductInfo1.IsSet() == true) && (ProductInfo1.IsDataValid() == true)) && ((ProductInfo2.IsSet() == true) && (ProductInfo2.IsDataValid() == true)) && ((ProductInfo3.IsSet() == true) && (ProductInfo3.IsDataValid() == true)) && ((ProductInfo4.IsSet() == true) && (ProductInfo4.IsDataValid() == true)));
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
private:
|
|
325
|
+
void _Init()
|
|
326
|
+
{
|
|
327
|
+
Add(_T("deviceName"), &DeviceName);
|
|
328
|
+
Add(_T("parentId"), &ParentId);
|
|
329
|
+
Add(_T("status"), &Status);
|
|
330
|
+
Add(_T("deviceLevel"), &DeviceLevel);
|
|
331
|
+
Add(_T("portNumber"), &PortNumber);
|
|
332
|
+
Add(_T("protocol"), &Protocol);
|
|
333
|
+
Add(_T("busSpeed"), &BusSpeed);
|
|
334
|
+
Add(_T("serialNumber"), &SerialNumber);
|
|
335
|
+
Add(_T("flags"), &Flags);
|
|
336
|
+
Add(_T("vendorId"), &VendorId);
|
|
337
|
+
Add(_T("productId"), &ProductId);
|
|
338
|
+
Add(_T("deviceClass"), &DeviceClass);
|
|
339
|
+
Add(_T("deviceSubclass"), &DeviceSubclass);
|
|
340
|
+
Add(_T("devicePath"), &DevicePath);
|
|
341
|
+
Add(_T("features"), &Features);
|
|
342
|
+
Add(_T("numLanguageIds"), &NumLanguageIds);
|
|
343
|
+
Add(_T("productInfo1"), &ProductInfo1);
|
|
344
|
+
Add(_T("productInfo2"), &ProductInfo2);
|
|
345
|
+
Add(_T("productInfo3"), &ProductInfo3);
|
|
346
|
+
Add(_T("productInfo4"), &ProductInfo4);
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
public:
|
|
350
|
+
Core::JSON::String DeviceName; // Name of the USB device
|
|
351
|
+
Core::JSON::DecUInt32 ParentId; // Parent Node ID of the device
|
|
352
|
+
Core::JSON::EnumType<Exchange::IUSBHub::Status> Status; // current device status
|
|
353
|
+
Core::JSON::DecUInt8 DeviceLevel; // device level
|
|
354
|
+
Core::JSON::DecUInt8 PortNumber; // port number of USB on which the device is attached
|
|
355
|
+
Core::JSON::DecUInt8 Protocol; // Protocol supported by the device
|
|
356
|
+
Core::JSON::EnumType<Exchange::IUSBHub::Speed> BusSpeed; // Speed of the device
|
|
357
|
+
Core::JSON::String SerialNumber; // Serial number of the device
|
|
358
|
+
Core::JSON::EnumType<Exchange::IUSBHub::Flags> Flags; // Flags of the device
|
|
359
|
+
Core::JSON::DecUInt16 VendorId; // the vendor Id assigned to this device
|
|
360
|
+
Core::JSON::DecUInt16 ProductId; // the product Id assigned to this device
|
|
361
|
+
Core::JSON::DecUInt8 DeviceClass; // USB class of the device as per USB specificiation
|
|
362
|
+
Core::JSON::DecUInt8 DeviceSubclass; // USB sub class of the device as per USB specificiation
|
|
363
|
+
Core::JSON::String DevicePath; // the path to be used for the USB device ex: /dev/sdX
|
|
364
|
+
Core::JSON::DecUInt32 Features; // Features supported by the device - reserved
|
|
365
|
+
Core::JSON::DecUInt8 NumLanguageIds; // number of language ids present on the device
|
|
366
|
+
ProductMetadataInfo ProductInfo1; // Get the metadata information about the name passed in the paramater.
|
|
367
|
+
ProductMetadataInfo ProductInfo2; // Get the metadata information about the name passed in the paramater.
|
|
368
|
+
ProductMetadataInfo ProductInfo3; // Get the metadata information about the name passed in the paramater.
|
|
369
|
+
ProductMetadataInfo ProductInfo4; // Get the metadata information about the name passed in the paramater.
|
|
370
|
+
}; // class DeviceMetadataInfo
|
|
371
|
+
|
|
372
|
+
class AnnounceParamsInfo : public Core::JSON::Container {
|
|
373
|
+
public:
|
|
374
|
+
AnnounceParamsInfo()
|
|
375
|
+
: Core::JSON::Container()
|
|
376
|
+
{
|
|
377
|
+
Add(_T("device"), &Device);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
AnnounceParamsInfo(const AnnounceParamsInfo&) = delete;
|
|
381
|
+
AnnounceParamsInfo(AnnounceParamsInfo&&) noexcept = delete;
|
|
382
|
+
|
|
383
|
+
AnnounceParamsInfo& operator=(const AnnounceParamsInfo&) = delete;
|
|
384
|
+
AnnounceParamsInfo& operator=(AnnounceParamsInfo&&) noexcept = delete;
|
|
385
|
+
|
|
386
|
+
~AnnounceParamsInfo() = default;
|
|
387
|
+
|
|
388
|
+
public:
|
|
389
|
+
bool IsDataValid() const
|
|
390
|
+
{
|
|
391
|
+
return ((Device.IsSet() == true) && (Device.IsDataValid() == true));
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
public:
|
|
395
|
+
DeviceMetadataInfo Device; // USB information of the plugged in device
|
|
396
|
+
}; // class AnnounceParamsInfo
|
|
397
|
+
|
|
398
|
+
// Method params/result classes
|
|
399
|
+
//
|
|
400
|
+
|
|
401
|
+
class DeviceParamsData : public Core::JSON::Container {
|
|
402
|
+
public:
|
|
403
|
+
DeviceParamsData()
|
|
404
|
+
: Core::JSON::Container()
|
|
405
|
+
{
|
|
406
|
+
Add(_T("deviceName"), &DeviceName);
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
DeviceParamsData(const DeviceParamsData&) = delete;
|
|
410
|
+
DeviceParamsData(DeviceParamsData&&) noexcept = delete;
|
|
411
|
+
|
|
412
|
+
DeviceParamsData& operator=(const DeviceParamsData&) = delete;
|
|
413
|
+
DeviceParamsData& operator=(DeviceParamsData&&) noexcept = delete;
|
|
414
|
+
|
|
415
|
+
~DeviceParamsData() = default;
|
|
416
|
+
|
|
417
|
+
public:
|
|
418
|
+
bool IsDataValid() const
|
|
419
|
+
{
|
|
420
|
+
return (DeviceName.IsSet() == true);
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
public:
|
|
424
|
+
Core::JSON::String DeviceName; // Name of the device
|
|
425
|
+
}; // class DeviceParamsData
|
|
426
|
+
|
|
427
|
+
class VendorDevicesParamsData : public Core::JSON::Container {
|
|
428
|
+
public:
|
|
429
|
+
VendorDevicesParamsData()
|
|
430
|
+
: Core::JSON::Container()
|
|
431
|
+
{
|
|
432
|
+
Add(_T("vendorId"), &VendorId);
|
|
433
|
+
Add(_T("productId"), &ProductId);
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
VendorDevicesParamsData(const VendorDevicesParamsData&) = delete;
|
|
437
|
+
VendorDevicesParamsData(VendorDevicesParamsData&&) noexcept = delete;
|
|
438
|
+
|
|
439
|
+
VendorDevicesParamsData& operator=(const VendorDevicesParamsData&) = delete;
|
|
440
|
+
VendorDevicesParamsData& operator=(VendorDevicesParamsData&&) noexcept = delete;
|
|
441
|
+
|
|
442
|
+
~VendorDevicesParamsData() = default;
|
|
443
|
+
|
|
444
|
+
public:
|
|
445
|
+
bool IsDataValid() const
|
|
446
|
+
{
|
|
447
|
+
return ((VendorId.IsSet() == true) && (ProductId.IsSet() == true));
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
public:
|
|
451
|
+
Core::JSON::DecUInt16 VendorId; // Get a string array defining all devices hooked up to this hub cmpliant to the given VendorId/ProductId
|
|
452
|
+
Core::JSON::DecUInt16 ProductId; // Get a string array defining all devices hooked up to this hub cmpliant to the given VendorId/ProductId
|
|
453
|
+
}; // class VendorDevicesParamsData
|
|
454
|
+
|
|
455
|
+
} // namespace USBHub
|
|
456
|
+
|
|
457
|
+
POP_WARNING()
|
|
458
|
+
|
|
459
|
+
} // namespace JsonData
|
|
460
|
+
|
|
461
|
+
// Enum conversion handlers
|
|
462
|
+
ENUM_CONVERSION_HANDLER(Exchange::IUSBHub::Status)
|
|
463
|
+
ENUM_CONVERSION_HANDLER(Exchange::IUSBHub::Speed)
|
|
464
|
+
ENUM_CONVERSION_HANDLER(Exchange::IUSBHub::Flags)
|
|
465
|
+
|
|
466
|
+
}
|
|
467
|
+
|
|
@@ -0,0 +1,264 @@
|
|
|
1
|
+
// C++ types for Catalog API.
|
|
2
|
+
// Generated automatically from 'IValuePoint.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IValuePoint.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ValuePoint {
|
|
18
|
+
|
|
19
|
+
namespace Catalog {
|
|
20
|
+
|
|
21
|
+
// Common classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class ActivatedParamsInfo : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
ActivatedParamsInfo()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
Add(_T("id"), &Id);
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
ActivatedParamsInfo(const ActivatedParamsInfo&) = delete;
|
|
33
|
+
ActivatedParamsInfo(ActivatedParamsInfo&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
ActivatedParamsInfo& operator=(const ActivatedParamsInfo&) = delete;
|
|
36
|
+
ActivatedParamsInfo& operator=(ActivatedParamsInfo&&) noexcept = delete;
|
|
37
|
+
|
|
38
|
+
~ActivatedParamsInfo() = default;
|
|
39
|
+
|
|
40
|
+
public:
|
|
41
|
+
bool IsDataValid() const
|
|
42
|
+
{
|
|
43
|
+
return (Id.IsSet() == true);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
public:
|
|
47
|
+
Core::JSON::String Id; // Id of the IValuePoint
|
|
48
|
+
}; // class ActivatedParamsInfo
|
|
49
|
+
|
|
50
|
+
class ResourceParamsInfo : public Core::JSON::Container {
|
|
51
|
+
public:
|
|
52
|
+
ResourceParamsInfo()
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
Add(_T("id"), &Id);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
ResourceParamsInfo(const ResourceParamsInfo&) = delete;
|
|
59
|
+
ResourceParamsInfo(ResourceParamsInfo&&) noexcept = delete;
|
|
60
|
+
|
|
61
|
+
ResourceParamsInfo& operator=(const ResourceParamsInfo&) = delete;
|
|
62
|
+
ResourceParamsInfo& operator=(ResourceParamsInfo&&) noexcept = delete;
|
|
63
|
+
|
|
64
|
+
~ResourceParamsInfo() = default;
|
|
65
|
+
|
|
66
|
+
public:
|
|
67
|
+
bool IsDataValid() const
|
|
68
|
+
{
|
|
69
|
+
return (Id.IsSet() == true);
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
public:
|
|
73
|
+
Core::JSON::DecUInt32 Id;
|
|
74
|
+
}; // class ResourceParamsInfo
|
|
75
|
+
|
|
76
|
+
// Method params/result classes
|
|
77
|
+
//
|
|
78
|
+
|
|
79
|
+
class InfoData : public Core::JSON::Container {
|
|
80
|
+
public:
|
|
81
|
+
InfoData()
|
|
82
|
+
: Core::JSON::Container()
|
|
83
|
+
{
|
|
84
|
+
_Init();
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
InfoData(const InfoData& _other)
|
|
88
|
+
: Core::JSON::Container()
|
|
89
|
+
, Base(_other.Base)
|
|
90
|
+
, Extended(_other.Extended)
|
|
91
|
+
, Type(_other.Type)
|
|
92
|
+
, Fraction(_other.Fraction)
|
|
93
|
+
, Manufacturer(_other.Manufacturer)
|
|
94
|
+
, Model(_other.Model)
|
|
95
|
+
, Communication(_other.Communication)
|
|
96
|
+
, Metadata(_other.Metadata)
|
|
97
|
+
{
|
|
98
|
+
_Init();
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
InfoData(InfoData&& _other) noexcept
|
|
102
|
+
: Core::JSON::Container()
|
|
103
|
+
, Base(std::move(_other.Base))
|
|
104
|
+
, Extended(std::move(_other.Extended))
|
|
105
|
+
, Type(std::move(_other.Type))
|
|
106
|
+
, Fraction(std::move(_other.Fraction))
|
|
107
|
+
, Manufacturer(std::move(_other.Manufacturer))
|
|
108
|
+
, Model(std::move(_other.Model))
|
|
109
|
+
, Communication(std::move(_other.Communication))
|
|
110
|
+
, Metadata(std::move(_other.Metadata))
|
|
111
|
+
{
|
|
112
|
+
_Init();
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
InfoData(const Exchange::IValuePoint::Info& _other)
|
|
116
|
+
: Core::JSON::Container()
|
|
117
|
+
{
|
|
118
|
+
Base = _other.base;
|
|
119
|
+
Extended = _other.extended;
|
|
120
|
+
Type = _other.type;
|
|
121
|
+
Fraction = _other.fraction;
|
|
122
|
+
Manufacturer = _other.manufacturer;
|
|
123
|
+
Model = _other.model;
|
|
124
|
+
Communication = _other.communication;
|
|
125
|
+
if (_other.metadata.IsSet() == true) {
|
|
126
|
+
Metadata = _other.metadata.Value();
|
|
127
|
+
}
|
|
128
|
+
_Init();
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
InfoData& operator=(const InfoData& _rhs)
|
|
132
|
+
{
|
|
133
|
+
Base = _rhs.Base;
|
|
134
|
+
Extended = _rhs.Extended;
|
|
135
|
+
Type = _rhs.Type;
|
|
136
|
+
Fraction = _rhs.Fraction;
|
|
137
|
+
Manufacturer = _rhs.Manufacturer;
|
|
138
|
+
Model = _rhs.Model;
|
|
139
|
+
Communication = _rhs.Communication;
|
|
140
|
+
if (_rhs.Metadata.IsSet() == true) {
|
|
141
|
+
Metadata = _rhs.Metadata;
|
|
142
|
+
}
|
|
143
|
+
return (*this);
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
InfoData& operator=(InfoData&& _rhs) noexcept
|
|
147
|
+
{
|
|
148
|
+
Base = std::move(_rhs.Base);
|
|
149
|
+
Extended = std::move(_rhs.Extended);
|
|
150
|
+
Type = std::move(_rhs.Type);
|
|
151
|
+
Fraction = std::move(_rhs.Fraction);
|
|
152
|
+
Manufacturer = std::move(_rhs.Manufacturer);
|
|
153
|
+
Model = std::move(_rhs.Model);
|
|
154
|
+
Communication = std::move(_rhs.Communication);
|
|
155
|
+
Metadata = std::move(_rhs.Metadata);
|
|
156
|
+
return (*this);
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
InfoData& operator=(const Exchange::IValuePoint::Info& _rhs)
|
|
160
|
+
{
|
|
161
|
+
Base = _rhs.base;
|
|
162
|
+
Extended = _rhs.extended;
|
|
163
|
+
Type = _rhs.type;
|
|
164
|
+
Fraction = _rhs.fraction;
|
|
165
|
+
Manufacturer = _rhs.manufacturer;
|
|
166
|
+
Model = _rhs.model;
|
|
167
|
+
Communication = _rhs.communication;
|
|
168
|
+
if (_rhs.metadata.IsSet() == true) {
|
|
169
|
+
Metadata = _rhs.metadata.Value();
|
|
170
|
+
}
|
|
171
|
+
return (*this);
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
operator Exchange::IValuePoint::Info() const
|
|
175
|
+
{
|
|
176
|
+
Exchange::IValuePoint::Info _value{};
|
|
177
|
+
_value.base = Base;
|
|
178
|
+
_value.extended = Extended;
|
|
179
|
+
_value.type = Type;
|
|
180
|
+
_value.fraction = Fraction;
|
|
181
|
+
_value.manufacturer = Manufacturer;
|
|
182
|
+
_value.model = Model;
|
|
183
|
+
_value.communication = Communication;
|
|
184
|
+
if (Metadata.IsSet() == true) {
|
|
185
|
+
_value.metadata = Metadata;
|
|
186
|
+
}
|
|
187
|
+
return (_value);
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
~InfoData() = default;
|
|
191
|
+
|
|
192
|
+
public:
|
|
193
|
+
bool IsDataValid() const
|
|
194
|
+
{
|
|
195
|
+
return ((Base.IsSet() == true) && (Extended.IsSet() == true) && (Type.IsSet() == true) && (Fraction.IsSet() == true) && (Manufacturer.IsSet() == true) && (Model.IsSet() == true) && (Communication.IsSet() == true));
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
private:
|
|
199
|
+
void _Init()
|
|
200
|
+
{
|
|
201
|
+
Add(_T("base"), &Base);
|
|
202
|
+
Add(_T("extended"), &Extended);
|
|
203
|
+
Add(_T("type"), &Type);
|
|
204
|
+
Add(_T("fraction"), &Fraction);
|
|
205
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
206
|
+
Add(_T("model"), &Model);
|
|
207
|
+
Add(_T("communication"), &Communication);
|
|
208
|
+
Add(_T("metadata"), &Metadata);
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
public:
|
|
212
|
+
Core::JSON::EnumType<Exchange::IValuePoint::basic> Base; // There most be more than meets the eye, report it as a JSON string.
|
|
213
|
+
Core::JSON::EnumType<Exchange::IValuePoint::specific> Extended; // There most be more than meets the eye, report it as a JSON string.
|
|
214
|
+
Core::JSON::EnumType<Exchange::IValuePoint::dimension> Type; // There most be more than meets the eye, report it as a JSON string.
|
|
215
|
+
Core::JSON::DecUInt8 Fraction; // There most be more than meets the eye, report it as a JSON string.
|
|
216
|
+
Core::JSON::String Manufacturer; // There most be more than meets the eye, report it as a JSON string.
|
|
217
|
+
Core::JSON::String Model; // There most be more than meets the eye, report it as a JSON string.
|
|
218
|
+
Core::JSON::EnumType<Exchange::IValuePoint::protocol> Communication; // There most be more than meets the eye, report it as a JSON string.
|
|
219
|
+
Core::JSON::String Metadata; // There most be more than meets the eye, report it as a JSON string.
|
|
220
|
+
}; // class InfoData
|
|
221
|
+
|
|
222
|
+
class ValueData : public Core::JSON::Container {
|
|
223
|
+
public:
|
|
224
|
+
ValueData()
|
|
225
|
+
: Core::JSON::Container()
|
|
226
|
+
{
|
|
227
|
+
Add(_T("value"), &Value);
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
ValueData(const ValueData&) = delete;
|
|
231
|
+
ValueData(ValueData&&) noexcept = delete;
|
|
232
|
+
|
|
233
|
+
ValueData& operator=(const ValueData&) = delete;
|
|
234
|
+
ValueData& operator=(ValueData&&) noexcept = delete;
|
|
235
|
+
|
|
236
|
+
~ValueData() = default;
|
|
237
|
+
|
|
238
|
+
public:
|
|
239
|
+
bool IsDataValid() const
|
|
240
|
+
{
|
|
241
|
+
return (Value.IsSet() == true);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
public:
|
|
245
|
+
Core::JSON::DecSInt32 Value; // The current value of this IValuePoint.
|
|
246
|
+
}; // class ValueData
|
|
247
|
+
|
|
248
|
+
} // namespace Catalog
|
|
249
|
+
|
|
250
|
+
} // namespace ValuePoint
|
|
251
|
+
|
|
252
|
+
POP_WARNING()
|
|
253
|
+
|
|
254
|
+
} // namespace JsonData
|
|
255
|
+
|
|
256
|
+
// Enum conversion handlers
|
|
257
|
+
ENUM_CONVERSION_HANDLER(Exchange::IValuePoint::condition)
|
|
258
|
+
ENUM_CONVERSION_HANDLER(Exchange::IValuePoint::basic)
|
|
259
|
+
ENUM_CONVERSION_HANDLER(Exchange::IValuePoint::specific)
|
|
260
|
+
ENUM_CONVERSION_HANDLER(Exchange::IValuePoint::dimension)
|
|
261
|
+
ENUM_CONVERSION_HANDLER(Exchange::IValuePoint::protocol)
|
|
262
|
+
|
|
263
|
+
}
|
|
264
|
+
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
// C++ types for VolumeControl API.
|
|
2
|
+
// Generated automatically from 'IVolumeControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IVolumeControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace VolumeControl {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class MutedParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
MutedParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("muted"), &Muted);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
MutedParamsData(const MutedParamsData&) = delete;
|
|
31
|
+
MutedParamsData(MutedParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
MutedParamsData& operator=(const MutedParamsData&) = delete;
|
|
34
|
+
MutedParamsData& operator=(MutedParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~MutedParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Muted.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::Boolean Muted; // New mute state (true: muted, false: un-muted)
|
|
46
|
+
}; // class MutedParamsData
|
|
47
|
+
|
|
48
|
+
class VolumeParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
VolumeParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("volume"), &Volume);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
VolumeParamsData(const VolumeParamsData&) = delete;
|
|
57
|
+
VolumeParamsData(VolumeParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
VolumeParamsData& operator=(const VolumeParamsData&) = delete;
|
|
60
|
+
VolumeParamsData& operator=(VolumeParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~VolumeParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Volume.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::DecUInt8 Volume; // New bolume level in percent
|
|
72
|
+
}; // class VolumeParamsData
|
|
73
|
+
|
|
74
|
+
} // namespace VolumeControl
|
|
75
|
+
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
|
|
78
|
+
} // namespace JsonData
|
|
79
|
+
|
|
80
|
+
}
|
|
81
|
+
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
// C++ types for WatchDog API.
|
|
2
|
+
// Generated automatically from 'IWatchDog.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IWatchDog.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace WatchDog {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class TouchParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
TouchParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("callsign"), &Callsign);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
TouchParamsData(const TouchParamsData&) = delete;
|
|
31
|
+
TouchParamsData(TouchParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
TouchParamsData& operator=(const TouchParamsData&) = delete;
|
|
34
|
+
TouchParamsData& operator=(TouchParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~TouchParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Callsign.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Callsign; // In case a specific watchdog needs to be padded pass the name of the callsign for which we want to touch.
|
|
46
|
+
}; // class TouchParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace WatchDog
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
// C++ types for WebBrowser API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace WebBrowser {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class BridgeQueryParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
BridgeQueryParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("message"), &Message);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
BridgeQueryParamsData(const BridgeQueryParamsData&) = delete;
|
|
31
|
+
BridgeQueryParamsData(BridgeQueryParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
BridgeQueryParamsData& operator=(const BridgeQueryParamsData&) = delete;
|
|
34
|
+
BridgeQueryParamsData& operator=(BridgeQueryParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~BridgeQueryParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Message.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Message; // Requested action
|
|
46
|
+
}; // class BridgeQueryParamsData
|
|
47
|
+
|
|
48
|
+
class LoadFailedParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
LoadFailedParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("url"), &URL);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
LoadFailedParamsData(const LoadFailedParamsData&) = delete;
|
|
57
|
+
LoadFailedParamsData(LoadFailedParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
LoadFailedParamsData& operator=(const LoadFailedParamsData&) = delete;
|
|
60
|
+
LoadFailedParamsData& operator=(LoadFailedParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~LoadFailedParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (URL.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String URL; // The URL that has been failed to load
|
|
72
|
+
}; // class LoadFailedParamsData
|
|
73
|
+
|
|
74
|
+
class LoadFinishedParamsData : public Core::JSON::Container {
|
|
75
|
+
public:
|
|
76
|
+
LoadFinishedParamsData()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
Add(_T("url"), &URL);
|
|
80
|
+
Add(_T("httpstatus"), &Httpstatus);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
LoadFinishedParamsData(const LoadFinishedParamsData&) = delete;
|
|
84
|
+
LoadFinishedParamsData(LoadFinishedParamsData&&) noexcept = delete;
|
|
85
|
+
|
|
86
|
+
LoadFinishedParamsData& operator=(const LoadFinishedParamsData&) = delete;
|
|
87
|
+
LoadFinishedParamsData& operator=(LoadFinishedParamsData&&) noexcept = delete;
|
|
88
|
+
|
|
89
|
+
~LoadFinishedParamsData() = default;
|
|
90
|
+
|
|
91
|
+
public:
|
|
92
|
+
bool IsDataValid() const
|
|
93
|
+
{
|
|
94
|
+
return ((URL.IsSet() == true) && (Httpstatus.IsSet() == true));
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
public:
|
|
98
|
+
Core::JSON::String URL; // The URL that has been loaded
|
|
99
|
+
Core::JSON::DecSInt32 Httpstatus; // The response code of main resource request
|
|
100
|
+
}; // class LoadFinishedParamsData
|
|
101
|
+
|
|
102
|
+
class URLChangeParamsData : public Core::JSON::Container {
|
|
103
|
+
public:
|
|
104
|
+
URLChangeParamsData()
|
|
105
|
+
: Core::JSON::Container()
|
|
106
|
+
{
|
|
107
|
+
Add(_T("url"), &URL);
|
|
108
|
+
Add(_T("loaded"), &Loaded);
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
URLChangeParamsData(const URLChangeParamsData&) = delete;
|
|
112
|
+
URLChangeParamsData(URLChangeParamsData&&) noexcept = delete;
|
|
113
|
+
|
|
114
|
+
URLChangeParamsData& operator=(const URLChangeParamsData&) = delete;
|
|
115
|
+
URLChangeParamsData& operator=(URLChangeParamsData&&) noexcept = delete;
|
|
116
|
+
|
|
117
|
+
~URLChangeParamsData() = default;
|
|
118
|
+
|
|
119
|
+
public:
|
|
120
|
+
bool IsDataValid() const
|
|
121
|
+
{
|
|
122
|
+
return ((URL.IsSet() == true) && (Loaded.IsSet() == true));
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
public:
|
|
126
|
+
Core::JSON::String URL; // The URL that has been loaded or requested
|
|
127
|
+
Core::JSON::Boolean Loaded; // Loaded (true) or not (false)
|
|
128
|
+
}; // class URLChangeParamsData
|
|
129
|
+
|
|
130
|
+
class VisibilityChangeParamsData : public Core::JSON::Container {
|
|
131
|
+
public:
|
|
132
|
+
VisibilityChangeParamsData()
|
|
133
|
+
: Core::JSON::Container()
|
|
134
|
+
{
|
|
135
|
+
Add(_T("hidden"), &Hidden);
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
VisibilityChangeParamsData(const VisibilityChangeParamsData&) = delete;
|
|
139
|
+
VisibilityChangeParamsData(VisibilityChangeParamsData&&) noexcept = delete;
|
|
140
|
+
|
|
141
|
+
VisibilityChangeParamsData& operator=(const VisibilityChangeParamsData&) = delete;
|
|
142
|
+
VisibilityChangeParamsData& operator=(VisibilityChangeParamsData&&) noexcept = delete;
|
|
143
|
+
|
|
144
|
+
~VisibilityChangeParamsData() = default;
|
|
145
|
+
|
|
146
|
+
public:
|
|
147
|
+
bool IsDataValid() const
|
|
148
|
+
{
|
|
149
|
+
return (Hidden.IsSet() == true);
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
public:
|
|
153
|
+
Core::JSON::Boolean Hidden; // Hidden (true) or Visible (false)
|
|
154
|
+
}; // class VisibilityChangeParamsData
|
|
155
|
+
|
|
156
|
+
} // namespace WebBrowser
|
|
157
|
+
|
|
158
|
+
POP_WARNING()
|
|
159
|
+
|
|
160
|
+
} // namespace JsonData
|
|
161
|
+
|
|
162
|
+
// Enum conversion handlers
|
|
163
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
164
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
165
|
+
|
|
166
|
+
}
|
|
167
|
+
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
// C++ types for WebBrowserExt API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IBrowser.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace WebBrowserExt {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class DeleteDirParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
DeleteDirParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("path"), &Path);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
DeleteDirParamsData(const DeleteDirParamsData&) = delete;
|
|
31
|
+
DeleteDirParamsData(DeleteDirParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
DeleteDirParamsData& operator=(const DeleteDirParamsData&) = delete;
|
|
34
|
+
DeleteDirParamsData& operator=(DeleteDirParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~DeleteDirParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Path.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Path; // Path to directory (within the persistent storage) to delete contents of
|
|
46
|
+
}; // class DeleteDirParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace WebBrowserExt
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
// Enum conversion handlers
|
|
55
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::VisibilityType)
|
|
56
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
57
|
+
|
|
58
|
+
}
|
|
59
|
+
|
|
@@ -0,0 +1,509 @@
|
|
|
1
|
+
// C++ types for WifiControl API.
|
|
2
|
+
// Generated automatically from 'IWifiControl.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IWifiControl.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace WifiControl {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class ConfigInfoInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
ConfigInfoInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
ConfigInfoInfo(const ConfigInfoInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, Hidden(_other.Hidden)
|
|
33
|
+
, Accesspoint(_other.Accesspoint)
|
|
34
|
+
, Ssid(_other.Ssid)
|
|
35
|
+
, Secret(_other.Secret)
|
|
36
|
+
, Identity(_other.Identity)
|
|
37
|
+
, Method(_other.Method)
|
|
38
|
+
, Key(_other.Key)
|
|
39
|
+
{
|
|
40
|
+
_Init();
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
ConfigInfoInfo(ConfigInfoInfo&& _other) noexcept
|
|
44
|
+
: Core::JSON::Container()
|
|
45
|
+
, Hidden(std::move(_other.Hidden))
|
|
46
|
+
, Accesspoint(std::move(_other.Accesspoint))
|
|
47
|
+
, Ssid(std::move(_other.Ssid))
|
|
48
|
+
, Secret(std::move(_other.Secret))
|
|
49
|
+
, Identity(std::move(_other.Identity))
|
|
50
|
+
, Method(std::move(_other.Method))
|
|
51
|
+
, Key(std::move(_other.Key))
|
|
52
|
+
{
|
|
53
|
+
_Init();
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
ConfigInfoInfo(const Exchange::IWifiControl::ConfigInfo& _other)
|
|
57
|
+
: Core::JSON::Container()
|
|
58
|
+
{
|
|
59
|
+
Hidden = _other.hidden;
|
|
60
|
+
Accesspoint = _other.accesspoint;
|
|
61
|
+
if (_other.ssid.IsSet() == true) {
|
|
62
|
+
Ssid = _other.ssid.Value();
|
|
63
|
+
}
|
|
64
|
+
if (_other.secret.IsSet() == true) {
|
|
65
|
+
Secret = _other.secret.Value();
|
|
66
|
+
}
|
|
67
|
+
if (_other.identity.IsSet() == true) {
|
|
68
|
+
Identity = _other.identity.Value();
|
|
69
|
+
}
|
|
70
|
+
Method = _other.method;
|
|
71
|
+
if (_other.key.IsSet() == true) {
|
|
72
|
+
Key = _other.key.Value();
|
|
73
|
+
}
|
|
74
|
+
_Init();
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
ConfigInfoInfo& operator=(const ConfigInfoInfo& _rhs)
|
|
78
|
+
{
|
|
79
|
+
Hidden = _rhs.Hidden;
|
|
80
|
+
Accesspoint = _rhs.Accesspoint;
|
|
81
|
+
if (_rhs.Ssid.IsSet() == true) {
|
|
82
|
+
Ssid = _rhs.Ssid;
|
|
83
|
+
}
|
|
84
|
+
if (_rhs.Secret.IsSet() == true) {
|
|
85
|
+
Secret = _rhs.Secret;
|
|
86
|
+
}
|
|
87
|
+
if (_rhs.Identity.IsSet() == true) {
|
|
88
|
+
Identity = _rhs.Identity;
|
|
89
|
+
}
|
|
90
|
+
Method = _rhs.Method;
|
|
91
|
+
if (_rhs.Key.IsSet() == true) {
|
|
92
|
+
Key = _rhs.Key;
|
|
93
|
+
}
|
|
94
|
+
return (*this);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
ConfigInfoInfo& operator=(ConfigInfoInfo&& _rhs) noexcept
|
|
98
|
+
{
|
|
99
|
+
Hidden = std::move(_rhs.Hidden);
|
|
100
|
+
Accesspoint = std::move(_rhs.Accesspoint);
|
|
101
|
+
Ssid = std::move(_rhs.Ssid);
|
|
102
|
+
Secret = std::move(_rhs.Secret);
|
|
103
|
+
Identity = std::move(_rhs.Identity);
|
|
104
|
+
Method = std::move(_rhs.Method);
|
|
105
|
+
Key = std::move(_rhs.Key);
|
|
106
|
+
return (*this);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
ConfigInfoInfo& operator=(const Exchange::IWifiControl::ConfigInfo& _rhs)
|
|
110
|
+
{
|
|
111
|
+
Hidden = _rhs.hidden;
|
|
112
|
+
Accesspoint = _rhs.accesspoint;
|
|
113
|
+
if (_rhs.ssid.IsSet() == true) {
|
|
114
|
+
Ssid = _rhs.ssid.Value();
|
|
115
|
+
}
|
|
116
|
+
if (_rhs.secret.IsSet() == true) {
|
|
117
|
+
Secret = _rhs.secret.Value();
|
|
118
|
+
}
|
|
119
|
+
if (_rhs.identity.IsSet() == true) {
|
|
120
|
+
Identity = _rhs.identity.Value();
|
|
121
|
+
}
|
|
122
|
+
Method = _rhs.method;
|
|
123
|
+
if (_rhs.key.IsSet() == true) {
|
|
124
|
+
Key = _rhs.key.Value();
|
|
125
|
+
}
|
|
126
|
+
return (*this);
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
operator Exchange::IWifiControl::ConfigInfo() const
|
|
130
|
+
{
|
|
131
|
+
Exchange::IWifiControl::ConfigInfo _value{};
|
|
132
|
+
_value.hidden = Hidden;
|
|
133
|
+
_value.accesspoint = Accesspoint;
|
|
134
|
+
if (Ssid.IsSet() == true) {
|
|
135
|
+
_value.ssid = Ssid;
|
|
136
|
+
}
|
|
137
|
+
if (Secret.IsSet() == true) {
|
|
138
|
+
_value.secret = Secret;
|
|
139
|
+
}
|
|
140
|
+
if (Identity.IsSet() == true) {
|
|
141
|
+
_value.identity = Identity;
|
|
142
|
+
}
|
|
143
|
+
_value.method = Method;
|
|
144
|
+
if (Key.IsSet() == true) {
|
|
145
|
+
_value.key = Key;
|
|
146
|
+
}
|
|
147
|
+
return (_value);
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
~ConfigInfoInfo() = default;
|
|
151
|
+
|
|
152
|
+
public:
|
|
153
|
+
bool IsDataValid() const
|
|
154
|
+
{
|
|
155
|
+
return ((Hidden.IsSet() == true) && (Accesspoint.IsSet() == true) && (Method.IsSet() == true));
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
private:
|
|
159
|
+
void _Init()
|
|
160
|
+
{
|
|
161
|
+
Add(_T("hidden"), &Hidden);
|
|
162
|
+
Add(_T("accesspoint"), &Accesspoint);
|
|
163
|
+
Add(_T("ssid"), &Ssid);
|
|
164
|
+
Add(_T("secret"), &Secret);
|
|
165
|
+
Add(_T("identity"), &Identity);
|
|
166
|
+
Add(_T("method"), &Method);
|
|
167
|
+
Add(_T("key"), &Key);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
public:
|
|
171
|
+
Core::JSON::Boolean Hidden; // Visibility of the router (hidden or visible)
|
|
172
|
+
Core::JSON::Boolean Accesspoint; // Accesspoint or not
|
|
173
|
+
Core::JSON::String Ssid; // SSID of the router/ap
|
|
174
|
+
Core::JSON::String Secret; // Secret key used
|
|
175
|
+
Core::JSON::String Identity; // Identity
|
|
176
|
+
Core::JSON::EnumType<Exchange::IWifiControl::Security> Method; // Security method
|
|
177
|
+
Core::JSON::EnumType<Exchange::IWifiControl::SecurityInfo::Key> Key; // Security Info: method and keys
|
|
178
|
+
}; // class ConfigInfoInfo
|
|
179
|
+
|
|
180
|
+
class ConnectParamsInfo : public Core::JSON::Container {
|
|
181
|
+
public:
|
|
182
|
+
ConnectParamsInfo()
|
|
183
|
+
: Core::JSON::Container()
|
|
184
|
+
{
|
|
185
|
+
Add(_T("configssid"), &ConfigSSID);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
ConnectParamsInfo(const ConnectParamsInfo&) = delete;
|
|
189
|
+
ConnectParamsInfo(ConnectParamsInfo&&) noexcept = delete;
|
|
190
|
+
|
|
191
|
+
ConnectParamsInfo& operator=(const ConnectParamsInfo&) = delete;
|
|
192
|
+
ConnectParamsInfo& operator=(ConnectParamsInfo&&) noexcept = delete;
|
|
193
|
+
|
|
194
|
+
~ConnectParamsInfo() = default;
|
|
195
|
+
|
|
196
|
+
public:
|
|
197
|
+
bool IsDataValid() const
|
|
198
|
+
{
|
|
199
|
+
return (ConfigSSID.IsSet() == true);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
public:
|
|
203
|
+
Core::JSON::String ConfigSSID; // SSID to be connected
|
|
204
|
+
}; // class ConnectParamsInfo
|
|
205
|
+
|
|
206
|
+
// Method params/result classes
|
|
207
|
+
//
|
|
208
|
+
|
|
209
|
+
class ConfigData : public Core::JSON::Container {
|
|
210
|
+
public:
|
|
211
|
+
ConfigData()
|
|
212
|
+
: Core::JSON::Container()
|
|
213
|
+
{
|
|
214
|
+
Add(_T("value"), &Value);
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
ConfigData(const ConfigData&) = delete;
|
|
218
|
+
ConfigData(ConfigData&&) noexcept = delete;
|
|
219
|
+
|
|
220
|
+
ConfigData& operator=(const ConfigData&) = delete;
|
|
221
|
+
ConfigData& operator=(ConfigData&&) noexcept = delete;
|
|
222
|
+
|
|
223
|
+
~ConfigData() = default;
|
|
224
|
+
|
|
225
|
+
public:
|
|
226
|
+
bool IsDataValid() const
|
|
227
|
+
{
|
|
228
|
+
return ((Value.IsSet() == true) && (Value.IsDataValid() == true));
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
public:
|
|
232
|
+
ConfigInfoInfo Value; // Provide config details for requested SSID
|
|
233
|
+
}; // class ConfigData
|
|
234
|
+
|
|
235
|
+
class ConnectionChangeParamsData : public Core::JSON::Container {
|
|
236
|
+
public:
|
|
237
|
+
ConnectionChangeParamsData()
|
|
238
|
+
: Core::JSON::Container()
|
|
239
|
+
{
|
|
240
|
+
Add(_T("ssid"), &Ssid);
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
ConnectionChangeParamsData(const ConnectionChangeParamsData&) = delete;
|
|
244
|
+
ConnectionChangeParamsData(ConnectionChangeParamsData&&) noexcept = delete;
|
|
245
|
+
|
|
246
|
+
ConnectionChangeParamsData& operator=(const ConnectionChangeParamsData&) = delete;
|
|
247
|
+
ConnectionChangeParamsData& operator=(ConnectionChangeParamsData&&) noexcept = delete;
|
|
248
|
+
|
|
249
|
+
~ConnectionChangeParamsData() = default;
|
|
250
|
+
|
|
251
|
+
public:
|
|
252
|
+
bool IsDataValid() const
|
|
253
|
+
{
|
|
254
|
+
return (Ssid.IsSet() == true);
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
public:
|
|
258
|
+
Core::JSON::String Ssid; // SSID of connection changed network
|
|
259
|
+
}; // class ConnectionChangeParamsData
|
|
260
|
+
|
|
261
|
+
class NetworkInfoData : public Core::JSON::Container {
|
|
262
|
+
public:
|
|
263
|
+
NetworkInfoData()
|
|
264
|
+
: Core::JSON::Container()
|
|
265
|
+
{
|
|
266
|
+
_Init();
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
NetworkInfoData(const NetworkInfoData& _other)
|
|
270
|
+
: Core::JSON::Container()
|
|
271
|
+
, Ssid(_other.Ssid)
|
|
272
|
+
, Bssid(_other.Bssid)
|
|
273
|
+
, Frequency(_other.Frequency)
|
|
274
|
+
, Signal(_other.Signal)
|
|
275
|
+
, Security(_other.Security)
|
|
276
|
+
{
|
|
277
|
+
_Init();
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
NetworkInfoData(NetworkInfoData&& _other) noexcept
|
|
281
|
+
: Core::JSON::Container()
|
|
282
|
+
, Ssid(std::move(_other.Ssid))
|
|
283
|
+
, Bssid(std::move(_other.Bssid))
|
|
284
|
+
, Frequency(std::move(_other.Frequency))
|
|
285
|
+
, Signal(std::move(_other.Signal))
|
|
286
|
+
, Security(std::move(_other.Security))
|
|
287
|
+
{
|
|
288
|
+
_Init();
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
NetworkInfoData(const Exchange::IWifiControl::NetworkInfo& _other)
|
|
292
|
+
: Core::JSON::Container()
|
|
293
|
+
{
|
|
294
|
+
if (_other.ssid.IsSet() == true) {
|
|
295
|
+
Ssid = _other.ssid.Value();
|
|
296
|
+
}
|
|
297
|
+
Bssid = _other.bssid;
|
|
298
|
+
Frequency = _other.frequency;
|
|
299
|
+
Signal = _other.signal;
|
|
300
|
+
Security.Set(true);
|
|
301
|
+
Security = _other.security;
|
|
302
|
+
_Init();
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
NetworkInfoData& operator=(const NetworkInfoData& _rhs)
|
|
306
|
+
{
|
|
307
|
+
if (_rhs.Ssid.IsSet() == true) {
|
|
308
|
+
Ssid = _rhs.Ssid;
|
|
309
|
+
}
|
|
310
|
+
Bssid = _rhs.Bssid;
|
|
311
|
+
Frequency = _rhs.Frequency;
|
|
312
|
+
Signal = _rhs.Signal;
|
|
313
|
+
Security = _rhs.Security;
|
|
314
|
+
return (*this);
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
NetworkInfoData& operator=(NetworkInfoData&& _rhs) noexcept
|
|
318
|
+
{
|
|
319
|
+
Ssid = std::move(_rhs.Ssid);
|
|
320
|
+
Bssid = std::move(_rhs.Bssid);
|
|
321
|
+
Frequency = std::move(_rhs.Frequency);
|
|
322
|
+
Signal = std::move(_rhs.Signal);
|
|
323
|
+
Security = std::move(_rhs.Security);
|
|
324
|
+
return (*this);
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
NetworkInfoData& operator=(const Exchange::IWifiControl::NetworkInfo& _rhs)
|
|
328
|
+
{
|
|
329
|
+
if (_rhs.ssid.IsSet() == true) {
|
|
330
|
+
Ssid = _rhs.ssid.Value();
|
|
331
|
+
}
|
|
332
|
+
Bssid = _rhs.bssid;
|
|
333
|
+
Frequency = _rhs.frequency;
|
|
334
|
+
Signal = _rhs.signal;
|
|
335
|
+
Security.Set(true);
|
|
336
|
+
Security = _rhs.security;
|
|
337
|
+
return (*this);
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
operator Exchange::IWifiControl::NetworkInfo() const
|
|
341
|
+
{
|
|
342
|
+
Exchange::IWifiControl::NetworkInfo _value{};
|
|
343
|
+
if (Ssid.IsSet() == true) {
|
|
344
|
+
_value.ssid = Ssid;
|
|
345
|
+
}
|
|
346
|
+
_value.bssid = Bssid;
|
|
347
|
+
_value.frequency = Frequency;
|
|
348
|
+
_value.signal = Signal;
|
|
349
|
+
_value.security = Security;
|
|
350
|
+
return (_value);
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
~NetworkInfoData() = default;
|
|
354
|
+
|
|
355
|
+
public:
|
|
356
|
+
bool IsDataValid() const
|
|
357
|
+
{
|
|
358
|
+
return ((Bssid.IsSet() == true) && (Frequency.IsSet() == true) && (Signal.IsSet() == true) && (Security.IsSet() == true));
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
private:
|
|
362
|
+
void _Init()
|
|
363
|
+
{
|
|
364
|
+
Add(_T("ssid"), &Ssid);
|
|
365
|
+
Add(_T("bssid"), &Bssid);
|
|
366
|
+
Add(_T("frequency"), &Frequency);
|
|
367
|
+
Add(_T("signal"), &Signal);
|
|
368
|
+
Add(_T("security"), &Security);
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
public:
|
|
372
|
+
Core::JSON::String Ssid; // SSID of the network
|
|
373
|
+
Core::JSON::DecUInt64 Bssid; // BSSID of the network
|
|
374
|
+
Core::JSON::DecUInt32 Frequency; // Frequency used
|
|
375
|
+
Core::JSON::DecSInt32 Signal; // Signal strength
|
|
376
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IWifiControl::Security>> Security; // Security method
|
|
377
|
+
}; // class NetworkInfoData
|
|
378
|
+
|
|
379
|
+
class SecurityInfoData : public Core::JSON::Container {
|
|
380
|
+
public:
|
|
381
|
+
SecurityInfoData()
|
|
382
|
+
: Core::JSON::Container()
|
|
383
|
+
{
|
|
384
|
+
_Init();
|
|
385
|
+
}
|
|
386
|
+
|
|
387
|
+
SecurityInfoData(const SecurityInfoData& _other)
|
|
388
|
+
: Core::JSON::Container()
|
|
389
|
+
, Method(_other.Method)
|
|
390
|
+
, Keys(_other.Keys)
|
|
391
|
+
{
|
|
392
|
+
_Init();
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
SecurityInfoData(SecurityInfoData&& _other) noexcept
|
|
396
|
+
: Core::JSON::Container()
|
|
397
|
+
, Method(std::move(_other.Method))
|
|
398
|
+
, Keys(std::move(_other.Keys))
|
|
399
|
+
{
|
|
400
|
+
_Init();
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
SecurityInfoData(const Exchange::IWifiControl::SecurityInfo& _other)
|
|
404
|
+
: Core::JSON::Container()
|
|
405
|
+
{
|
|
406
|
+
Method = _other.method;
|
|
407
|
+
if (_other.keys.IsSet() == true) {
|
|
408
|
+
Keys.Set(true);
|
|
409
|
+
Keys = _other.keys.Value();
|
|
410
|
+
}
|
|
411
|
+
_Init();
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
SecurityInfoData& operator=(const SecurityInfoData& _rhs)
|
|
415
|
+
{
|
|
416
|
+
Method = _rhs.Method;
|
|
417
|
+
if (_rhs.Keys.IsSet() == true) {
|
|
418
|
+
Keys = _rhs.Keys;
|
|
419
|
+
}
|
|
420
|
+
return (*this);
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
SecurityInfoData& operator=(SecurityInfoData&& _rhs) noexcept
|
|
424
|
+
{
|
|
425
|
+
Method = std::move(_rhs.Method);
|
|
426
|
+
Keys = std::move(_rhs.Keys);
|
|
427
|
+
return (*this);
|
|
428
|
+
}
|
|
429
|
+
|
|
430
|
+
SecurityInfoData& operator=(const Exchange::IWifiControl::SecurityInfo& _rhs)
|
|
431
|
+
{
|
|
432
|
+
Method = _rhs.method;
|
|
433
|
+
if (_rhs.keys.IsSet() == true) {
|
|
434
|
+
Keys.Set(true);
|
|
435
|
+
Keys = _rhs.keys.Value();
|
|
436
|
+
}
|
|
437
|
+
return (*this);
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
operator Exchange::IWifiControl::SecurityInfo() const
|
|
441
|
+
{
|
|
442
|
+
Exchange::IWifiControl::SecurityInfo _value{};
|
|
443
|
+
_value.method = Method;
|
|
444
|
+
if (Keys.IsSet() == true) {
|
|
445
|
+
_value.keys = Keys;
|
|
446
|
+
}
|
|
447
|
+
return (_value);
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
~SecurityInfoData() = default;
|
|
451
|
+
|
|
452
|
+
public:
|
|
453
|
+
bool IsDataValid() const
|
|
454
|
+
{
|
|
455
|
+
return (Method.IsSet() == true);
|
|
456
|
+
}
|
|
457
|
+
|
|
458
|
+
private:
|
|
459
|
+
void _Init()
|
|
460
|
+
{
|
|
461
|
+
Add(_T("method"), &Method);
|
|
462
|
+
Add(_T("keys"), &Keys);
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
public:
|
|
466
|
+
Core::JSON::EnumType<Exchange::IWifiControl::Security> Method; // Security method
|
|
467
|
+
Core::JSON::ArrayType<Core::JSON::EnumType<Exchange::IWifiControl::SecurityInfo::Key>> Keys; // Security Keys
|
|
468
|
+
}; // class SecurityInfoData
|
|
469
|
+
|
|
470
|
+
class StatusResultData : public Core::JSON::Container {
|
|
471
|
+
public:
|
|
472
|
+
StatusResultData()
|
|
473
|
+
: Core::JSON::Container()
|
|
474
|
+
{
|
|
475
|
+
Add(_T("connectedssid"), &ConnectedSsid);
|
|
476
|
+
Add(_T("isscanning"), &IsScanning);
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
StatusResultData(const StatusResultData&) = delete;
|
|
480
|
+
StatusResultData(StatusResultData&&) noexcept = delete;
|
|
481
|
+
|
|
482
|
+
StatusResultData& operator=(const StatusResultData&) = delete;
|
|
483
|
+
StatusResultData& operator=(StatusResultData&&) noexcept = delete;
|
|
484
|
+
|
|
485
|
+
~StatusResultData() = default;
|
|
486
|
+
|
|
487
|
+
public:
|
|
488
|
+
bool IsDataValid() const
|
|
489
|
+
{
|
|
490
|
+
return ((ConnectedSsid.IsSet() == true) && (IsScanning.IsSet() == true));
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
public:
|
|
494
|
+
Core::JSON::String ConnectedSsid; // SSID of connected router/ap
|
|
495
|
+
Core::JSON::Boolean IsScanning; // Scanning is in progress or not
|
|
496
|
+
}; // class StatusResultData
|
|
497
|
+
|
|
498
|
+
} // namespace WifiControl
|
|
499
|
+
|
|
500
|
+
POP_WARNING()
|
|
501
|
+
|
|
502
|
+
} // namespace JsonData
|
|
503
|
+
|
|
504
|
+
// Enum conversion handlers
|
|
505
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWifiControl::Security)
|
|
506
|
+
ENUM_CONVERSION_HANDLER(Exchange::IWifiControl::SecurityInfo::Key)
|
|
507
|
+
|
|
508
|
+
}
|
|
509
|
+
|
|
@@ -0,0 +1,314 @@
|
|
|
1
|
+
// C++ types for ZigWave API.
|
|
2
|
+
// Generated automatically from 'IZigWave.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <interfaces/IZigWave.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ZigWave {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class BindParamsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
BindParamsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("source"), &Source);
|
|
28
|
+
Add(_T("destination"), &Destination);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
BindParamsInfo(const BindParamsInfo&) = delete;
|
|
32
|
+
BindParamsInfo(BindParamsInfo&&) noexcept = delete;
|
|
33
|
+
|
|
34
|
+
BindParamsInfo& operator=(const BindParamsInfo&) = delete;
|
|
35
|
+
BindParamsInfo& operator=(BindParamsInfo&&) noexcept = delete;
|
|
36
|
+
|
|
37
|
+
~BindParamsInfo() = default;
|
|
38
|
+
|
|
39
|
+
public:
|
|
40
|
+
bool IsDataValid() const
|
|
41
|
+
{
|
|
42
|
+
return ((Source.IsSet() == true) && (Destination.IsSet() == true));
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
public:
|
|
46
|
+
Core::JSON::DecUInt32 Source; // Source to be bound
|
|
47
|
+
Core::JSON::DecUInt32 Destination; // Destination to be bound
|
|
48
|
+
}; // class BindParamsInfo
|
|
49
|
+
|
|
50
|
+
// Method params/result classes
|
|
51
|
+
//
|
|
52
|
+
|
|
53
|
+
class DeviceData : public Core::JSON::Container {
|
|
54
|
+
public:
|
|
55
|
+
DeviceData()
|
|
56
|
+
: Core::JSON::Container()
|
|
57
|
+
{
|
|
58
|
+
_Init();
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
DeviceData(const DeviceData& _other)
|
|
62
|
+
: Core::JSON::Container()
|
|
63
|
+
, Parent(_other.Parent)
|
|
64
|
+
, Address(_other.Address)
|
|
65
|
+
, Type(_other.Type)
|
|
66
|
+
, Manufacturer(_other.Manufacturer)
|
|
67
|
+
, Metadata(_other.Metadata)
|
|
68
|
+
{
|
|
69
|
+
_Init();
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
DeviceData(DeviceData&& _other) noexcept
|
|
73
|
+
: Core::JSON::Container()
|
|
74
|
+
, Parent(std::move(_other.Parent))
|
|
75
|
+
, Address(std::move(_other.Address))
|
|
76
|
+
, Type(std::move(_other.Type))
|
|
77
|
+
, Manufacturer(std::move(_other.Manufacturer))
|
|
78
|
+
, Metadata(std::move(_other.Metadata))
|
|
79
|
+
{
|
|
80
|
+
_Init();
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
DeviceData(const Exchange::IZigWave::Device& _other)
|
|
84
|
+
: Core::JSON::Container()
|
|
85
|
+
{
|
|
86
|
+
Parent = _other.Parent;
|
|
87
|
+
Address = _other.Address;
|
|
88
|
+
Type = _other.Type;
|
|
89
|
+
Manufacturer = _other.Manufacturer;
|
|
90
|
+
Metadata = _other.Metadata;
|
|
91
|
+
_Init();
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
DeviceData& operator=(const DeviceData& _rhs)
|
|
95
|
+
{
|
|
96
|
+
Parent = _rhs.Parent;
|
|
97
|
+
Address = _rhs.Address;
|
|
98
|
+
Type = _rhs.Type;
|
|
99
|
+
Manufacturer = _rhs.Manufacturer;
|
|
100
|
+
Metadata = _rhs.Metadata;
|
|
101
|
+
return (*this);
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
DeviceData& operator=(DeviceData&& _rhs) noexcept
|
|
105
|
+
{
|
|
106
|
+
Parent = std::move(_rhs.Parent);
|
|
107
|
+
Address = std::move(_rhs.Address);
|
|
108
|
+
Type = std::move(_rhs.Type);
|
|
109
|
+
Manufacturer = std::move(_rhs.Manufacturer);
|
|
110
|
+
Metadata = std::move(_rhs.Metadata);
|
|
111
|
+
return (*this);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
DeviceData& operator=(const Exchange::IZigWave::Device& _rhs)
|
|
115
|
+
{
|
|
116
|
+
Parent = _rhs.Parent;
|
|
117
|
+
Address = _rhs.Address;
|
|
118
|
+
Type = _rhs.Type;
|
|
119
|
+
Manufacturer = _rhs.Manufacturer;
|
|
120
|
+
Metadata = _rhs.Metadata;
|
|
121
|
+
return (*this);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
operator Exchange::IZigWave::Device() const
|
|
125
|
+
{
|
|
126
|
+
Exchange::IZigWave::Device _value{};
|
|
127
|
+
_value.Parent = Parent;
|
|
128
|
+
_value.Address = Address;
|
|
129
|
+
_value.Type = Type;
|
|
130
|
+
_value.Manufacturer = Manufacturer;
|
|
131
|
+
_value.Metadata = Metadata;
|
|
132
|
+
return (_value);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
~DeviceData() = default;
|
|
136
|
+
|
|
137
|
+
public:
|
|
138
|
+
bool IsDataValid() const
|
|
139
|
+
{
|
|
140
|
+
return ((Parent.IsSet() == true) && (Address.IsSet() == true) && (Type.IsSet() == true) && (Manufacturer.IsSet() == true) && (Metadata.IsSet() == true));
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
private:
|
|
144
|
+
void _Init()
|
|
145
|
+
{
|
|
146
|
+
Add(_T("parent"), &Parent);
|
|
147
|
+
Add(_T("address"), &Address);
|
|
148
|
+
Add(_T("type"), &Type);
|
|
149
|
+
Add(_T("manufacturer"), &Manufacturer);
|
|
150
|
+
Add(_T("metadata"), &Metadata);
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
public:
|
|
154
|
+
Core::JSON::DecUInt32 Parent; // Address of the Parent
|
|
155
|
+
Core::JSON::DecUInt32 Address; // Address of the device
|
|
156
|
+
Core::JSON::EnumType<Exchange::IZigWave::Device::type> Type; // Type of the device
|
|
157
|
+
Core::JSON::DecUInt16 Manufacturer; // Manufactured of this device
|
|
158
|
+
Core::JSON::String Metadata; // Metadata associated with this device
|
|
159
|
+
}; // class DeviceData
|
|
160
|
+
|
|
161
|
+
class ControllerData : public Core::JSON::Container {
|
|
162
|
+
public:
|
|
163
|
+
ControllerData()
|
|
164
|
+
: Core::JSON::Container()
|
|
165
|
+
{
|
|
166
|
+
_Init();
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
ControllerData(const ControllerData& _other)
|
|
170
|
+
: Core::JSON::Container()
|
|
171
|
+
, Permutable(_other.Permutable)
|
|
172
|
+
, Port(_other.Port)
|
|
173
|
+
, Id(_other.Id)
|
|
174
|
+
, Major(_other.Major)
|
|
175
|
+
, Minor(_other.Minor)
|
|
176
|
+
, Nodes(_other.Nodes)
|
|
177
|
+
{
|
|
178
|
+
_Init();
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
ControllerData(ControllerData&& _other) noexcept
|
|
182
|
+
: Core::JSON::Container()
|
|
183
|
+
, Permutable(std::move(_other.Permutable))
|
|
184
|
+
, Port(std::move(_other.Port))
|
|
185
|
+
, Id(std::move(_other.Id))
|
|
186
|
+
, Major(std::move(_other.Major))
|
|
187
|
+
, Minor(std::move(_other.Minor))
|
|
188
|
+
, Nodes(std::move(_other.Nodes))
|
|
189
|
+
{
|
|
190
|
+
_Init();
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
ControllerData(const Exchange::IZigWave::Controller& _other)
|
|
194
|
+
: Core::JSON::Container()
|
|
195
|
+
{
|
|
196
|
+
Permutable = _other.Permutable;
|
|
197
|
+
Port = _other.Port;
|
|
198
|
+
Id = _other.Id;
|
|
199
|
+
Major = _other.Major;
|
|
200
|
+
Minor = _other.Minor;
|
|
201
|
+
Nodes = _other.Nodes;
|
|
202
|
+
_Init();
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
ControllerData& operator=(const ControllerData& _rhs)
|
|
206
|
+
{
|
|
207
|
+
Permutable = _rhs.Permutable;
|
|
208
|
+
Port = _rhs.Port;
|
|
209
|
+
Id = _rhs.Id;
|
|
210
|
+
Major = _rhs.Major;
|
|
211
|
+
Minor = _rhs.Minor;
|
|
212
|
+
Nodes = _rhs.Nodes;
|
|
213
|
+
return (*this);
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
ControllerData& operator=(ControllerData&& _rhs) noexcept
|
|
217
|
+
{
|
|
218
|
+
Permutable = std::move(_rhs.Permutable);
|
|
219
|
+
Port = std::move(_rhs.Port);
|
|
220
|
+
Id = std::move(_rhs.Id);
|
|
221
|
+
Major = std::move(_rhs.Major);
|
|
222
|
+
Minor = std::move(_rhs.Minor);
|
|
223
|
+
Nodes = std::move(_rhs.Nodes);
|
|
224
|
+
return (*this);
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
ControllerData& operator=(const Exchange::IZigWave::Controller& _rhs)
|
|
228
|
+
{
|
|
229
|
+
Permutable = _rhs.Permutable;
|
|
230
|
+
Port = _rhs.Port;
|
|
231
|
+
Id = _rhs.Id;
|
|
232
|
+
Major = _rhs.Major;
|
|
233
|
+
Minor = _rhs.Minor;
|
|
234
|
+
Nodes = _rhs.Nodes;
|
|
235
|
+
return (*this);
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
operator Exchange::IZigWave::Controller() const
|
|
239
|
+
{
|
|
240
|
+
Exchange::IZigWave::Controller _value{};
|
|
241
|
+
_value.Permutable = Permutable;
|
|
242
|
+
_value.Port = Port;
|
|
243
|
+
_value.Id = Id;
|
|
244
|
+
_value.Major = Major;
|
|
245
|
+
_value.Minor = Minor;
|
|
246
|
+
_value.Nodes = Nodes;
|
|
247
|
+
return (_value);
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
~ControllerData() = default;
|
|
251
|
+
|
|
252
|
+
public:
|
|
253
|
+
bool IsDataValid() const
|
|
254
|
+
{
|
|
255
|
+
return ((Permutable.IsSet() == true) && (Port.IsSet() == true) && (Id.IsSet() == true) && (Major.IsSet() == true) && (Minor.IsSet() == true) && (Nodes.IsSet() == true));
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
private:
|
|
259
|
+
void _Init()
|
|
260
|
+
{
|
|
261
|
+
Add(_T("permutable"), &Permutable);
|
|
262
|
+
Add(_T("port"), &Port);
|
|
263
|
+
Add(_T("id"), &Id);
|
|
264
|
+
Add(_T("major"), &Major);
|
|
265
|
+
Add(_T("minor"), &Minor);
|
|
266
|
+
Add(_T("nodes"), &Nodes);
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
public:
|
|
270
|
+
Core::JSON::Boolean Permutable; // Permutable or not
|
|
271
|
+
Core::JSON::String Port; // Port number
|
|
272
|
+
Core::JSON::DecUInt32 Id; // Controller Id
|
|
273
|
+
Core::JSON::DecUInt8 Major; // Major number
|
|
274
|
+
Core::JSON::DecUInt8 Minor; // Minor number
|
|
275
|
+
Core::JSON::DecUInt16 Nodes; // Number of Nodes
|
|
276
|
+
}; // class ControllerData
|
|
277
|
+
|
|
278
|
+
class PermutableData : public Core::JSON::Container {
|
|
279
|
+
public:
|
|
280
|
+
PermutableData()
|
|
281
|
+
: Core::JSON::Container()
|
|
282
|
+
{
|
|
283
|
+
Add(_T("value"), &Value);
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
PermutableData(const PermutableData&) = delete;
|
|
287
|
+
PermutableData(PermutableData&&) noexcept = delete;
|
|
288
|
+
|
|
289
|
+
PermutableData& operator=(const PermutableData&) = delete;
|
|
290
|
+
PermutableData& operator=(PermutableData&&) noexcept = delete;
|
|
291
|
+
|
|
292
|
+
~PermutableData() = default;
|
|
293
|
+
|
|
294
|
+
public:
|
|
295
|
+
bool IsDataValid() const
|
|
296
|
+
{
|
|
297
|
+
return (Value.IsSet() == true);
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
public:
|
|
301
|
+
Core::JSON::Boolean Value; // To allow new devices to the network, the controller should be placed into an accepting mode. By enabling this mode, the controller can accept new devices.
|
|
302
|
+
}; // class PermutableData
|
|
303
|
+
|
|
304
|
+
} // namespace ZigWave
|
|
305
|
+
|
|
306
|
+
POP_WARNING()
|
|
307
|
+
|
|
308
|
+
} // namespace JsonData
|
|
309
|
+
|
|
310
|
+
// Enum conversion handlers
|
|
311
|
+
ENUM_CONVERSION_HANDLER(Exchange::IZigWave::Device::type)
|
|
312
|
+
|
|
313
|
+
}
|
|
314
|
+
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
// Enumeration code for AVSController API.
|
|
2
|
+
// Generated automatically from 'IAVSClient.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IAVSClient.h>
|
|
8
|
+
#include "JsonData_AVSController.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IAVSController::INotification::dialoguestate)
|
|
13
|
+
{ Exchange::IAVSController::INotification::dialoguestate::IDLE, _TXT("Idle") },
|
|
14
|
+
{ Exchange::IAVSController::INotification::dialoguestate::LISTENING, _TXT("Listening") },
|
|
15
|
+
{ Exchange::IAVSController::INotification::dialoguestate::EXPECTING, _TXT("Expecting") },
|
|
16
|
+
{ Exchange::IAVSController::INotification::dialoguestate::THINKING, _TXT("Thinking") },
|
|
17
|
+
{ Exchange::IAVSController::INotification::dialoguestate::SPEAKING, _TXT("Speaking") },
|
|
18
|
+
ENUM_CONVERSION_END(Exchange::IAVSController::INotification::dialoguestate)
|
|
19
|
+
|
|
20
|
+
}
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
// Enumeration code for Application API.
|
|
2
|
+
// Generated automatically from 'IApplication.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IApplication.h>
|
|
8
|
+
#include "JsonData_Application.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IApplication::resettype)
|
|
13
|
+
{ Exchange::IApplication::resettype::FACTORY, _TXT("Factory") },
|
|
14
|
+
{ Exchange::IApplication::resettype::CACHE, _TXT("Cache") },
|
|
15
|
+
{ Exchange::IApplication::resettype::CREDENTIALS, _TXT("Credentials") },
|
|
16
|
+
{ Exchange::IApplication::resettype::RECORDINGS, _TXT("Recordings") },
|
|
17
|
+
ENUM_CONVERSION_END(Exchange::IApplication::resettype)
|
|
18
|
+
|
|
19
|
+
ENUM_CONVERSION_BEGIN(Exchange::IApplication::launchpointtype)
|
|
20
|
+
{ Exchange::IApplication::launchpointtype::UNDEFINED, _TXT("Undefined") },
|
|
21
|
+
{ Exchange::IApplication::launchpointtype::DIAL, _TXT("Dial") },
|
|
22
|
+
{ Exchange::IApplication::launchpointtype::DEDICATED_BUTTON, _TXT("DedicatedButton") },
|
|
23
|
+
{ Exchange::IApplication::launchpointtype::DEDICATED_ICON, _TXT("DedicatedIcon") },
|
|
24
|
+
{ Exchange::IApplication::launchpointtype::APPLICATION_LIST, _TXT("ApplicationList") },
|
|
25
|
+
{ Exchange::IApplication::launchpointtype::INTEGRATED_TILE, _TXT("IntegratedTile") },
|
|
26
|
+
{ Exchange::IApplication::launchpointtype::SEARCH_RESULT, _TXT("SearchResult") },
|
|
27
|
+
{ Exchange::IApplication::launchpointtype::SEARCH_CONTINUATION, _TXT("SearchContinuation") },
|
|
28
|
+
{ Exchange::IApplication::launchpointtype::VOICE_CONTROL, _TXT("VoiceControl") },
|
|
29
|
+
{ Exchange::IApplication::launchpointtype::VOICE_SEARCH_RESULT, _TXT("VoiceSearchResult") },
|
|
30
|
+
{ Exchange::IApplication::launchpointtype::VISUAL_GESTURE, _TXT("VisualGesture") },
|
|
31
|
+
{ Exchange::IApplication::launchpointtype::TOUCH_GESTURE, _TXT("TouchGesture") },
|
|
32
|
+
{ Exchange::IApplication::launchpointtype::EPG_GRID, _TXT("EpgGrid") },
|
|
33
|
+
{ Exchange::IApplication::launchpointtype::CHANNEL_NUMBER, _TXT("ChannelNumber") },
|
|
34
|
+
{ Exchange::IApplication::launchpointtype::CHANNEL_ZAP, _TXT("ChannelZap") },
|
|
35
|
+
{ Exchange::IApplication::launchpointtype::CHANNEL_BAR, _TXT("ChannelBar") },
|
|
36
|
+
{ Exchange::IApplication::launchpointtype::WEB_BROWSER, _TXT("WebBrowser") },
|
|
37
|
+
{ Exchange::IApplication::launchpointtype::POWER_ON, _TXT("PowerOn") },
|
|
38
|
+
{ Exchange::IApplication::launchpointtype::POWER_ON_FROM_DEDICATED_BUTTON, _TXT("PowerOnFromDedicatedButton") },
|
|
39
|
+
{ Exchange::IApplication::launchpointtype::SUSPENDED_POWER_ON, _TXT("SuspendedPowerOn") },
|
|
40
|
+
{ Exchange::IApplication::launchpointtype::RESTART, _TXT("Restart") },
|
|
41
|
+
{ Exchange::IApplication::launchpointtype::SUSPENDED_RESTART, _TXT("SuspendedRestart") },
|
|
42
|
+
{ Exchange::IApplication::launchpointtype::RESUMED_FROM_SCREEN_SAVER, _TXT("ResumedFromScreenSaver") },
|
|
43
|
+
{ Exchange::IApplication::launchpointtype::RESUMED_FROM_STANDBY, _TXT("ResumedFromStandby") },
|
|
44
|
+
{ Exchange::IApplication::launchpointtype::BANNER_AD, _TXT("BannerAd") },
|
|
45
|
+
{ Exchange::IApplication::launchpointtype::TITLE_RECOMMENDATION, _TXT("TitleRecommendation") },
|
|
46
|
+
{ Exchange::IApplication::launchpointtype::APPLICATION_PROMOTION, _TXT("ApplicationPromotion") },
|
|
47
|
+
ENUM_CONVERSION_END(Exchange::IApplication::launchpointtype)
|
|
48
|
+
|
|
49
|
+
}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
// Enumeration code for AudioStream API.
|
|
2
|
+
// Generated automatically from 'IAudioStream.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IAudioStream.h>
|
|
8
|
+
#include "JsonData_AudioStream.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IAudioStream::streamstate)
|
|
13
|
+
{ Exchange::IAudioStream::streamstate::UNAVAILABLE, _TXT("Unavailable") },
|
|
14
|
+
{ Exchange::IAudioStream::streamstate::IDLE, _TXT("Idle") },
|
|
15
|
+
{ Exchange::IAudioStream::streamstate::STARTED, _TXT("Started") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IAudioStream::streamstate)
|
|
17
|
+
|
|
18
|
+
ENUM_CONVERSION_BEGIN(Exchange::IAudioStream::codectype)
|
|
19
|
+
{ Exchange::IAudioStream::codectype::PCM, _TXT("PCM") },
|
|
20
|
+
{ Exchange::IAudioStream::codectype::IMA_ADPCM, _TXT("IMA-ADPCM") },
|
|
21
|
+
{ Exchange::IAudioStream::codectype::_, _TXT("") },
|
|
22
|
+
{ Exchange::IAudioStream::codectype::ADPCM, _TXT("Adpcm") },
|
|
23
|
+
ENUM_CONVERSION_END(Exchange::IAudioStream::codectype)
|
|
24
|
+
|
|
25
|
+
}
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
// Enumeration code for Sink API.
|
|
2
|
+
// Generated automatically from 'IBluetoothAudio.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
8
|
+
#include "JsonData_BluetoothAudioSink.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBluetoothAudio::state)
|
|
13
|
+
{ Exchange::IBluetoothAudio::state::UNASSIGNED, _TXT("Unassigned") },
|
|
14
|
+
{ Exchange::IBluetoothAudio::state::DISCONNECTED, _TXT("Disconnected") },
|
|
15
|
+
{ Exchange::IBluetoothAudio::state::CONNECTING, _TXT("Connecting") },
|
|
16
|
+
{ Exchange::IBluetoothAudio::state::CONNECTED, _TXT("Connected") },
|
|
17
|
+
{ Exchange::IBluetoothAudio::state::CONNECTED_BAD, _TXT("ConnectedBad") },
|
|
18
|
+
{ Exchange::IBluetoothAudio::state::CONNECTED_RESTRICTED, _TXT("ConnectedRestricted") },
|
|
19
|
+
{ Exchange::IBluetoothAudio::state::READY, _TXT("Ready") },
|
|
20
|
+
{ Exchange::IBluetoothAudio::state::STREAMING, _TXT("Streaming") },
|
|
21
|
+
ENUM_CONVERSION_END(Exchange::IBluetoothAudio::state)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBluetoothAudio::ISink::devicetype)
|
|
24
|
+
{ Exchange::IBluetoothAudio::ISink::devicetype::UNKNOWN, _TXT("Unknown") },
|
|
25
|
+
{ Exchange::IBluetoothAudio::ISink::devicetype::HEADPHONE, _TXT("Headphone") },
|
|
26
|
+
{ Exchange::IBluetoothAudio::ISink::devicetype::SPEAKER, _TXT("Speaker") },
|
|
27
|
+
{ Exchange::IBluetoothAudio::ISink::devicetype::RECORDER, _TXT("Recorder") },
|
|
28
|
+
{ Exchange::IBluetoothAudio::ISink::devicetype::AMPLIFIER, _TXT("Amplifier") },
|
|
29
|
+
ENUM_CONVERSION_END(Exchange::IBluetoothAudio::ISink::devicetype)
|
|
30
|
+
|
|
31
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBluetoothAudio::audiocodec)
|
|
32
|
+
{ Exchange::IBluetoothAudio::audiocodec::LC_SBC, _TXT("LC-SBC") },
|
|
33
|
+
ENUM_CONVERSION_END(Exchange::IBluetoothAudio::audiocodec)
|
|
34
|
+
|
|
35
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBluetoothAudio::drmscheme)
|
|
36
|
+
{ Exchange::IBluetoothAudio::drmscheme::DTCP, _TXT("DTCP") },
|
|
37
|
+
{ Exchange::IBluetoothAudio::drmscheme::SCMS_T, _TXT("SCMS-T") },
|
|
38
|
+
ENUM_CONVERSION_END(Exchange::IBluetoothAudio::drmscheme)
|
|
39
|
+
|
|
40
|
+
}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
// Enumeration code for Source API.
|
|
2
|
+
// Generated automatically from 'IBluetoothAudio.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IBluetoothAudio.h>
|
|
8
|
+
#include "JsonData_BluetoothAudioSource.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBluetoothAudio::ISource::devicetype)
|
|
13
|
+
{ Exchange::IBluetoothAudio::ISource::devicetype::UNKNOWN, _TXT("Unknown") },
|
|
14
|
+
{ Exchange::IBluetoothAudio::ISource::devicetype::PLAYER, _TXT("Player") },
|
|
15
|
+
{ Exchange::IBluetoothAudio::ISource::devicetype::MICROPHONE, _TXT("Microphone") },
|
|
16
|
+
{ Exchange::IBluetoothAudio::ISource::devicetype::TUNER, _TXT("Tuner") },
|
|
17
|
+
{ Exchange::IBluetoothAudio::ISource::devicetype::MIXER, _TXT("Mixer") },
|
|
18
|
+
ENUM_CONVERSION_END(Exchange::IBluetoothAudio::ISource::devicetype)
|
|
19
|
+
|
|
20
|
+
}
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
// Enumeration code for BluetoothControl API.
|
|
2
|
+
// Generated automatically from 'IBluetooth.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IBluetooth.h>
|
|
8
|
+
#include "JsonData_BluetoothControl.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::scantype)
|
|
13
|
+
{ Exchange::JSONRPC::IBluetoothControl::scantype::CLASSIC, _TXT("Classic") },
|
|
14
|
+
{ Exchange::JSONRPC::IBluetoothControl::scantype::LOW_ENERGY, _TXT("LowEnergy") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::scantype)
|
|
16
|
+
|
|
17
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::scanmode)
|
|
18
|
+
{ Exchange::JSONRPC::IBluetoothControl::scanmode::GENERAL, _TXT("General") },
|
|
19
|
+
{ Exchange::JSONRPC::IBluetoothControl::scanmode::LIMITED, _TXT("Limited") },
|
|
20
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::scanmode)
|
|
21
|
+
|
|
22
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::devicetype)
|
|
23
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicetype::CLASSIC, _TXT("Classic") },
|
|
24
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicetype::LOW_ENERGY, _TXT("LowEnergy") },
|
|
25
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicetype::LOW_ENERGY_RANDOM, _TXT("LowEnergyRandom") },
|
|
26
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::devicetype)
|
|
27
|
+
|
|
28
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::pairingcapabilities)
|
|
29
|
+
{ Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::DISPLAY_ONLY, _TXT("DisplayOnly") },
|
|
30
|
+
{ Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::DISPLAY_YES_NO, _TXT("DisplayYesNo") },
|
|
31
|
+
{ Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::KEYBOARD_ONLY, _TXT("KeyboardOnly") },
|
|
32
|
+
{ Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::NO_INPUT_NO_OUTPUT, _TXT("NoInputNoOutput") },
|
|
33
|
+
{ Exchange::JSONRPC::IBluetoothControl::pairingcapabilities::KEYBOARD_DISPLAY, _TXT("KeyboardDisplay") },
|
|
34
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::pairingcapabilities)
|
|
35
|
+
|
|
36
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::adaptertype)
|
|
37
|
+
{ Exchange::JSONRPC::IBluetoothControl::adaptertype::CLASSIC, _TXT("Classic") },
|
|
38
|
+
{ Exchange::JSONRPC::IBluetoothControl::adaptertype::LOW_ENERGY, _TXT("LowEnergy") },
|
|
39
|
+
{ Exchange::JSONRPC::IBluetoothControl::adaptertype::DUAL, _TXT("Dual") },
|
|
40
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::adaptertype)
|
|
41
|
+
|
|
42
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::devicestate)
|
|
43
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicestate::PAIRING, _TXT("Pairing") },
|
|
44
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicestate::PAIRED, _TXT("Paired") },
|
|
45
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicestate::UNPAIRED, _TXT("Unpaired") },
|
|
46
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicestate::CONNECTED, _TXT("Connected") },
|
|
47
|
+
{ Exchange::JSONRPC::IBluetoothControl::devicestate::DISCONNECTED, _TXT("Disconnected") },
|
|
48
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::devicestate)
|
|
49
|
+
|
|
50
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IBluetoothControl::disconnectreason)
|
|
51
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::CONNECTION_TIMEOUT, _TXT("ConnectionTimeout") },
|
|
52
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::AUTHENTICATION_FAILURE, _TXT("AuthenticationFailure") },
|
|
53
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::REMOTE_LOW_ON_RESOURCES, _TXT("RemoteLowOnResources") },
|
|
54
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::REMOTE_POWERED_OFF, _TXT("RemotePoweredOff") },
|
|
55
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::TERMINATED_BY_REMOTE, _TXT("TerminatedByRemote") },
|
|
56
|
+
{ Exchange::JSONRPC::IBluetoothControl::disconnectreason::TERMINATED_BY_HOST, _TXT("TerminatedByHost") },
|
|
57
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IBluetoothControl::disconnectreason)
|
|
58
|
+
|
|
59
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
// Enumeration code for Browser API.
|
|
2
|
+
// Generated automatically from 'Browser.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Browser.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::Browser::VisibilityType)
|
|
12
|
+
{ JsonData::Browser::VisibilityType::VISIBLE, _TXT("visible") },
|
|
13
|
+
{ JsonData::Browser::VisibilityType::HIDDEN, _TXT("hidden") },
|
|
14
|
+
ENUM_CONVERSION_END(JsonData::Browser::VisibilityType)
|
|
15
|
+
|
|
16
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// Enumeration code for BrowserSecurity API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IBrowser.h>
|
|
8
|
+
#include "JsonData_BrowserSecurity.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IBrowserSecurity::MixedContentPolicyType)
|
|
13
|
+
{ Exchange::IBrowserSecurity::MixedContentPolicyType::ALLOWED, _TXT("allowed") },
|
|
14
|
+
{ Exchange::IBrowserSecurity::MixedContentPolicyType::BLOCKED, _TXT("blocked") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::IBrowserSecurity::MixedContentPolicyType)
|
|
16
|
+
|
|
17
|
+
}
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
// Enumeration code for Compositor API.
|
|
2
|
+
// Generated automatically from 'Compositor.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Compositor.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::Compositor::ResolutionType)
|
|
12
|
+
{ JsonData::Compositor::ResolutionType::UNKNOWN, _TXT("unknown") },
|
|
13
|
+
{ JsonData::Compositor::ResolutionType::E480I, _TXT("480i") },
|
|
14
|
+
{ JsonData::Compositor::ResolutionType::E480P, _TXT("480p") },
|
|
15
|
+
{ JsonData::Compositor::ResolutionType::E720P50, _TXT("720p50") },
|
|
16
|
+
{ JsonData::Compositor::ResolutionType::E720P60, _TXT("720p60") },
|
|
17
|
+
{ JsonData::Compositor::ResolutionType::E1080P24, _TXT("1080p24") },
|
|
18
|
+
{ JsonData::Compositor::ResolutionType::E1080I50, _TXT("1080i50") },
|
|
19
|
+
{ JsonData::Compositor::ResolutionType::E1080P50, _TXT("1080p50") },
|
|
20
|
+
{ JsonData::Compositor::ResolutionType::E1080P60, _TXT("1080p60") },
|
|
21
|
+
{ JsonData::Compositor::ResolutionType::E2160P50, _TXT("2160p50") },
|
|
22
|
+
{ JsonData::Compositor::ResolutionType::E2160P60, _TXT("2160p60") },
|
|
23
|
+
ENUM_CONVERSION_END(JsonData::Compositor::ResolutionType)
|
|
24
|
+
|
|
25
|
+
ENUM_CONVERSION_BEGIN(JsonData::Compositor::BrightnessType)
|
|
26
|
+
{ JsonData::Compositor::BrightnessType::DEFAULT, _TXT("default") },
|
|
27
|
+
{ JsonData::Compositor::BrightnessType::MATCH_VIDEO, _TXT("match_video") },
|
|
28
|
+
{ JsonData::Compositor::BrightnessType::MAX, _TXT("max") },
|
|
29
|
+
ENUM_CONVERSION_END(JsonData::Compositor::BrightnessType)
|
|
30
|
+
|
|
31
|
+
ENUM_CONVERSION_BEGIN(JsonData::Compositor::VisiblityType)
|
|
32
|
+
{ JsonData::Compositor::VisiblityType::VISIBLE, _TXT("visible") },
|
|
33
|
+
{ JsonData::Compositor::VisiblityType::HIDDEN, _TXT("hidden") },
|
|
34
|
+
ENUM_CONVERSION_END(JsonData::Compositor::VisiblityType)
|
|
35
|
+
|
|
36
|
+
}
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Enumeration code for ConnectionProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDisplayInfo.h>
|
|
8
|
+
#include "JsonData_ConnectionProperties.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IConnectionProperties::HDCPProtectionType)
|
|
13
|
+
{ Exchange::IConnectionProperties::HDCPProtectionType::HDCP_Unencrypted, _TXT("HdcpUnencrypted") },
|
|
14
|
+
{ Exchange::IConnectionProperties::HDCPProtectionType::HDCP_1X, _TXT("Hdcp1X") },
|
|
15
|
+
{ Exchange::IConnectionProperties::HDCPProtectionType::HDCP_2X, _TXT("Hdcp2X") },
|
|
16
|
+
{ Exchange::IConnectionProperties::HDCPProtectionType::HDCP_AUTO, _TXT("HdcpAuto") },
|
|
17
|
+
ENUM_CONVERSION_END(Exchange::IConnectionProperties::HDCPProtectionType)
|
|
18
|
+
|
|
19
|
+
ENUM_CONVERSION_BEGIN(Exchange::IConnectionProperties::INotification::Source)
|
|
20
|
+
{ Exchange::IConnectionProperties::INotification::Source::PRE_RESOLUTION_CHANGE, _TXT("PreResolutionChange") },
|
|
21
|
+
{ Exchange::IConnectionProperties::INotification::Source::POST_RESOLUTION_CHANGE, _TXT("PostResolutionChange") },
|
|
22
|
+
{ Exchange::IConnectionProperties::INotification::Source::HDMI_CHANGE, _TXT("HdmiChange") },
|
|
23
|
+
{ Exchange::IConnectionProperties::INotification::Source::HDCP_CHANGE, _TXT("HdcpChange") },
|
|
24
|
+
ENUM_CONVERSION_END(Exchange::IConnectionProperties::INotification::Source)
|
|
25
|
+
|
|
26
|
+
}
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
// Enumeration code for ContentProtection API.
|
|
2
|
+
// Generated automatically from 'IContentProtection.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IContentProtection.h>
|
|
8
|
+
#include "JsonData_ContentProtection.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IContentProtection::KeySystem)
|
|
13
|
+
{ Exchange::IContentProtection::KeySystem::WIDEVINE, _TXT("widevine") },
|
|
14
|
+
{ Exchange::IContentProtection::KeySystem::PLAYREADY, _TXT("playready") },
|
|
15
|
+
{ Exchange::IContentProtection::KeySystem::CLEARKEY, _TXT("clearkey") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IContentProtection::KeySystem)
|
|
17
|
+
|
|
18
|
+
ENUM_CONVERSION_BEGIN(Exchange::IContentProtection::State)
|
|
19
|
+
{ Exchange::IContentProtection::State::ACTIVE, _TXT("active") },
|
|
20
|
+
{ Exchange::IContentProtection::State::INACTIVE, _TXT("inactive") },
|
|
21
|
+
ENUM_CONVERSION_END(Exchange::IContentProtection::State)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(Exchange::IContentProtection::INotification::Status::State)
|
|
24
|
+
{ Exchange::IContentProtection::INotification::Status::State::GRANTED, _TXT("GRANTED") },
|
|
25
|
+
{ Exchange::IContentProtection::INotification::Status::State::NOT_REQUIRED, _TXT("NOT_REQUIRED") },
|
|
26
|
+
{ Exchange::IContentProtection::INotification::Status::State::DENIED, _TXT("DENIED") },
|
|
27
|
+
{ Exchange::IContentProtection::INotification::Status::State::FAILED, _TXT("FAILED") },
|
|
28
|
+
ENUM_CONVERSION_END(Exchange::IContentProtection::INotification::Status::State)
|
|
29
|
+
|
|
30
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// Enumeration code for DIAL Server API.
|
|
2
|
+
// Generated automatically from 'DIALServer.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_DIALServer.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::DIALServer::StateType)
|
|
12
|
+
{ JsonData::DIALServer::StateType::STOPPED, _TXT("Stopped") },
|
|
13
|
+
{ JsonData::DIALServer::StateType::STARTED, _TXT("Started") },
|
|
14
|
+
{ JsonData::DIALServer::StateType::HIDDEN, _TXT("Hidden") },
|
|
15
|
+
ENUM_CONVERSION_END(JsonData::DIALServer::StateType)
|
|
16
|
+
|
|
17
|
+
}
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
// Enumeration code for DNSServer API.
|
|
2
|
+
// Generated automatically from 'IDNSServer.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDNSServer.h>
|
|
8
|
+
#include "JsonData_DNSServer.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDNSServer::Record::type)
|
|
13
|
+
{ Exchange::IDNSServer::Record::type::INVALID, _TXT("INVALID") },
|
|
14
|
+
{ Exchange::IDNSServer::Record::type::RECORD_A, _TXT("RECORD_A") },
|
|
15
|
+
{ Exchange::IDNSServer::Record::type::RECORD_NS, _TXT("RECORD_NS") },
|
|
16
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MD, _TXT("RECORD_MD") },
|
|
17
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MF, _TXT("RECORD_MF") },
|
|
18
|
+
{ Exchange::IDNSServer::Record::type::RECORD_CNAME, _TXT("RECORD_CNAME") },
|
|
19
|
+
{ Exchange::IDNSServer::Record::type::RECORD_SOA, _TXT("RECORD_SOA") },
|
|
20
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MB, _TXT("RECORD_MB") },
|
|
21
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MG, _TXT("RECORD_MG") },
|
|
22
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MR, _TXT("RECORD_MR") },
|
|
23
|
+
{ Exchange::IDNSServer::Record::type::RECORD_NULL, _TXT("RECORD_NULL") },
|
|
24
|
+
{ Exchange::IDNSServer::Record::type::RECORD_WKS, _TXT("RECORD_WKS") },
|
|
25
|
+
{ Exchange::IDNSServer::Record::type::RECORD_PTR, _TXT("RECORD_PTR") },
|
|
26
|
+
{ Exchange::IDNSServer::Record::type::RECORD_HINFO, _TXT("RECORD_HINFO") },
|
|
27
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MINFO, _TXT("RECORD_MINFO") },
|
|
28
|
+
{ Exchange::IDNSServer::Record::type::RECORD_MX, _TXT("RECORD_MX") },
|
|
29
|
+
{ Exchange::IDNSServer::Record::type::RECORD_TXT, _TXT("RECORD_TXT") },
|
|
30
|
+
{ Exchange::IDNSServer::Record::type::RECORD_AAAA, _TXT("RECORD_AAAA") },
|
|
31
|
+
{ Exchange::IDNSServer::Record::type::REQUEST_AXFR, _TXT("REQUEST_AXFR") },
|
|
32
|
+
{ Exchange::IDNSServer::Record::type::REQUEST_MAILB, _TXT("REQUEST_MAILB") },
|
|
33
|
+
{ Exchange::IDNSServer::Record::type::REQUEST_MAILA, _TXT("REQUEST_MAILA") },
|
|
34
|
+
{ Exchange::IDNSServer::Record::type::REQUEST_ALL, _TXT("REQUEST_ALL") },
|
|
35
|
+
ENUM_CONVERSION_END(Exchange::IDNSServer::Record::type)
|
|
36
|
+
|
|
37
|
+
}
|
|
@@ -0,0 +1,201 @@
|
|
|
1
|
+
// Enumeration code for DTV API.
|
|
2
|
+
// Generated automatically from 'DTV.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_DTV.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::LnbtypeType)
|
|
12
|
+
{ JsonData::DTV::LnbtypeType::SINGLE, _TXT("single") },
|
|
13
|
+
{ JsonData::DTV::LnbtypeType::UNIVERSAL, _TXT("universal") },
|
|
14
|
+
{ JsonData::DTV::LnbtypeType::UNICABLE, _TXT("unicable") },
|
|
15
|
+
ENUM_CONVERSION_END(JsonData::DTV::LnbtypeType)
|
|
16
|
+
|
|
17
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::LnbpowerType)
|
|
18
|
+
{ JsonData::DTV::LnbpowerType::OFF, _TXT("off") },
|
|
19
|
+
{ JsonData::DTV::LnbpowerType::ON, _TXT("on") },
|
|
20
|
+
{ JsonData::DTV::LnbpowerType::AUTO, _TXT("auto") },
|
|
21
|
+
ENUM_CONVERSION_END(JsonData::DTV::LnbpowerType)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::Diseqc_toneType)
|
|
24
|
+
{ JsonData::DTV::Diseqc_toneType::OFF, _TXT("off") },
|
|
25
|
+
{ JsonData::DTV::Diseqc_toneType::A, _TXT("a") },
|
|
26
|
+
{ JsonData::DTV::Diseqc_toneType::B, _TXT("b") },
|
|
27
|
+
ENUM_CONVERSION_END(JsonData::DTV::Diseqc_toneType)
|
|
28
|
+
|
|
29
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::Diseqc_cswitchType)
|
|
30
|
+
{ JsonData::DTV::Diseqc_cswitchType::OFF, _TXT("off") },
|
|
31
|
+
{ JsonData::DTV::Diseqc_cswitchType::A, _TXT("a") },
|
|
32
|
+
{ JsonData::DTV::Diseqc_cswitchType::B, _TXT("b") },
|
|
33
|
+
{ JsonData::DTV::Diseqc_cswitchType::C, _TXT("c") },
|
|
34
|
+
{ JsonData::DTV::Diseqc_cswitchType::D, _TXT("d") },
|
|
35
|
+
ENUM_CONVERSION_END(JsonData::DTV::Diseqc_cswitchType)
|
|
36
|
+
|
|
37
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::TunertypeType)
|
|
38
|
+
{ JsonData::DTV::TunertypeType::NONE, _TXT("none") },
|
|
39
|
+
{ JsonData::DTV::TunertypeType::DVBS, _TXT("dvbs") },
|
|
40
|
+
{ JsonData::DTV::TunertypeType::DVBT, _TXT("dvbt") },
|
|
41
|
+
{ JsonData::DTV::TunertypeType::DVBC, _TXT("dvbc") },
|
|
42
|
+
ENUM_CONVERSION_END(JsonData::DTV::TunertypeType)
|
|
43
|
+
|
|
44
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::StartServiceSearchParamsData::SearchtypeType)
|
|
45
|
+
{ JsonData::DTV::StartServiceSearchParamsData::SearchtypeType::FREQUENCY, _TXT("frequency") },
|
|
46
|
+
{ JsonData::DTV::StartServiceSearchParamsData::SearchtypeType::NETWORK, _TXT("network") },
|
|
47
|
+
ENUM_CONVERSION_END(JsonData::DTV::StartServiceSearchParamsData::SearchtypeType)
|
|
48
|
+
|
|
49
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::PolarityType)
|
|
50
|
+
{ JsonData::DTV::PolarityType::HORIZONTAL, _TXT("horizontal") },
|
|
51
|
+
{ JsonData::DTV::PolarityType::VERTICAL, _TXT("vertical") },
|
|
52
|
+
{ JsonData::DTV::PolarityType::LEFT, _TXT("left") },
|
|
53
|
+
{ JsonData::DTV::PolarityType::RIGHT, _TXT("right") },
|
|
54
|
+
ENUM_CONVERSION_END(JsonData::DTV::PolarityType)
|
|
55
|
+
|
|
56
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::FecType)
|
|
57
|
+
{ JsonData::DTV::FecType::FECAUTO, _TXT("fecauto") },
|
|
58
|
+
{ JsonData::DTV::FecType::FEC1_2, _TXT("fec1_2") },
|
|
59
|
+
{ JsonData::DTV::FecType::FEC2_3, _TXT("fec2_3") },
|
|
60
|
+
{ JsonData::DTV::FecType::FEC3_4, _TXT("fec3_4") },
|
|
61
|
+
{ JsonData::DTV::FecType::FEC5_6, _TXT("fec5_6") },
|
|
62
|
+
{ JsonData::DTV::FecType::FEC7_8, _TXT("fec7_8") },
|
|
63
|
+
{ JsonData::DTV::FecType::FEC1_4, _TXT("fec1_4") },
|
|
64
|
+
{ JsonData::DTV::FecType::FEC1_3, _TXT("fec1_3") },
|
|
65
|
+
{ JsonData::DTV::FecType::FEC2_5, _TXT("fec2_5") },
|
|
66
|
+
{ JsonData::DTV::FecType::FEC8_9, _TXT("fec8_9") },
|
|
67
|
+
{ JsonData::DTV::FecType::FEC9_10, _TXT("fec9_10") },
|
|
68
|
+
{ JsonData::DTV::FecType::FEC3_5, _TXT("fec3_5") },
|
|
69
|
+
{ JsonData::DTV::FecType::FEC4_5, _TXT("fec4_5") },
|
|
70
|
+
ENUM_CONVERSION_END(JsonData::DTV::FecType)
|
|
71
|
+
|
|
72
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::DvbsmodulationType)
|
|
73
|
+
{ JsonData::DTV::DvbsmodulationType::AUTO, _TXT("auto") },
|
|
74
|
+
{ JsonData::DTV::DvbsmodulationType::QPSK, _TXT("qpsk") },
|
|
75
|
+
{ JsonData::DTV::DvbsmodulationType::E8PSK, _TXT("8psk") },
|
|
76
|
+
{ JsonData::DTV::DvbsmodulationType::E16QAM, _TXT("16qam") },
|
|
77
|
+
ENUM_CONVERSION_END(JsonData::DTV::DvbsmodulationType)
|
|
78
|
+
|
|
79
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::DvbcmodulationType)
|
|
80
|
+
{ JsonData::DTV::DvbcmodulationType::AUTO, _TXT("auto") },
|
|
81
|
+
{ JsonData::DTV::DvbcmodulationType::E4QAM, _TXT("4qam") },
|
|
82
|
+
{ JsonData::DTV::DvbcmodulationType::E8QAM, _TXT("8qam") },
|
|
83
|
+
{ JsonData::DTV::DvbcmodulationType::E16QAM, _TXT("16qam") },
|
|
84
|
+
{ JsonData::DTV::DvbcmodulationType::E32QAM, _TXT("32qam") },
|
|
85
|
+
{ JsonData::DTV::DvbcmodulationType::E64QAM, _TXT("64qam") },
|
|
86
|
+
{ JsonData::DTV::DvbcmodulationType::E128QAM, _TXT("128qam") },
|
|
87
|
+
{ JsonData::DTV::DvbcmodulationType::E256QAM, _TXT("256qam") },
|
|
88
|
+
ENUM_CONVERSION_END(JsonData::DTV::DvbcmodulationType)
|
|
89
|
+
|
|
90
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::DvbtbandwidthType)
|
|
91
|
+
{ JsonData::DTV::DvbtbandwidthType::E5MHZ, _TXT("5MHz") },
|
|
92
|
+
{ JsonData::DTV::DvbtbandwidthType::E6MHZ, _TXT("6MHz") },
|
|
93
|
+
{ JsonData::DTV::DvbtbandwidthType::E7MHZ, _TXT("7MHz") },
|
|
94
|
+
{ JsonData::DTV::DvbtbandwidthType::E8MHZ, _TXT("8MHz") },
|
|
95
|
+
{ JsonData::DTV::DvbtbandwidthType::E10MHZ, _TXT("10MHz") },
|
|
96
|
+
{ JsonData::DTV::DvbtbandwidthType::UNDEFINED, _TXT("undefined") },
|
|
97
|
+
ENUM_CONVERSION_END(JsonData::DTV::DvbtbandwidthType)
|
|
98
|
+
|
|
99
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::OfdmmodeType)
|
|
100
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_1K, _TXT("ofdm_1K") },
|
|
101
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_2K, _TXT("ofdm_2K") },
|
|
102
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_4K, _TXT("ofdm_4K") },
|
|
103
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_8K, _TXT("ofdm_8K") },
|
|
104
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_16K, _TXT("ofdm_16K") },
|
|
105
|
+
{ JsonData::DTV::OfdmmodeType::OFDM_32K, _TXT("ofdm_32K") },
|
|
106
|
+
{ JsonData::DTV::OfdmmodeType::UNDEFINED, _TXT("undefined") },
|
|
107
|
+
ENUM_CONVERSION_END(JsonData::DTV::OfdmmodeType)
|
|
108
|
+
|
|
109
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::ServicetypeType)
|
|
110
|
+
{ JsonData::DTV::ServicetypeType::TV, _TXT("tv") },
|
|
111
|
+
{ JsonData::DTV::ServicetypeType::RADIO, _TXT("radio") },
|
|
112
|
+
{ JsonData::DTV::ServicetypeType::TELETEXT, _TXT("teletext") },
|
|
113
|
+
{ JsonData::DTV::ServicetypeType::NVOD, _TXT("nvod") },
|
|
114
|
+
{ JsonData::DTV::ServicetypeType::NVOD_TIMESHIFT, _TXT("nvod_timeshift") },
|
|
115
|
+
{ JsonData::DTV::ServicetypeType::MOSAIC, _TXT("mosaic") },
|
|
116
|
+
{ JsonData::DTV::ServicetypeType::AVC_RADIO, _TXT("avc_radio") },
|
|
117
|
+
{ JsonData::DTV::ServicetypeType::AVC_MOSAIC, _TXT("avc_mosaic") },
|
|
118
|
+
{ JsonData::DTV::ServicetypeType::DATA, _TXT("data") },
|
|
119
|
+
{ JsonData::DTV::ServicetypeType::MPEG2_HD, _TXT("mpeg2_hd") },
|
|
120
|
+
{ JsonData::DTV::ServicetypeType::AVC_SD_TV, _TXT("avc_sd_tv") },
|
|
121
|
+
{ JsonData::DTV::ServicetypeType::AVC_SD_NVOD_TIMESHIFT, _TXT("avc_sd_nvod_timeshift") },
|
|
122
|
+
{ JsonData::DTV::ServicetypeType::AVC_SD_NVOD, _TXT("avc_sd_nvod") },
|
|
123
|
+
{ JsonData::DTV::ServicetypeType::HD_TV, _TXT("hd_tv") },
|
|
124
|
+
{ JsonData::DTV::ServicetypeType::AVC_HD_NVOD_TIMESHIFT, _TXT("avc_hd_nvod_timeshift") },
|
|
125
|
+
{ JsonData::DTV::ServicetypeType::AVC_HD_NVOD, _TXT("avc_hd_nvod") },
|
|
126
|
+
{ JsonData::DTV::ServicetypeType::UHD_TV, _TXT("uhd_tv") },
|
|
127
|
+
{ JsonData::DTV::ServicetypeType::UNKNOWN, _TXT("unknown") },
|
|
128
|
+
ENUM_CONVERSION_END(JsonData::DTV::ServicetypeType)
|
|
129
|
+
|
|
130
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::RunningstatusType)
|
|
131
|
+
{ JsonData::DTV::RunningstatusType::UNDEFINED, _TXT("undefined") },
|
|
132
|
+
{ JsonData::DTV::RunningstatusType::NOTRUNNING, _TXT("notrunning") },
|
|
133
|
+
{ JsonData::DTV::RunningstatusType::STARTSSOON, _TXT("startssoon") },
|
|
134
|
+
{ JsonData::DTV::RunningstatusType::PAUSING, _TXT("pausing") },
|
|
135
|
+
{ JsonData::DTV::RunningstatusType::RUNNING, _TXT("running") },
|
|
136
|
+
{ JsonData::DTV::RunningstatusType::OFFAIR, _TXT("offair") },
|
|
137
|
+
ENUM_CONVERSION_END(JsonData::DTV::RunningstatusType)
|
|
138
|
+
|
|
139
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::ComponentData::TypeType)
|
|
140
|
+
{ JsonData::DTV::ComponentData::TypeType::VIDEO, _TXT("video") },
|
|
141
|
+
{ JsonData::DTV::ComponentData::TypeType::AUDIO, _TXT("audio") },
|
|
142
|
+
{ JsonData::DTV::ComponentData::TypeType::SUBTITLES, _TXT("subtitles") },
|
|
143
|
+
{ JsonData::DTV::ComponentData::TypeType::TELETEXT, _TXT("teletext") },
|
|
144
|
+
{ JsonData::DTV::ComponentData::TypeType::DATA, _TXT("data") },
|
|
145
|
+
ENUM_CONVERSION_END(JsonData::DTV::ComponentData::TypeType)
|
|
146
|
+
|
|
147
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::CodecType)
|
|
148
|
+
{ JsonData::DTV::CodecType::MPEG2, _TXT("mpeg2") },
|
|
149
|
+
{ JsonData::DTV::CodecType::H264, _TXT("h264") },
|
|
150
|
+
{ JsonData::DTV::CodecType::H265, _TXT("h265") },
|
|
151
|
+
{ JsonData::DTV::CodecType::AVS, _TXT("avs") },
|
|
152
|
+
{ JsonData::DTV::CodecType::MPEG1, _TXT("mpeg1") },
|
|
153
|
+
{ JsonData::DTV::CodecType::AAC, _TXT("aac") },
|
|
154
|
+
{ JsonData::DTV::CodecType::HEAAC, _TXT("heaac") },
|
|
155
|
+
{ JsonData::DTV::CodecType::HEAACV2, _TXT("heaacv2") },
|
|
156
|
+
{ JsonData::DTV::CodecType::AC3, _TXT("ac3") },
|
|
157
|
+
{ JsonData::DTV::CodecType::EAC3, _TXT("eac3") },
|
|
158
|
+
ENUM_CONVERSION_END(JsonData::DTV::CodecType)
|
|
159
|
+
|
|
160
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::ComponentData::AudioData::TypeType)
|
|
161
|
+
{ JsonData::DTV::ComponentData::AudioData::TypeType::UNDEFINED, _TXT("undefined") },
|
|
162
|
+
{ JsonData::DTV::ComponentData::AudioData::TypeType::CLEAN, _TXT("clean") },
|
|
163
|
+
{ JsonData::DTV::ComponentData::AudioData::TypeType::HEARINGIMPAIRED, _TXT("hearingimpaired") },
|
|
164
|
+
{ JsonData::DTV::ComponentData::AudioData::TypeType::VISUALLYIMPAIRED, _TXT("visuallyimpaired") },
|
|
165
|
+
{ JsonData::DTV::ComponentData::AudioData::TypeType::UNKNOWN, _TXT("unknown") },
|
|
166
|
+
ENUM_CONVERSION_END(JsonData::DTV::ComponentData::AudioData::TypeType)
|
|
167
|
+
|
|
168
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::ComponentData::AudioData::ModeType)
|
|
169
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::MONO, _TXT("mono") },
|
|
170
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::LEFT, _TXT("left") },
|
|
171
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::RIGHT, _TXT("right") },
|
|
172
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::STEREO, _TXT("stereo") },
|
|
173
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::MULTICHANNEL, _TXT("multichannel") },
|
|
174
|
+
{ JsonData::DTV::ComponentData::AudioData::ModeType::UNDEFINED, _TXT("undefined") },
|
|
175
|
+
ENUM_CONVERSION_END(JsonData::DTV::ComponentData::AudioData::ModeType)
|
|
176
|
+
|
|
177
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::ComponentData::SubtitlesData::FormatType)
|
|
178
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::DEFAULT, _TXT("default") },
|
|
179
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::E4_3, _TXT("4_3") },
|
|
180
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::E16_9, _TXT("16_9") },
|
|
181
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::E221_1, _TXT("221_1") },
|
|
182
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HD, _TXT("hd") },
|
|
183
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HARDOFHEARING, _TXT("hardofhearing") },
|
|
184
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HARDOFHEARING4_3, _TXT("hardofhearing4_3") },
|
|
185
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HARDOFHEARING16_9, _TXT("hardofhearing16_9") },
|
|
186
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HARDOFHEARING221_1, _TXT("hardofhearing221_1") },
|
|
187
|
+
{ JsonData::DTV::ComponentData::SubtitlesData::FormatType::HARDOFHEARINGHD, _TXT("hardofhearinghd") },
|
|
188
|
+
ENUM_CONVERSION_END(JsonData::DTV::ComponentData::SubtitlesData::FormatType)
|
|
189
|
+
|
|
190
|
+
ENUM_CONVERSION_BEGIN(JsonData::DTV::EventtypeType)
|
|
191
|
+
{ JsonData::DTV::EventtypeType::SERVICESEARCHSTATUS, _TXT("ServiceSearchStatus") },
|
|
192
|
+
{ JsonData::DTV::EventtypeType::SERVICEUPDATED, _TXT("serviceupdated") },
|
|
193
|
+
{ JsonData::DTV::EventtypeType::SERVICEADDED, _TXT("serviceadded") },
|
|
194
|
+
{ JsonData::DTV::EventtypeType::SERVICEDELETED, _TXT("servicedeleted") },
|
|
195
|
+
{ JsonData::DTV::EventtypeType::VIDEOCHANGED, _TXT("videochanged") },
|
|
196
|
+
{ JsonData::DTV::EventtypeType::AUDIOCHANGED, _TXT("audiochanged") },
|
|
197
|
+
{ JsonData::DTV::EventtypeType::SUBTITLESCHANGED, _TXT("subtitleschanged") },
|
|
198
|
+
{ JsonData::DTV::EventtypeType::EVENTCHANGED, _TXT("eventchanged") },
|
|
199
|
+
ENUM_CONVERSION_END(JsonData::DTV::EventtypeType)
|
|
200
|
+
|
|
201
|
+
}
|
|
@@ -0,0 +1,190 @@
|
|
|
1
|
+
// Enumeration code for Device Info API.
|
|
2
|
+
// Generated automatically from 'DeviceInfo.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_DeviceInfo.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::VideodisplayType)
|
|
12
|
+
{ JsonData::DeviceInfo::VideodisplayType::OTHER, _TXT("OTHER") },
|
|
13
|
+
{ JsonData::DeviceInfo::VideodisplayType::RF_MODULATOR, _TXT("RF_MODULATOR") },
|
|
14
|
+
{ JsonData::DeviceInfo::VideodisplayType::COMPOSITE, _TXT("COMPOSITE") },
|
|
15
|
+
{ JsonData::DeviceInfo::VideodisplayType::SVIDEO, _TXT("SVIDEO") },
|
|
16
|
+
{ JsonData::DeviceInfo::VideodisplayType::COMPONET, _TXT("COMPONET") },
|
|
17
|
+
{ JsonData::DeviceInfo::VideodisplayType::SCART_RGB, _TXT("SCART_RGB") },
|
|
18
|
+
{ JsonData::DeviceInfo::VideodisplayType::HDMI0, _TXT("HDMI0") },
|
|
19
|
+
{ JsonData::DeviceInfo::VideodisplayType::HDMI1, _TXT("HDMI1") },
|
|
20
|
+
{ JsonData::DeviceInfo::VideodisplayType::DISPLAYPORT, _TXT("DISPLAYPORT") },
|
|
21
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::VideodisplayType)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::Output_resolutionType)
|
|
24
|
+
{ JsonData::DeviceInfo::Output_resolutionType::UNKNOWN, _TXT("unknown") },
|
|
25
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E480I, _TXT("480i") },
|
|
26
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E480P, _TXT("480p") },
|
|
27
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E576I, _TXT("576i") },
|
|
28
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E576P, _TXT("576p") },
|
|
29
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E576P50, _TXT("576p50") },
|
|
30
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P, _TXT("720p") },
|
|
31
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P24, _TXT("720p24") },
|
|
32
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P25, _TXT("720p25") },
|
|
33
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P30, _TXT("720p30") },
|
|
34
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P50, _TXT("720p50") },
|
|
35
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E720P60, _TXT("720p60") },
|
|
36
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080I, _TXT("1080i") },
|
|
37
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080I25, _TXT("1080i25") },
|
|
38
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080I50, _TXT("1080i50") },
|
|
39
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080I60, _TXT("1080i60") },
|
|
40
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P, _TXT("1080p") },
|
|
41
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P24, _TXT("1080p24") },
|
|
42
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P25, _TXT("1080p25") },
|
|
43
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P30, _TXT("1080p30") },
|
|
44
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P50, _TXT("1080p50") },
|
|
45
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E1080P60, _TXT("1080p60") },
|
|
46
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E2160P24, _TXT("2160p24") },
|
|
47
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E2160P25, _TXT("2160p25") },
|
|
48
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E2160P30, _TXT("2160p30") },
|
|
49
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E2160P50, _TXT("2160p50") },
|
|
50
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E2160P60, _TXT("2160p60") },
|
|
51
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E4320P30, _TXT("4320p30") },
|
|
52
|
+
{ JsonData::DeviceInfo::Output_resolutionType::E4320P60, _TXT("4320p60") },
|
|
53
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::Output_resolutionType)
|
|
54
|
+
|
|
55
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::CopyprotectionType)
|
|
56
|
+
{ JsonData::DeviceInfo::CopyprotectionType::HDCP_UNAVAILABLE, _TXT("unavailable") },
|
|
57
|
+
{ JsonData::DeviceInfo::CopyprotectionType::HDCP_14, _TXT("1.4") },
|
|
58
|
+
{ JsonData::DeviceInfo::CopyprotectionType::HDCP_20, _TXT("2.0") },
|
|
59
|
+
{ JsonData::DeviceInfo::CopyprotectionType::HDCP_21, _TXT("2.1") },
|
|
60
|
+
{ JsonData::DeviceInfo::CopyprotectionType::HDCP_22, _TXT("2.2") },
|
|
61
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::CopyprotectionType)
|
|
62
|
+
|
|
63
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::AudioportType)
|
|
64
|
+
{ JsonData::DeviceInfo::AudioportType::OTHER, _TXT("OTHER") },
|
|
65
|
+
{ JsonData::DeviceInfo::AudioportType::RF_MODULATOR, _TXT("RF_MODULATOR") },
|
|
66
|
+
{ JsonData::DeviceInfo::AudioportType::ANALOG, _TXT("ANALOG") },
|
|
67
|
+
{ JsonData::DeviceInfo::AudioportType::SPDIF0, _TXT("SPDIF0") },
|
|
68
|
+
{ JsonData::DeviceInfo::AudioportType::HDMI0, _TXT("HDMI0") },
|
|
69
|
+
{ JsonData::DeviceInfo::AudioportType::HDMI1, _TXT("HDMI1") },
|
|
70
|
+
{ JsonData::DeviceInfo::AudioportType::DISPLAYPORT, _TXT("DISPLAYPORT") },
|
|
71
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::AudioportType)
|
|
72
|
+
|
|
73
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::AudiocapabilityType)
|
|
74
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::NONE, _TXT("none") },
|
|
75
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::ATMOS, _TXT("ATMOS") },
|
|
76
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::DD, _TXT("DOLBY DIGITAL") },
|
|
77
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::DDPLUS, _TXT("DOLBY DIGITAL PLUS") },
|
|
78
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::DAD, _TXT("Dual Audio Decode") },
|
|
79
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::DAPV2, _TXT("DAPv2") },
|
|
80
|
+
{ JsonData::DeviceInfo::AudiocapabilityType::MS12, _TXT("MS12") },
|
|
81
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::AudiocapabilityType)
|
|
82
|
+
|
|
83
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::Ms12capabilityType)
|
|
84
|
+
{ JsonData::DeviceInfo::Ms12capabilityType::NONE, _TXT("none") },
|
|
85
|
+
{ JsonData::DeviceInfo::Ms12capabilityType::DOLBYVOLUME, _TXT("Dolby Volume") },
|
|
86
|
+
{ JsonData::DeviceInfo::Ms12capabilityType::INTELIGENTEQUALIZER, _TXT("Inteligent Equalizer") },
|
|
87
|
+
{ JsonData::DeviceInfo::Ms12capabilityType::DIALOGUEENHANCER, _TXT("Dialogue Enhancer") },
|
|
88
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::Ms12capabilityType)
|
|
89
|
+
|
|
90
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::Ms12profileType)
|
|
91
|
+
{ JsonData::DeviceInfo::Ms12profileType::NONE, _TXT("None") },
|
|
92
|
+
{ JsonData::DeviceInfo::Ms12profileType::MUSIC, _TXT("Music") },
|
|
93
|
+
{ JsonData::DeviceInfo::Ms12profileType::MOVIE, _TXT("Movie") },
|
|
94
|
+
{ JsonData::DeviceInfo::Ms12profileType::VOICE, _TXT("Voice") },
|
|
95
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::Ms12profileType)
|
|
96
|
+
|
|
97
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::FirmwareversionData::YoctoType)
|
|
98
|
+
{ JsonData::DeviceInfo::FirmwareversionData::YoctoType::DUNFELL, _TXT("dunfell") },
|
|
99
|
+
{ JsonData::DeviceInfo::FirmwareversionData::YoctoType::MORTY, _TXT("morty") },
|
|
100
|
+
{ JsonData::DeviceInfo::FirmwareversionData::YoctoType::DAISY, _TXT("daisy") },
|
|
101
|
+
{ JsonData::DeviceInfo::FirmwareversionData::YoctoType::KIRKSTONE, _TXT("kirkstone") },
|
|
102
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::FirmwareversionData::YoctoType)
|
|
103
|
+
|
|
104
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::MakeData::MakeType)
|
|
105
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::PLATCO, _TXT("platco") },
|
|
106
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::LLAMA, _TXT("llama") },
|
|
107
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::HISENSE, _TXT("hisense") },
|
|
108
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::ELEMENT, _TXT("element") },
|
|
109
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::SKY, _TXT("sky") },
|
|
110
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::SERCOMM, _TXT("sercomm") },
|
|
111
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::COMMSCOPE, _TXT("commscope") },
|
|
112
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::ARRIS, _TXT("arris") },
|
|
113
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::CISCO, _TXT("cisco") },
|
|
114
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::PACE, _TXT("pace") },
|
|
115
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::SAMSUNG, _TXT("samsung") },
|
|
116
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::TECHNICOLOR, _TXT("technicolor") },
|
|
117
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::AMLOGIC_INC, _TXT("Amlogic_Inc") },
|
|
118
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::RASPBERRYPI_ORG, _TXT("raspberrypi_org") },
|
|
119
|
+
{ JsonData::DeviceInfo::MakeData::MakeType::PIONEER, _TXT("Pioneer") },
|
|
120
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::MakeData::MakeType)
|
|
121
|
+
|
|
122
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::ModelidData::SkuType)
|
|
123
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PLTL11AEI, _TXT("PLTL11AEI") },
|
|
124
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::ZWCN11MWI, _TXT("ZWCN11MWI") },
|
|
125
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SKTL11AEI, _TXT("SKTL11AEI") },
|
|
126
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::LS301, _TXT("LS301") },
|
|
127
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::HSTP11MWR, _TXT("HSTP11MWR") },
|
|
128
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::HSTP11MWRFX50, _TXT("HSTP11MWRFX50") },
|
|
129
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::ELTE11MWR, _TXT("ELTE11MWR") },
|
|
130
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SKXI11ADS, _TXT("SKXI11ADS") },
|
|
131
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SKXI11AIS, _TXT("SKXI11AIS") },
|
|
132
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SKXI11ANS, _TXT("SKXI11ANS") },
|
|
133
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SCXI11AIC, _TXT("SCXI11AIC") },
|
|
134
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SCXI11BEI, _TXT("SCXI11BEI") },
|
|
135
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::CMXI11BEI, _TXT("CMXI11BEI") },
|
|
136
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::AX013AN, _TXT("AX013AN") },
|
|
137
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::AX014AN, _TXT("AX014AN") },
|
|
138
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::AX061AEI, _TXT("AX061AEI") },
|
|
139
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::MX011AN, _TXT("MX011AN") },
|
|
140
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::CS011AN, _TXT("CS011AN") },
|
|
141
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::CXD01ANI, _TXT("CXD01ANI") },
|
|
142
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PX001AN, _TXT("PX001AN") },
|
|
143
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PX013AN, _TXT("PX013AN") },
|
|
144
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PX022AN, _TXT("PX022AN") },
|
|
145
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PX032ANI, _TXT("PX032ANI") },
|
|
146
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PX051AEI, _TXT("PX051AEI") },
|
|
147
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PXD01ANI, _TXT("PXD01ANI") },
|
|
148
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::SX022AN, _TXT("SX022AN") },
|
|
149
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::TX061AEI, _TXT("TX061AEI") },
|
|
150
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PI, _TXT("PI") },
|
|
151
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::XUSHTC11MWR, _TXT("XUSHTC11MWR") },
|
|
152
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::XUSPTC11MWR, _TXT("XUSPTC11MWR") },
|
|
153
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::XUSHTB11MWR, _TXT("XUSHTB11MWR") },
|
|
154
|
+
{ JsonData::DeviceInfo::ModelidData::SkuType::PITU11MWR, _TXT("PITU11MWR") },
|
|
155
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::ModelidData::SkuType)
|
|
156
|
+
|
|
157
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::DevicetypeData::DevicetypeType)
|
|
158
|
+
{ JsonData::DeviceInfo::DevicetypeData::DevicetypeType::TV, _TXT("tv") },
|
|
159
|
+
{ JsonData::DeviceInfo::DevicetypeData::DevicetypeType::IPSTB, _TXT("IpStb") },
|
|
160
|
+
{ JsonData::DeviceInfo::DevicetypeData::DevicetypeType::QAMIPSTB, _TXT("QamIpStb") },
|
|
161
|
+
{ JsonData::DeviceInfo::DevicetypeData::DevicetypeType::HYBRID, _TXT("hybrid") },
|
|
162
|
+
{ JsonData::DeviceInfo::DevicetypeData::DevicetypeType::MEDIACLIENT, _TXT("mediaclient") },
|
|
163
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::DevicetypeData::DevicetypeType)
|
|
164
|
+
|
|
165
|
+
ENUM_CONVERSION_BEGIN(JsonData::DeviceInfo::DistributoridData::DistributoridType)
|
|
166
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::COMCAST, _TXT("comcast") },
|
|
167
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::XGLOBAL, _TXT("xglobal") },
|
|
168
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_DE, _TXT("sky-de") },
|
|
169
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_ITALIA, _TXT("sky-italia") },
|
|
170
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_UK, _TXT("sky-uk") },
|
|
171
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_UK_DEV, _TXT("sky-uk-dev") },
|
|
172
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_DEU, _TXT("sky-deu") },
|
|
173
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_DEU_DEV, _TXT("sky-deu-dev") },
|
|
174
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_IT, _TXT("sky-it") },
|
|
175
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SKY_IT_DEV, _TXT("sky-it-dev") },
|
|
176
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::COX, _TXT("cox") },
|
|
177
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::COX_HOSPITALITY, _TXT("cox-hospitality") },
|
|
178
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::COX_DEV, _TXT("cox-dev") },
|
|
179
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::COX_QA, _TXT("cox-qa") },
|
|
180
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::MIT, _TXT("MIT") },
|
|
181
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SHAW, _TXT("shaw") },
|
|
182
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::SHAW_DEV, _TXT("shaw-dev") },
|
|
183
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::ROGERS, _TXT("rogers") },
|
|
184
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::ROGERS_DEV, _TXT("rogers-dev") },
|
|
185
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::VIDEOTRON, _TXT("videotron") },
|
|
186
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::CHARTER, _TXT("charter") },
|
|
187
|
+
{ JsonData::DeviceInfo::DistributoridData::DistributoridType::CHARTER_DEV, _TXT("charter-dev") },
|
|
188
|
+
ENUM_CONVERSION_END(JsonData::DeviceInfo::DistributoridData::DistributoridType)
|
|
189
|
+
|
|
190
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for Dictionary API.
|
|
2
|
+
// Generated automatically from 'IDictionary.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDictionary.h>
|
|
8
|
+
#include "JsonData_Dictionary.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDictionary::Type)
|
|
13
|
+
{ Exchange::IDictionary::Type::NAMESPACE, _TXT("Namespace") },
|
|
14
|
+
{ Exchange::IDictionary::Type::PERSISTENT_KEY, _TXT("PersistentKey") },
|
|
15
|
+
{ Exchange::IDictionary::Type::VOLATILE_KEY, _TXT("VolatileKey") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IDictionary::Type)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
// Enumeration code for DisplayProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDisplayInfo.h>
|
|
8
|
+
#include "JsonData_DisplayProperties.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::ColourSpaceType)
|
|
13
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_UNKNOWN, _TXT("FormatUnknown") },
|
|
14
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_OTHER, _TXT("FormatOther") },
|
|
15
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_RGB_444, _TXT("FormatRgb444") },
|
|
16
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_YCBCR_444, _TXT("FormatYcbcr444") },
|
|
17
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_YCBCR_422, _TXT("FormatYcbcr422") },
|
|
18
|
+
{ Exchange::IDisplayProperties::ColourSpaceType::FORMAT_YCBCR_420, _TXT("FormatYcbcr420") },
|
|
19
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::ColourSpaceType)
|
|
20
|
+
|
|
21
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::FrameRateType)
|
|
22
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_UNKNOWN, _TXT("FramerateUnknown") },
|
|
23
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_23_976, _TXT("Framerate23976") },
|
|
24
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_24, _TXT("Framerate24") },
|
|
25
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_25, _TXT("Framerate25") },
|
|
26
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_29_97, _TXT("Framerate2997") },
|
|
27
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_30, _TXT("Framerate30") },
|
|
28
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_47_952, _TXT("Framerate47952") },
|
|
29
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_48, _TXT("Framerate48") },
|
|
30
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_50, _TXT("Framerate50") },
|
|
31
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_59_94, _TXT("Framerate5994") },
|
|
32
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_60, _TXT("Framerate60") },
|
|
33
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_119_88, _TXT("Framerate11988") },
|
|
34
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_120, _TXT("Framerate120") },
|
|
35
|
+
{ Exchange::IDisplayProperties::FrameRateType::FRAMERATE_144, _TXT("Framerate144") },
|
|
36
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::FrameRateType)
|
|
37
|
+
|
|
38
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::ColourDepthType)
|
|
39
|
+
{ Exchange::IDisplayProperties::ColourDepthType::COLORDEPTH_UNKNOWN, _TXT("ColordepthUnknown") },
|
|
40
|
+
{ Exchange::IDisplayProperties::ColourDepthType::COLORDEPTH_8_BIT, _TXT("Colordepth8Bit") },
|
|
41
|
+
{ Exchange::IDisplayProperties::ColourDepthType::COLORDEPTH_10_BIT, _TXT("Colordepth10Bit") },
|
|
42
|
+
{ Exchange::IDisplayProperties::ColourDepthType::COLORDEPTH_12_BIT, _TXT("Colordepth12Bit") },
|
|
43
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::ColourDepthType)
|
|
44
|
+
|
|
45
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::ColorimetryType)
|
|
46
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_UNKNOWN, _TXT("ColorimetryUnknown") },
|
|
47
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_OTHER, _TXT("ColorimetryOther") },
|
|
48
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_SMPTE170M, _TXT("ColorimetrySmpte170M") },
|
|
49
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_BT709, _TXT("ColorimetryBt709") },
|
|
50
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_XVYCC601, _TXT("ColorimetryXvycc601") },
|
|
51
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_XVYCC709, _TXT("ColorimetryXvycc709") },
|
|
52
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_SYCC601, _TXT("ColorimetrySycc601") },
|
|
53
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_OPYCC601, _TXT("ColorimetryOpycc601") },
|
|
54
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_OPRGB, _TXT("ColorimetryOprgb") },
|
|
55
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_BT2020YCCBCBRC, _TXT("ColorimetryBt2020Yccbcbrc") },
|
|
56
|
+
{ Exchange::IDisplayProperties::ColorimetryType::COLORIMETRY_BT2020RGB_YCBCR, _TXT("ColorimetryBt2020RgbYcbcr") },
|
|
57
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::ColorimetryType)
|
|
58
|
+
|
|
59
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::QuantizationRangeType)
|
|
60
|
+
{ Exchange::IDisplayProperties::QuantizationRangeType::QUANTIZATIONRANGE_UNKNOWN, _TXT("QuantizationrangeUnknown") },
|
|
61
|
+
{ Exchange::IDisplayProperties::QuantizationRangeType::QUANTIZATIONRANGE_LIMITED, _TXT("QuantizationrangeLimited") },
|
|
62
|
+
{ Exchange::IDisplayProperties::QuantizationRangeType::QUANTIZATIONRANGE_FULL, _TXT("QuantizationrangeFull") },
|
|
63
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::QuantizationRangeType)
|
|
64
|
+
|
|
65
|
+
ENUM_CONVERSION_BEGIN(Exchange::IDisplayProperties::EotfType)
|
|
66
|
+
{ Exchange::IDisplayProperties::EotfType::EOTF_UNKNOWN, _TXT("EotfUnknown") },
|
|
67
|
+
{ Exchange::IDisplayProperties::EotfType::EOTF_OTHER, _TXT("EotfOther") },
|
|
68
|
+
{ Exchange::IDisplayProperties::EotfType::EOTF_BT1886, _TXT("EotfBt1886") },
|
|
69
|
+
{ Exchange::IDisplayProperties::EotfType::EOTF_BT2100, _TXT("EotfBt2100") },
|
|
70
|
+
{ Exchange::IDisplayProperties::EotfType::EOTF_SMPTE_ST_2084, _TXT("EotfSmpteSt2084") },
|
|
71
|
+
ENUM_CONVERSION_END(Exchange::IDisplayProperties::EotfType)
|
|
72
|
+
|
|
73
|
+
}
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
// Enumeration code for Output API.
|
|
2
|
+
// Generated automatically from 'IDolby.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDolby.h>
|
|
8
|
+
#include "JsonData_DolbyOutput.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::Dolby::IOutput::SoundModes)
|
|
13
|
+
{ Exchange::Dolby::IOutput::SoundModes::UNKNOWN, _TXT("Unknown") },
|
|
14
|
+
{ Exchange::Dolby::IOutput::SoundModes::MONO, _TXT("Mono") },
|
|
15
|
+
{ Exchange::Dolby::IOutput::SoundModes::STEREO, _TXT("Stereo") },
|
|
16
|
+
{ Exchange::Dolby::IOutput::SoundModes::SURROUND, _TXT("Surround") },
|
|
17
|
+
{ Exchange::Dolby::IOutput::SoundModes::PASSTHRU, _TXT("Passthru") },
|
|
18
|
+
{ Exchange::Dolby::IOutput::SoundModes::DOLBYDIGITAL, _TXT("Dolbydigital") },
|
|
19
|
+
{ Exchange::Dolby::IOutput::SoundModes::DOLBYDIGITALPLUS, _TXT("Dolbydigitalplus") },
|
|
20
|
+
{ Exchange::Dolby::IOutput::SoundModes::SOUNDMODE_AUTO, _TXT("SoundmodeAuto") },
|
|
21
|
+
ENUM_CONVERSION_END(Exchange::Dolby::IOutput::SoundModes)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(Exchange::Dolby::IOutput::Type)
|
|
24
|
+
{ Exchange::Dolby::IOutput::Type::DIGITAL_PCM, _TXT("DigitalPcm") },
|
|
25
|
+
{ Exchange::Dolby::IOutput::Type::DIGITAL_PLUS, _TXT("DigitalPlus") },
|
|
26
|
+
{ Exchange::Dolby::IOutput::Type::DIGITAL_AC3, _TXT("DigitalAc3") },
|
|
27
|
+
{ Exchange::Dolby::IOutput::Type::AUTO, _TXT("Auto") },
|
|
28
|
+
{ Exchange::Dolby::IOutput::Type::DIGITAL_PASSTHROUGH, _TXT("DigitalPassthrough") },
|
|
29
|
+
{ Exchange::Dolby::IOutput::Type::MS12, _TXT("Ms12") },
|
|
30
|
+
ENUM_CONVERSION_END(Exchange::Dolby::IOutput::Type)
|
|
31
|
+
|
|
32
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
// Enumeration code for Firmware Control API.
|
|
2
|
+
// Generated automatically from 'FirmwareControl.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_FirmwareControl.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::FirmwareControl::UpgradeParamsData::TypeType)
|
|
12
|
+
{ JsonData::FirmwareControl::UpgradeParamsData::TypeType::CDL, _TXT("CDL") },
|
|
13
|
+
{ JsonData::FirmwareControl::UpgradeParamsData::TypeType::RCDL, _TXT("RCDL") },
|
|
14
|
+
ENUM_CONVERSION_END(JsonData::FirmwareControl::UpgradeParamsData::TypeType)
|
|
15
|
+
|
|
16
|
+
ENUM_CONVERSION_BEGIN(JsonData::FirmwareControl::StatusType)
|
|
17
|
+
{ JsonData::FirmwareControl::StatusType::NONE, _TXT("none") },
|
|
18
|
+
{ JsonData::FirmwareControl::StatusType::UPGRADESTARTED, _TXT("upgradestarted") },
|
|
19
|
+
{ JsonData::FirmwareControl::StatusType::DOWNLOADSTARTED, _TXT("downloadstarted") },
|
|
20
|
+
{ JsonData::FirmwareControl::StatusType::DOWNLOADABORTED, _TXT("downloadaborted") },
|
|
21
|
+
{ JsonData::FirmwareControl::StatusType::DOWNLOADCOMPLETED, _TXT("downloadcompleted") },
|
|
22
|
+
{ JsonData::FirmwareControl::StatusType::INSTALLINITIATED, _TXT("installinitiated") },
|
|
23
|
+
{ JsonData::FirmwareControl::StatusType::INSTALLNOTSTARTED, _TXT("installnotstarted") },
|
|
24
|
+
{ JsonData::FirmwareControl::StatusType::INSTALLABORTED, _TXT("installaborted") },
|
|
25
|
+
{ JsonData::FirmwareControl::StatusType::INSTALLSTARTED, _TXT("installstarted") },
|
|
26
|
+
{ JsonData::FirmwareControl::StatusType::UPGRADECOMPLETED, _TXT("upgradecompleted") },
|
|
27
|
+
{ JsonData::FirmwareControl::StatusType::UPGRADECANCELLED, _TXT("upgradecancelled") },
|
|
28
|
+
ENUM_CONVERSION_END(JsonData::FirmwareControl::StatusType)
|
|
29
|
+
|
|
30
|
+
ENUM_CONVERSION_BEGIN(JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType)
|
|
31
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::NONE, _TXT("none") },
|
|
32
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::GENERIC, _TXT("generic") },
|
|
33
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::INVALIDPARAMETERS, _TXT("invalidparameters") },
|
|
34
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::INVALIDSTATE, _TXT("invalidstate") },
|
|
35
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::NOENOUGHSPACE, _TXT("noenoughspace") },
|
|
36
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::OPERATIONOTSUPPORTED, _TXT("operationotsupported") },
|
|
37
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::INCORRECTHASH, _TXT("incorrecthash") },
|
|
38
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::UNAUTHENTICATED, _TXT("unauthenticated") },
|
|
39
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::UNAVAILABLE, _TXT("unavailable") },
|
|
40
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::TIMEDOUT, _TXT("timedout") },
|
|
41
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::DOWNLOADDIRECTORYNOTEXIST, _TXT("downloaddirectorynotexist") },
|
|
42
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::RESUMENOTSUPPORTED, _TXT("resumenotsupported") },
|
|
43
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::INVALIDRANGE, _TXT("invalidrange") },
|
|
44
|
+
{ JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType::UNKOWN, _TXT("unkown") },
|
|
45
|
+
ENUM_CONVERSION_END(JsonData::FirmwareControl::UpgradeprogressParamsData::ErrorType)
|
|
46
|
+
|
|
47
|
+
}
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
// Enumeration code for HDRProperties API.
|
|
2
|
+
// Generated automatically from 'IDisplayInfo.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IDisplayInfo.h>
|
|
8
|
+
#include "JsonData_HDRProperties.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IHDRProperties::HDRType)
|
|
13
|
+
{ Exchange::IHDRProperties::HDRType::HDR_OFF, _TXT("HdrOff") },
|
|
14
|
+
{ Exchange::IHDRProperties::HDRType::HDR_10, _TXT("Hdr10") },
|
|
15
|
+
{ Exchange::IHDRProperties::HDRType::HDR_10PLUS, _TXT("Hdr10Plus") },
|
|
16
|
+
{ Exchange::IHDRProperties::HDRType::HDR_HLG, _TXT("HdrHlg") },
|
|
17
|
+
{ Exchange::IHDRProperties::HDRType::HDR_DOLBYVISION, _TXT("HdrDolbyvision") },
|
|
18
|
+
{ Exchange::IHDRProperties::HDRType::HDR_TECHNICOLOR, _TXT("HdrTechnicolor") },
|
|
19
|
+
ENUM_CONVERSION_END(Exchange::IHDRProperties::HDRType)
|
|
20
|
+
|
|
21
|
+
}
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
// Enumeration code for MemoryMonitor API.
|
|
2
|
+
// Generated automatically from 'IMemoryMonitor.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IMemoryMonitor.h>
|
|
8
|
+
#include "JsonData_MemoryMonitor.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IMemoryMonitor::INotification::action)
|
|
13
|
+
{ Exchange::IMemoryMonitor::INotification::action::DEACTIVATED, _TXT("Deactivated") },
|
|
14
|
+
{ Exchange::IMemoryMonitor::INotification::action::ACTIVATED, _TXT("Activated") },
|
|
15
|
+
{ Exchange::IMemoryMonitor::INotification::action::RESTARTING_STOPPED, _TXT("RestartingStopped") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IMemoryMonitor::INotification::action)
|
|
17
|
+
|
|
18
|
+
ENUM_CONVERSION_BEGIN(Exchange::IMemoryMonitor::INotification::reason)
|
|
19
|
+
{ Exchange::IMemoryMonitor::INotification::reason::EXCEEDED_MEMORY, _TXT("ExceededMemory") },
|
|
20
|
+
{ Exchange::IMemoryMonitor::INotification::reason::NOT_OPERATIONAL, _TXT("NotOperational") },
|
|
21
|
+
ENUM_CONVERSION_END(Exchange::IMemoryMonitor::INotification::reason)
|
|
22
|
+
|
|
23
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
// Enumeration code for MessagingControl API.
|
|
2
|
+
// Generated automatically from 'IMessagingControl.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IMessagingControl.h>
|
|
8
|
+
#include "JsonData_MessagingControl.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IMessagingControl::messagetype)
|
|
13
|
+
{ Exchange::IMessagingControl::messagetype::INVALID, _TXT("Invalid") },
|
|
14
|
+
{ Exchange::IMessagingControl::messagetype::TRACING, _TXT("Tracing") },
|
|
15
|
+
{ Exchange::IMessagingControl::messagetype::LOGGING, _TXT("Logging") },
|
|
16
|
+
{ Exchange::IMessagingControl::messagetype::REPORTING, _TXT("Reporting") },
|
|
17
|
+
{ Exchange::IMessagingControl::messagetype::OPERATIONAL_STREAM, _TXT("OperationalStream") },
|
|
18
|
+
{ Exchange::IMessagingControl::messagetype::ASSERT, _TXT("Assert") },
|
|
19
|
+
{ Exchange::IMessagingControl::messagetype::TELEMETRY, _TXT("Telemetry") },
|
|
20
|
+
ENUM_CONVERSION_END(Exchange::IMessagingControl::messagetype)
|
|
21
|
+
|
|
22
|
+
}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
// Enumeration code for Messenger API.
|
|
2
|
+
// Generated automatically from 'IMessenger.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IMessenger.h>
|
|
8
|
+
#include "JsonData_Messenger.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IMessenger::security)
|
|
13
|
+
{ Exchange::JSONRPC::IMessenger::security::INSECURE, _TXT("insecure") },
|
|
14
|
+
{ Exchange::JSONRPC::IMessenger::security::SECURE, _TXT("secure") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IMessenger::security)
|
|
16
|
+
|
|
17
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IMessenger::INotification::roomupdate)
|
|
18
|
+
{ Exchange::JSONRPC::IMessenger::INotification::roomupdate::CREATED, _TXT("created") },
|
|
19
|
+
{ Exchange::JSONRPC::IMessenger::INotification::roomupdate::DESTROYED, _TXT("destroyed") },
|
|
20
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IMessenger::INotification::roomupdate)
|
|
21
|
+
|
|
22
|
+
ENUM_CONVERSION_BEGIN(Exchange::JSONRPC::IMessenger::INotification::userupdate)
|
|
23
|
+
{ Exchange::JSONRPC::IMessenger::INotification::userupdate::JOINED, _TXT("joined") },
|
|
24
|
+
{ Exchange::JSONRPC::IMessenger::INotification::userupdate::LEFT, _TXT("left") },
|
|
25
|
+
ENUM_CONVERSION_END(Exchange::JSONRPC::IMessenger::INotification::userupdate)
|
|
26
|
+
|
|
27
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
// Enumeration code for Netflix API.
|
|
2
|
+
// Generated automatically from 'Netflix.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Netflix.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::Netflix::VisibilityType)
|
|
12
|
+
{ JsonData::Netflix::VisibilityType::VISIBLE, _TXT("visible") },
|
|
13
|
+
{ JsonData::Netflix::VisibilityType::HIDDEN, _TXT("hidden") },
|
|
14
|
+
ENUM_CONVERSION_END(JsonData::Netflix::VisibilityType)
|
|
15
|
+
|
|
16
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
// Enumeration code for NetworkControl API.
|
|
2
|
+
// Generated automatically from 'INetworkControl.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/INetworkControl.h>
|
|
8
|
+
#include "JsonData_NetworkControl.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::INetworkControl::StatusType)
|
|
13
|
+
{ Exchange::INetworkControl::StatusType::UNAVAILABLE, _TXT("Unavailable") },
|
|
14
|
+
{ Exchange::INetworkControl::StatusType::AVAILABLE, _TXT("Available") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::INetworkControl::StatusType)
|
|
16
|
+
|
|
17
|
+
ENUM_CONVERSION_BEGIN(Exchange::INetworkControl::ModeType)
|
|
18
|
+
{ Exchange::INetworkControl::ModeType::STATIC, _TXT("Static") },
|
|
19
|
+
{ Exchange::INetworkControl::ModeType::DYNAMIC, _TXT("Dynamic") },
|
|
20
|
+
ENUM_CONVERSION_END(Exchange::INetworkControl::ModeType)
|
|
21
|
+
|
|
22
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// Enumeration code for OpenCDMi API.
|
|
2
|
+
// Generated automatically from 'OCDM.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_OCDM.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::OCDM::DrminitializationstatusParamsData::StatusType)
|
|
12
|
+
{ JsonData::OCDM::DrminitializationstatusParamsData::StatusType::BUSY, _TXT("BUSY") },
|
|
13
|
+
{ JsonData::OCDM::DrminitializationstatusParamsData::StatusType::SUCCESS, _TXT("SUCCESS") },
|
|
14
|
+
{ JsonData::OCDM::DrminitializationstatusParamsData::StatusType::FAILED, _TXT("FAILED") },
|
|
15
|
+
ENUM_CONVERSION_END(JsonData::OCDM::DrminitializationstatusParamsData::StatusType)
|
|
16
|
+
|
|
17
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
// Enumeration code for PertsistentStore API.
|
|
2
|
+
// Generated automatically from 'PersistentStore.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_PersistentStore.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::PersistentStore::ScopeType)
|
|
12
|
+
{ JsonData::PersistentStore::ScopeType::DEVICE, _TXT("device") },
|
|
13
|
+
{ JsonData::PersistentStore::ScopeType::ACCOUNT, _TXT("account") },
|
|
14
|
+
ENUM_CONVERSION_END(JsonData::PersistentStore::ScopeType)
|
|
15
|
+
|
|
16
|
+
}
|
|
@@ -0,0 +1,86 @@
|
|
|
1
|
+
// Enumeration code for PlayerProperties API.
|
|
2
|
+
// Generated automatically from 'IPlayerInfo.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IPlayerInfo.h>
|
|
8
|
+
#include "JsonData_PlayerProperties.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IPlayerProperties::AudioCodec)
|
|
13
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_UNDEFINED, _TXT("AudioUndefined") },
|
|
14
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_AAC, _TXT("AudioAac") },
|
|
15
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_AC3, _TXT("AudioAc3") },
|
|
16
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_AC3_PLUS, _TXT("AudioAc3Plus") },
|
|
17
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_DTS, _TXT("AudioDts") },
|
|
18
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_MPEG1, _TXT("AudioMpeg1") },
|
|
19
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_MPEG2, _TXT("AudioMpeg2") },
|
|
20
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_MPEG3, _TXT("AudioMpeg3") },
|
|
21
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_MPEG4, _TXT("AudioMpeg4") },
|
|
22
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_OPUS, _TXT("AudioOpus") },
|
|
23
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_VORBIS_OGG, _TXT("AudioVorbisOgg") },
|
|
24
|
+
{ Exchange::IPlayerProperties::AudioCodec::AUDIO_WAV, _TXT("AudioWav") },
|
|
25
|
+
ENUM_CONVERSION_END(Exchange::IPlayerProperties::AudioCodec)
|
|
26
|
+
|
|
27
|
+
ENUM_CONVERSION_BEGIN(Exchange::IPlayerProperties::VideoCodec)
|
|
28
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_UNDEFINED, _TXT("VideoUndefined") },
|
|
29
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_H263, _TXT("VideoH263") },
|
|
30
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_H264, _TXT("VideoH264") },
|
|
31
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_H265, _TXT("VideoH265") },
|
|
32
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_H265_10, _TXT("VideoH26510") },
|
|
33
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_MPEG, _TXT("VideoMpeg") },
|
|
34
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_MPEG2, _TXT("VideoMpeg2") },
|
|
35
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_MPEG4, _TXT("VideoMpeg4") },
|
|
36
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_VP8, _TXT("VideoVp8") },
|
|
37
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_VP9, _TXT("VideoVp9") },
|
|
38
|
+
{ Exchange::IPlayerProperties::VideoCodec::VIDEO_VP10, _TXT("VideoVp10") },
|
|
39
|
+
ENUM_CONVERSION_END(Exchange::IPlayerProperties::VideoCodec)
|
|
40
|
+
|
|
41
|
+
ENUM_CONVERSION_BEGIN(Exchange::IPlayerProperties::PlaybackResolution)
|
|
42
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_UNKNOWN, _TXT("ResolutionUnknown") },
|
|
43
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480I24, _TXT("Resolution480I24") },
|
|
44
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480I25, _TXT("Resolution480I25") },
|
|
45
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480I30, _TXT("Resolution480I30") },
|
|
46
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480I50, _TXT("Resolution480I50") },
|
|
47
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480I, _TXT("Resolution480I") },
|
|
48
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480P24, _TXT("Resolution480P24") },
|
|
49
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480P25, _TXT("Resolution480P25") },
|
|
50
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480P30, _TXT("Resolution480P30") },
|
|
51
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480P50, _TXT("Resolution480P50") },
|
|
52
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_480P, _TXT("Resolution480P") },
|
|
53
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576I24, _TXT("Resolution576I24") },
|
|
54
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576I25, _TXT("Resolution576I25") },
|
|
55
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576I30, _TXT("Resolution576I30") },
|
|
56
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576I50, _TXT("Resolution576I50") },
|
|
57
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576I, _TXT("Resolution576I") },
|
|
58
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576P24, _TXT("Resolution576P24") },
|
|
59
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576P25, _TXT("Resolution576P25") },
|
|
60
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576P30, _TXT("Resolution576P30") },
|
|
61
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576P50, _TXT("Resolution576P50") },
|
|
62
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_576P, _TXT("Resolution576P") },
|
|
63
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_720P24, _TXT("Resolution720P24") },
|
|
64
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_720P25, _TXT("Resolution720P25") },
|
|
65
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_720P30, _TXT("Resolution720P30") },
|
|
66
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_720P50, _TXT("Resolution720P50") },
|
|
67
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_720P, _TXT("Resolution720P") },
|
|
68
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080I24, _TXT("Resolution1080I24") },
|
|
69
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080I25, _TXT("Resolution1080I25") },
|
|
70
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080I30, _TXT("Resolution1080I30") },
|
|
71
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080I50, _TXT("Resolution1080I50") },
|
|
72
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080I, _TXT("Resolution1080I") },
|
|
73
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080P24, _TXT("Resolution1080P24") },
|
|
74
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080P25, _TXT("Resolution1080P25") },
|
|
75
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080P30, _TXT("Resolution1080P30") },
|
|
76
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080P50, _TXT("Resolution1080P50") },
|
|
77
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_1080P, _TXT("Resolution1080P") },
|
|
78
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P24, _TXT("Resolution2160P24") },
|
|
79
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P25, _TXT("Resolution2160P25") },
|
|
80
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P30, _TXT("Resolution2160P30") },
|
|
81
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P50, _TXT("Resolution2160P50") },
|
|
82
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P60, _TXT("Resolution2160P60") },
|
|
83
|
+
{ Exchange::IPlayerProperties::PlaybackResolution::RESOLUTION_2160P, _TXT("Resolution2160P") },
|
|
84
|
+
ENUM_CONVERSION_END(Exchange::IPlayerProperties::PlaybackResolution)
|
|
85
|
+
|
|
86
|
+
}
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Enumeration code for Power API.
|
|
2
|
+
// Generated automatically from 'IPower.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IPower.h>
|
|
8
|
+
#include "JsonData_Power.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IPower::PCState)
|
|
13
|
+
{ Exchange::IPower::PCState::On, _TXT("On") },
|
|
14
|
+
{ Exchange::IPower::PCState::ActiveStandby, _TXT("ActiveStandby") },
|
|
15
|
+
{ Exchange::IPower::PCState::PassiveStandby, _TXT("PassiveStandby") },
|
|
16
|
+
{ Exchange::IPower::PCState::SuspendToRAM, _TXT("SuspendToRAM") },
|
|
17
|
+
{ Exchange::IPower::PCState::Hibernate, _TXT("Hibernate") },
|
|
18
|
+
{ Exchange::IPower::PCState::PowerOff, _TXT("PowerOff") },
|
|
19
|
+
ENUM_CONVERSION_END(Exchange::IPower::PCState)
|
|
20
|
+
|
|
21
|
+
ENUM_CONVERSION_BEGIN(Exchange::IPower::PCPhase)
|
|
22
|
+
{ Exchange::IPower::PCPhase::Before, _TXT("Before") },
|
|
23
|
+
{ Exchange::IPower::PCPhase::After, _TXT("After") },
|
|
24
|
+
ENUM_CONVERSION_END(Exchange::IPower::PCPhase)
|
|
25
|
+
|
|
26
|
+
}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
// Enumeration code for Remote Control API.
|
|
2
|
+
// Generated automatically from 'RemoteControl.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_RemoteControl.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::RemoteControl::ModifiersType)
|
|
12
|
+
{ JsonData::RemoteControl::ModifiersType::LEFTSHIFT, _TXT("leftshift") },
|
|
13
|
+
{ JsonData::RemoteControl::ModifiersType::RIGHTSHIFT, _TXT("rightshift") },
|
|
14
|
+
{ JsonData::RemoteControl::ModifiersType::LEFTALT, _TXT("leftalt") },
|
|
15
|
+
{ JsonData::RemoteControl::ModifiersType::RIGHTALT, _TXT("rightalt") },
|
|
16
|
+
{ JsonData::RemoteControl::ModifiersType::LEFTCTRL, _TXT("leftctrl") },
|
|
17
|
+
{ JsonData::RemoteControl::ModifiersType::RIGHTCTRL, _TXT("rightctrl") },
|
|
18
|
+
ENUM_CONVERSION_END(JsonData::RemoteControl::ModifiersType)
|
|
19
|
+
|
|
20
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
// Enumeration code for StateControl API.
|
|
2
|
+
// Generated automatically from 'StateControl.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_StateControl.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::StateControl::StateType)
|
|
12
|
+
{ JsonData::StateControl::StateType::RESUMED, _TXT("resumed") },
|
|
13
|
+
{ JsonData::StateControl::StateType::SUSPENDED, _TXT("suspended") },
|
|
14
|
+
ENUM_CONVERSION_END(JsonData::StateControl::StateType)
|
|
15
|
+
|
|
16
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// Enumeration code for Store2 API.
|
|
2
|
+
// Generated automatically from 'IStore2.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IStore2.h>
|
|
8
|
+
#include "JsonData_Store2.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IStore2::ScopeType)
|
|
13
|
+
{ Exchange::IStore2::ScopeType::DEVICE, _TXT("device") },
|
|
14
|
+
{ Exchange::IStore2::ScopeType::ACCOUNT, _TXT("account") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::IStore2::ScopeType)
|
|
16
|
+
|
|
17
|
+
}
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
// Enumeration code for Streamer API.
|
|
2
|
+
// Generated automatically from 'Streamer.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_Streamer.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::Streamer::StreamType)
|
|
12
|
+
{ JsonData::Streamer::StreamType::UNDEFINED, _TXT("undefined") },
|
|
13
|
+
{ JsonData::Streamer::StreamType::CABLE, _TXT("cable") },
|
|
14
|
+
{ JsonData::Streamer::StreamType::HANDHELD, _TXT("handheld") },
|
|
15
|
+
{ JsonData::Streamer::StreamType::SATELLITE, _TXT("satellite") },
|
|
16
|
+
{ JsonData::Streamer::StreamType::TERRESTRIAL, _TXT("terrestrial") },
|
|
17
|
+
{ JsonData::Streamer::StreamType::DAB, _TXT("dab") },
|
|
18
|
+
{ JsonData::Streamer::StreamType::RF, _TXT("rf") },
|
|
19
|
+
{ JsonData::Streamer::StreamType::UNICAST, _TXT("unicast") },
|
|
20
|
+
{ JsonData::Streamer::StreamType::MULTICAST, _TXT("multicast") },
|
|
21
|
+
{ JsonData::Streamer::StreamType::IP, _TXT("ip") },
|
|
22
|
+
ENUM_CONVERSION_END(JsonData::Streamer::StreamType)
|
|
23
|
+
|
|
24
|
+
ENUM_CONVERSION_BEGIN(JsonData::Streamer::DrmType)
|
|
25
|
+
{ JsonData::Streamer::DrmType::NONE, _TXT("none") },
|
|
26
|
+
{ JsonData::Streamer::DrmType::CLEARKEY, _TXT("clearkey") },
|
|
27
|
+
{ JsonData::Streamer::DrmType::PLAYREADY, _TXT("playready") },
|
|
28
|
+
{ JsonData::Streamer::DrmType::WIDEVINE, _TXT("widevine") },
|
|
29
|
+
{ JsonData::Streamer::DrmType::UNKNOWN, _TXT("unknown") },
|
|
30
|
+
ENUM_CONVERSION_END(JsonData::Streamer::DrmType)
|
|
31
|
+
|
|
32
|
+
ENUM_CONVERSION_BEGIN(JsonData::Streamer::StateType)
|
|
33
|
+
{ JsonData::Streamer::StateType::IDLE, _TXT("idle") },
|
|
34
|
+
{ JsonData::Streamer::StateType::LOADING, _TXT("loading") },
|
|
35
|
+
{ JsonData::Streamer::StateType::PREPARED, _TXT("prepared") },
|
|
36
|
+
{ JsonData::Streamer::StateType::CONTROLLED, _TXT("controlled") },
|
|
37
|
+
{ JsonData::Streamer::StateType::ERROR, _TXT("error") },
|
|
38
|
+
ENUM_CONVERSION_END(JsonData::Streamer::StateType)
|
|
39
|
+
|
|
40
|
+
ENUM_CONVERSION_BEGIN(JsonData::Streamer::StreamelementData::ElementType)
|
|
41
|
+
{ JsonData::Streamer::StreamelementData::ElementType::VIDEO, _TXT("video") },
|
|
42
|
+
{ JsonData::Streamer::StreamelementData::ElementType::AUDIO, _TXT("audio") },
|
|
43
|
+
{ JsonData::Streamer::StreamelementData::ElementType::SUBTITLES, _TXT("subtitles") },
|
|
44
|
+
{ JsonData::Streamer::StreamelementData::ElementType::TELETEXT, _TXT("teletext") },
|
|
45
|
+
{ JsonData::Streamer::StreamelementData::ElementType::DATA, _TXT("data") },
|
|
46
|
+
ENUM_CONVERSION_END(JsonData::Streamer::StreamelementData::ElementType)
|
|
47
|
+
|
|
48
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
// Enumeration code for SubsystemControl API.
|
|
2
|
+
// Generated automatically from 'ISubsystemControl.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/ISubsystemControl.h>
|
|
8
|
+
#include "JsonData_SubsystemControl.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(PluginHost::ISubSystem::subsystem)
|
|
13
|
+
{ PluginHost::ISubSystem::subsystem::PLATFORM, _TXT("Platform") },
|
|
14
|
+
{ PluginHost::ISubSystem::subsystem::SECURITY, _TXT("Security") },
|
|
15
|
+
{ PluginHost::ISubSystem::subsystem::NETWORK, _TXT("Network") },
|
|
16
|
+
{ PluginHost::ISubSystem::subsystem::IDENTIFIER, _TXT("Identifier") },
|
|
17
|
+
{ PluginHost::ISubSystem::subsystem::GRAPHICS, _TXT("Graphics") },
|
|
18
|
+
{ PluginHost::ISubSystem::subsystem::INTERNET, _TXT("Internet") },
|
|
19
|
+
{ PluginHost::ISubSystem::subsystem::LOCATION, _TXT("Location") },
|
|
20
|
+
{ PluginHost::ISubSystem::subsystem::TIME, _TXT("Time") },
|
|
21
|
+
{ PluginHost::ISubSystem::subsystem::PROVISIONING, _TXT("Provisioning") },
|
|
22
|
+
{ PluginHost::ISubSystem::subsystem::DECRYPTION, _TXT("Decryption") },
|
|
23
|
+
{ PluginHost::ISubSystem::subsystem::WEBSOURCE, _TXT("WebSource") },
|
|
24
|
+
{ PluginHost::ISubSystem::subsystem::STREAMING, _TXT("Streaming") },
|
|
25
|
+
{ PluginHost::ISubSystem::subsystem::BLUETOOTH, _TXT("Bluetooth") },
|
|
26
|
+
{ PluginHost::ISubSystem::subsystem::CRYPTOGRAPHY, _TXT("Cryptography") },
|
|
27
|
+
{ PluginHost::ISubSystem::subsystem::INSTALLATION, _TXT("Installation") },
|
|
28
|
+
{ PluginHost::ISubSystem::subsystem::END_LIST, _TXT("EndList") },
|
|
29
|
+
{ PluginHost::ISubSystem::subsystem::NEGATIVE_START, _TXT("NegativeStart") },
|
|
30
|
+
{ PluginHost::ISubSystem::subsystem::NOT_PLATFORM, _TXT("!Platform") },
|
|
31
|
+
{ PluginHost::ISubSystem::subsystem::NOT_SECURITY, _TXT("!Security") },
|
|
32
|
+
{ PluginHost::ISubSystem::subsystem::NOT_NETWORK, _TXT("!Network") },
|
|
33
|
+
{ PluginHost::ISubSystem::subsystem::NOT_IDENTIFIER, _TXT("!Identifier") },
|
|
34
|
+
{ PluginHost::ISubSystem::subsystem::NOT_GRAPHICS, _TXT("!Graphics") },
|
|
35
|
+
{ PluginHost::ISubSystem::subsystem::NOT_INTERNET, _TXT("!Internet") },
|
|
36
|
+
{ PluginHost::ISubSystem::subsystem::NOT_LOCATION, _TXT("!Location") },
|
|
37
|
+
{ PluginHost::ISubSystem::subsystem::NOT_TIME, _TXT("!Time") },
|
|
38
|
+
{ PluginHost::ISubSystem::subsystem::NOT_PROVISIONING, _TXT("!Provisioning") },
|
|
39
|
+
{ PluginHost::ISubSystem::subsystem::NOT_DECRYPTION, _TXT("!Decryption") },
|
|
40
|
+
{ PluginHost::ISubSystem::subsystem::NOT_WEBSOURCE, _TXT("!WebSource") },
|
|
41
|
+
{ PluginHost::ISubSystem::subsystem::NOT_STREAMING, _TXT("!Streaming") },
|
|
42
|
+
{ PluginHost::ISubSystem::subsystem::NOT_BLUETOOTH, _TXT("!Bluetooth") },
|
|
43
|
+
{ PluginHost::ISubSystem::subsystem::NOT_CRYPTOGRAPHY, _TXT("!Cryptography") },
|
|
44
|
+
{ PluginHost::ISubSystem::subsystem::NOT_INSTALLATION, _TXT("!Installation") },
|
|
45
|
+
ENUM_CONVERSION_END(PluginHost::ISubSystem::subsystem)
|
|
46
|
+
|
|
47
|
+
}
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
// Enumeration code for USBHub API.
|
|
2
|
+
// Generated automatically from 'IUSBHub.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IUSBHub.h>
|
|
8
|
+
#include "JsonData_USBHub.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IUSBHub::Status)
|
|
13
|
+
{ Exchange::IUSBHub::Status::STATUS_ACTIVE, _TXT("STATUS_ACTIVE") },
|
|
14
|
+
{ Exchange::IUSBHub::Status::STATUS_NO_DEVICE_CONNECTED, _TXT("STATUS_NO_DEVICE_CONNECTED") },
|
|
15
|
+
{ Exchange::IUSBHub::Status::STATUS_SELF_POWERED, _TXT("STATUS_SELF_POWERED") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IUSBHub::Status)
|
|
17
|
+
|
|
18
|
+
ENUM_CONVERSION_BEGIN(Exchange::IUSBHub::Speed)
|
|
19
|
+
{ Exchange::IUSBHub::Speed::SPEED_LOW, _TXT("SPEED_LOW") },
|
|
20
|
+
{ Exchange::IUSBHub::Speed::SPEED_FULL, _TXT("SPEED_FULL") },
|
|
21
|
+
{ Exchange::IUSBHub::Speed::SPEED_HIGH, _TXT("SPEED_HIGH") },
|
|
22
|
+
{ Exchange::IUSBHub::Speed::SPEED_SUPER, _TXT("SPEED_SUPER") },
|
|
23
|
+
ENUM_CONVERSION_END(Exchange::IUSBHub::Speed)
|
|
24
|
+
|
|
25
|
+
ENUM_CONVERSION_BEGIN(Exchange::IUSBHub::Flags)
|
|
26
|
+
{ Exchange::IUSBHub::Flags::FLAGS_AVAILABLE, _TXT("FLAGS_AVAILABLE") },
|
|
27
|
+
{ Exchange::IUSBHub::Flags::FLAGS_SWITCHABLE, _TXT("FLAGS_SWITCHABLE") },
|
|
28
|
+
ENUM_CONVERSION_END(Exchange::IUSBHub::Flags)
|
|
29
|
+
|
|
30
|
+
}
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
// Enumeration code for Catalog API.
|
|
2
|
+
// Generated automatically from 'IValuePoint.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IValuePoint.h>
|
|
8
|
+
#include "JsonData_ValuePointCatalog.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IValuePoint::condition)
|
|
13
|
+
{ Exchange::IValuePoint::condition::constructing, _TXT("CONSTRUCTING") },
|
|
14
|
+
{ Exchange::IValuePoint::condition::activated, _TXT("ACTIVATED") },
|
|
15
|
+
{ Exchange::IValuePoint::condition::deactivated, _TXT("DEACTIVATED") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IValuePoint::condition)
|
|
17
|
+
|
|
18
|
+
ENUM_CONVERSION_BEGIN(Exchange::IValuePoint::basic)
|
|
19
|
+
{ Exchange::IValuePoint::basic::regulator, _TXT("REGULATOR") },
|
|
20
|
+
{ Exchange::IValuePoint::basic::measurement, _TXT("MEASUREMENT") },
|
|
21
|
+
{ Exchange::IValuePoint::basic::group, _TXT("GROUP") },
|
|
22
|
+
{ Exchange::IValuePoint::basic::identification, _TXT("IDENTIFICATION") },
|
|
23
|
+
ENUM_CONVERSION_END(Exchange::IValuePoint::basic)
|
|
24
|
+
|
|
25
|
+
ENUM_CONVERSION_BEGIN(Exchange::IValuePoint::specific)
|
|
26
|
+
{ Exchange::IValuePoint::specific::general, _TXT("GENERAL") },
|
|
27
|
+
{ Exchange::IValuePoint::specific::electricity, _TXT("ELECTRICITY") },
|
|
28
|
+
{ Exchange::IValuePoint::specific::water, _TXT("WATER") },
|
|
29
|
+
{ Exchange::IValuePoint::specific::gas, _TXT("GAS") },
|
|
30
|
+
{ Exchange::IValuePoint::specific::air, _TXT("AIR") },
|
|
31
|
+
{ Exchange::IValuePoint::specific::smoke, _TXT("SMOKE") },
|
|
32
|
+
{ Exchange::IValuePoint::specific::carbonMonoxide, _TXT("CARBON_MONOXIDE") },
|
|
33
|
+
{ Exchange::IValuePoint::specific::carbonDioxide, _TXT("CARBON_DIOXIDE") },
|
|
34
|
+
{ Exchange::IValuePoint::specific::temperature, _TXT("TEMPERATURE") },
|
|
35
|
+
{ Exchange::IValuePoint::specific::accessControl, _TXT("ACCESS_CONTROL") },
|
|
36
|
+
{ Exchange::IValuePoint::specific::burglar, _TXT("BURGLAR") },
|
|
37
|
+
{ Exchange::IValuePoint::specific::powerManagement, _TXT("POWER_MANAGEMENT") },
|
|
38
|
+
{ Exchange::IValuePoint::specific::system, _TXT("SYSTEM") },
|
|
39
|
+
{ Exchange::IValuePoint::specific::emergency, _TXT("EMERGENCY") },
|
|
40
|
+
{ Exchange::IValuePoint::specific::clock, _TXT("CLOCK") },
|
|
41
|
+
{ Exchange::IValuePoint::specific::light, _TXT("LIGHT") },
|
|
42
|
+
{ Exchange::IValuePoint::specific::humidity, _TXT("HUMIDITY") },
|
|
43
|
+
{ Exchange::IValuePoint::specific::pressure, _TXT("PRESSURE") },
|
|
44
|
+
ENUM_CONVERSION_END(Exchange::IValuePoint::specific)
|
|
45
|
+
|
|
46
|
+
ENUM_CONVERSION_BEGIN(Exchange::IValuePoint::dimension)
|
|
47
|
+
{ Exchange::IValuePoint::dimension::logic, _TXT("LOGIC") },
|
|
48
|
+
{ Exchange::IValuePoint::dimension::percentage, _TXT("PERCENTAGE") },
|
|
49
|
+
{ Exchange::IValuePoint::dimension::kwh, _TXT("KWH") },
|
|
50
|
+
{ Exchange::IValuePoint::dimension::kvah, _TXT("KVAH") },
|
|
51
|
+
{ Exchange::IValuePoint::dimension::pulses, _TXT("PULSES") },
|
|
52
|
+
{ Exchange::IValuePoint::dimension::degrees, _TXT("DEGREES") },
|
|
53
|
+
{ Exchange::IValuePoint::dimension::units, _TXT("UNITS") },
|
|
54
|
+
{ Exchange::IValuePoint::dimension::lux, _TXT("LUX") },
|
|
55
|
+
{ Exchange::IValuePoint::dimension::volt, _TXT("VOLT") },
|
|
56
|
+
{ Exchange::IValuePoint::dimension::ampere, _TXT("AMPERE") },
|
|
57
|
+
{ Exchange::IValuePoint::dimension::frequency, _TXT("FREQUENCY") },
|
|
58
|
+
ENUM_CONVERSION_END(Exchange::IValuePoint::dimension)
|
|
59
|
+
|
|
60
|
+
ENUM_CONVERSION_BEGIN(Exchange::IValuePoint::protocol)
|
|
61
|
+
{ Exchange::IValuePoint::protocol::unknown, _TXT("UNKNOWN") },
|
|
62
|
+
{ Exchange::IValuePoint::protocol::serial, _TXT("SERIAL") },
|
|
63
|
+
{ Exchange::IValuePoint::protocol::modbus, _TXT("MODBUS") },
|
|
64
|
+
{ Exchange::IValuePoint::protocol::mqtt, _TXT("MQTT") },
|
|
65
|
+
{ Exchange::IValuePoint::protocol::http, _TXT("HTTP") },
|
|
66
|
+
{ Exchange::IValuePoint::protocol::coap, _TXT("COAP") },
|
|
67
|
+
{ Exchange::IValuePoint::protocol::zigbee, _TXT("ZIGBEE") },
|
|
68
|
+
{ Exchange::IValuePoint::protocol::zwave, _TXT("ZWAVE") },
|
|
69
|
+
{ Exchange::IValuePoint::protocol::bluetooth, _TXT("BLUETOOTH") },
|
|
70
|
+
{ Exchange::IValuePoint::protocol::hardware, _TXT("HARDWARE") },
|
|
71
|
+
{ Exchange::IValuePoint::protocol::onewire, _TXT("ONEWIRE") },
|
|
72
|
+
{ Exchange::IValuePoint::protocol::i2c, _TXT("I2C") },
|
|
73
|
+
{ Exchange::IValuePoint::protocol::spi, _TXT("SPI") },
|
|
74
|
+
{ Exchange::IValuePoint::protocol::nrf24, _TXT("NRF24") },
|
|
75
|
+
{ Exchange::IValuePoint::protocol::virtuals, _TXT("VIRTUALS") },
|
|
76
|
+
ENUM_CONVERSION_END(Exchange::IValuePoint::protocol)
|
|
77
|
+
|
|
78
|
+
}
|
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
// Enumeration code for WebBrowser API.
|
|
2
|
+
// Generated automatically from 'IBrowser.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IBrowser.h>
|
|
8
|
+
#include "JsonData_WebBrowser.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IWebBrowser::VisibilityType)
|
|
13
|
+
{ Exchange::IWebBrowser::VisibilityType::HIDDEN, _TXT("hidden") },
|
|
14
|
+
{ Exchange::IWebBrowser::VisibilityType::VISIBLE, _TXT("visible") },
|
|
15
|
+
ENUM_CONVERSION_END(Exchange::IWebBrowser::VisibilityType)
|
|
16
|
+
|
|
17
|
+
ENUM_CONVERSION_BEGIN(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
18
|
+
{ Exchange::IWebBrowser::HTTPCookieAcceptPolicyType::ALWAYS, _TXT("always") },
|
|
19
|
+
{ Exchange::IWebBrowser::HTTPCookieAcceptPolicyType::NEVER, _TXT("never") },
|
|
20
|
+
{ Exchange::IWebBrowser::HTTPCookieAcceptPolicyType::ONLY_FROM_MAIN_DOCUMENT_DOMAIN, _TXT("onlyfrommaindocumentdomain") },
|
|
21
|
+
{ Exchange::IWebBrowser::HTTPCookieAcceptPolicyType::EXCLUSIVELY_FROM_MAIN_DOCUMENT_DOMAIN, _TXT("exclusivelyfrommaindocumentdomain") },
|
|
22
|
+
ENUM_CONVERSION_END(Exchange::IWebBrowser::HTTPCookieAcceptPolicyType)
|
|
23
|
+
|
|
24
|
+
}
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
// Enumeration code for WifiControl API.
|
|
2
|
+
// Generated automatically from 'IWifiControl.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IWifiControl.h>
|
|
8
|
+
#include "JsonData_WifiControl.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IWifiControl::Security)
|
|
13
|
+
{ Exchange::IWifiControl::Security::OPEN, _TXT("Open") },
|
|
14
|
+
{ Exchange::IWifiControl::Security::WEP, _TXT("WEP") },
|
|
15
|
+
{ Exchange::IWifiControl::Security::WPA, _TXT("WPA") },
|
|
16
|
+
{ Exchange::IWifiControl::Security::WPA2, _TXT("WPA2") },
|
|
17
|
+
{ Exchange::IWifiControl::Security::WPS, _TXT("WPS") },
|
|
18
|
+
{ Exchange::IWifiControl::Security::ENTERPRISE, _TXT("Enterprise") },
|
|
19
|
+
{ Exchange::IWifiControl::Security::WPA_WPA2, _TXT("WPA_WPA2") },
|
|
20
|
+
{ Exchange::IWifiControl::Security::UNKNOWN, _TXT("Unknown") },
|
|
21
|
+
ENUM_CONVERSION_END(Exchange::IWifiControl::Security)
|
|
22
|
+
|
|
23
|
+
ENUM_CONVERSION_BEGIN(Exchange::IWifiControl::SecurityInfo::Key)
|
|
24
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::PSK, _TXT("PSK") },
|
|
25
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::EAP, _TXT("EAP") },
|
|
26
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::CCMP, _TXT("CCMP") },
|
|
27
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::TKIP, _TXT("TKIP") },
|
|
28
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::PREAUTH, _TXT("Preauth") },
|
|
29
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::PBC, _TXT("PBC") },
|
|
30
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::PIN, _TXT("PIN") },
|
|
31
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::PSK_HASHED, _TXT("PSK_HASHED") },
|
|
32
|
+
{ Exchange::IWifiControl::SecurityInfo::Key::NONE, _TXT("None") },
|
|
33
|
+
ENUM_CONVERSION_END(Exchange::IWifiControl::SecurityInfo::Key)
|
|
34
|
+
|
|
35
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for ZigWave API.
|
|
2
|
+
// Generated automatically from 'IZigWave.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <interfaces/IZigWave.h>
|
|
8
|
+
#include "JsonData_ZigWave.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(Exchange::IZigWave::Device::type)
|
|
13
|
+
{ Exchange::IZigWave::Device::type::END_DEVICE, _TXT("END_DEVICE") },
|
|
14
|
+
{ Exchange::IZigWave::Device::type::ROUTER, _TXT("ROUTER") },
|
|
15
|
+
{ Exchange::IZigWave::Device::type::CONTROLLER, _TXT("CONTROLLER") },
|
|
16
|
+
ENUM_CONVERSION_END(Exchange::IZigWave::Device::type)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Browser API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Browser.h"
|
|
7
|
+
#include "JBrowser.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// Cobalt API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JCobalt.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Compositor API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Compositor.h"
|
|
7
|
+
#include "JCompositor.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Containers API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Containers.h"
|
|
7
|
+
#include "JContainers.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// DHCPServer API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DHCPServer.h"
|
|
7
|
+
#include "JDHCPServer.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// DIALServer API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DIALServer.h"
|
|
7
|
+
#include "JDIALServer.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// DTV API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DTV.h"
|
|
7
|
+
#include "JDTV.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// DeviceInfo API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DeviceInfo.h"
|
|
7
|
+
#include "JDeviceInfo.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// FirmwareControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_FirmwareControl.h"
|
|
7
|
+
#include "JFirmwareControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IAVSClient API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_AVSController.h"
|
|
7
|
+
#include "JAVSController.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// IAmazonPrime API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JAmazonPrime.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IApplication API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Application.h"
|
|
7
|
+
#include "JApplication.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IAudioStream API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_AudioStream.h"
|
|
7
|
+
#include "JAudioStream.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IBluetooth API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_BluetoothControl.h"
|
|
7
|
+
#include "JBluetoothControl.h"
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
// IBluetoothAudio API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_BluetoothAudioSink.h"
|
|
7
|
+
#include "JsonData_BluetoothAudioSource.h"
|
|
8
|
+
#include "JBluetoothAudioSink.h"
|
|
9
|
+
#include "JBluetoothAudioSource.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IBluetoothRemoteControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_BluetoothRemoteControl.h"
|
|
7
|
+
#include "JBluetoothRemoteControl.h"
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
// IBrowser API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_WebBrowser.h"
|
|
7
|
+
#include "JsonData_WebBrowserExt.h"
|
|
8
|
+
#include "JsonData_BrowserResources.h"
|
|
9
|
+
#include "JsonData_BrowserSecurity.h"
|
|
10
|
+
#include "JsonData_BrowserScripting.h"
|
|
11
|
+
#include "JsonData_BrowserCookieJar.h"
|
|
12
|
+
#include "JWebBrowser.h"
|
|
13
|
+
#include "JWebBrowserExt.h"
|
|
14
|
+
#include "JBrowserResources.h"
|
|
15
|
+
#include "JBrowserSecurity.h"
|
|
16
|
+
#include "JBrowserScripting.h"
|
|
17
|
+
#include "JBrowserCookieJar.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IButler API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Butler.h"
|
|
7
|
+
#include "JButler.h"
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
// IContentProtection API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_ContentProtection.h"
|
|
7
|
+
#include "JsonData_ErrorToString.h"
|
|
8
|
+
#include "JContentProtection.h"
|
|
9
|
+
#include "JErrorToString.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// ICustomerCareOperations API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JCustomerCareOperations.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IDNSServer API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DNSServer.h"
|
|
7
|
+
#include "JDNSServer.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IDeviceIdentification API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DeviceIdentification.h"
|
|
7
|
+
#include "JDeviceIdentification.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IDictionary API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Dictionary.h"
|
|
7
|
+
#include "JDictionary.h"
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
// IDisplayInfo API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_ConnectionProperties.h"
|
|
7
|
+
#include "JsonData_HDRProperties.h"
|
|
8
|
+
#include "JsonData_DisplayProperties.h"
|
|
9
|
+
#include "JGraphicsProperties.h"
|
|
10
|
+
#include "JConnectionProperties.h"
|
|
11
|
+
#include "JHDRProperties.h"
|
|
12
|
+
#include "JDisplayProperties.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IDolby API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_DolbyOutput.h"
|
|
7
|
+
#include "JDolbyOutput.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IIOConnector API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_IOConnector.h"
|
|
7
|
+
#include "JIOConnector.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// ILanguageTag API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JLanguageTag.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ILocationSync API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_LocationSync.h"
|
|
7
|
+
#include "JLocationSync.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IMath API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Math.h"
|
|
7
|
+
#include "JMath.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IMemoryMonitor API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_MemoryMonitor.h"
|
|
7
|
+
#include "JMemoryMonitor.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IMessagingControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_MessagingControl.h"
|
|
7
|
+
#include "JMessagingControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IMessenger API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Messenger.h"
|
|
7
|
+
#include "JMessenger.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// INetworkControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_NetworkControl.h"
|
|
7
|
+
#include "JNetworkControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// INetworkTools API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_NetworkTools.h"
|
|
7
|
+
#include "JNetworkTools.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// IOCDM API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JOpenCDM.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IPackageManager API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_PackageManager.h"
|
|
7
|
+
#include "JPackageManager.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IPackager API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Packager.h"
|
|
7
|
+
#include "JPackager.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IPlayerInfo API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_PlayerProperties.h"
|
|
7
|
+
#include "JPlayerProperties.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IPower API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Power.h"
|
|
7
|
+
#include "JPower.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IScriptEngine API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_ScriptEngine.h"
|
|
7
|
+
#include "JScriptEngine.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISecurityAgent API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SecurityAgent.h"
|
|
7
|
+
#include "JSecurityAgent.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IStore2 API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Store2.h"
|
|
7
|
+
#include "JStore2.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISubsystemControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SubsystemControl.h"
|
|
7
|
+
#include "JSubsystemControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ISystemCommands API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SystemCommands.h"
|
|
7
|
+
#include "JSystemCommands.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ITimeSync API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_TimeSync.h"
|
|
7
|
+
#include "JTimeSync.h"
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
// ITimeZone API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JTimeZone.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IUSBHub API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_USBHub.h"
|
|
7
|
+
#include "JUSBHub.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IValuePoint API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_ValuePointCatalog.h"
|
|
7
|
+
#include "JValuePointCatalog.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IVolumeControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_VolumeControl.h"
|
|
7
|
+
#include "JVolumeControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IWatchDog API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_WatchDog.h"
|
|
7
|
+
#include "JWatchDog.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IWifiControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_WifiControl.h"
|
|
7
|
+
#include "JWifiControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IZigWave API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_ZigWave.h"
|
|
7
|
+
#include "JZigWave.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// InputSwitch API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_InputSwitch.h"
|
|
7
|
+
#include "JInputSwitch.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// LISA API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_LISA.h"
|
|
7
|
+
#include "JLISA.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Monitor API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Monitor.h"
|
|
7
|
+
#include "JMonitor.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Netflix API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Netflix.h"
|
|
7
|
+
#include "JNetflix.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// OCDM API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_OCDM.h"
|
|
7
|
+
#include "JOCDM.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// PerformanceMonitor API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_PerformanceMonitor.h"
|
|
7
|
+
#include "JPerformanceMonitor.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// PersistentStore API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_PersistentStore.h"
|
|
7
|
+
#include "JPersistentStore.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Provisioning API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Provisioning.h"
|
|
7
|
+
#include "JProvisioning.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// RemoteControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_RemoteControl.h"
|
|
7
|
+
#include "JRemoteControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// SecureShellServer API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_SecureShellServer.h"
|
|
7
|
+
#include "JSecureShellServer.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// StateControl API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_StateControl.h"
|
|
7
|
+
#include "JStateControl.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// Streamer API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Streamer.h"
|
|
7
|
+
#include "JStreamer.h"
|
|
@@ -0,0 +1,174 @@
|
|
|
1
|
+
// Generated automatically from 'IBenchmark.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Benchmark.h"
|
|
6
|
+
#include <qa_interfaces/IBenchmark.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JBenchmark {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 2;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IBenchmark* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JBenchmark"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'trigger' - Run the benchmark
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Benchmark::TriggerParamsData, void>(_T("trigger"),
|
|
37
|
+
[_implementation__](const JsonData::Benchmark::TriggerParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBenchmark"), _T("trigger")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint32_t _iterations_{params.Iterations};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->Trigger(_iterations_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Method: 'collectData' - Collect the results of the most recent benchmark run
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::Benchmark::BenchmarkResultData>>(_T("collectData"),
|
|
56
|
+
[_implementation__](Core::JSON::ArrayType<JsonData::Benchmark::BenchmarkResultData>& report) -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>* _report_{};
|
|
60
|
+
|
|
61
|
+
_errorCode__ = _implementation__->CollectData(_report_);
|
|
62
|
+
|
|
63
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
64
|
+
report.Set(true);
|
|
65
|
+
|
|
66
|
+
if (_report_ != nullptr) {
|
|
67
|
+
QualityAssurance::IBenchmark::BenchmarkResult _resultItem__{};
|
|
68
|
+
while (_report_->Next(_resultItem__) == true) { report.Add() = _resultItem__; }
|
|
69
|
+
_report_->Release();
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
return (_errorCode__);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
// Property: 'latencyThreshold' - Maximum allowed deviation in avg latency compared to first-run baseline, in millipercent (1000 = 1%, 0 = no latency check)
|
|
77
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Benchmark::LatencyThresholdData, Core::JSON::DecUInt32>(_T("latencyThreshold"),
|
|
78
|
+
[_implementation__](const JsonData::Benchmark::LatencyThresholdData& params, Core::JSON::DecUInt32& result) -> uint32_t {
|
|
79
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
80
|
+
|
|
81
|
+
if (params.IsSet() == false) {
|
|
82
|
+
uint32_t _result_{};
|
|
83
|
+
|
|
84
|
+
_errorCode__ = (static_cast<const IBenchmark*>(_implementation__))->LatencyThreshold(_result_);
|
|
85
|
+
|
|
86
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
87
|
+
result = _result_;
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
else {
|
|
91
|
+
|
|
92
|
+
if (params.IsDataValid() == false) {
|
|
93
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBenchmark"), _T("latencyThreshold")));
|
|
94
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
95
|
+
}
|
|
96
|
+
else {
|
|
97
|
+
const uint32_t _value_{params.Value};
|
|
98
|
+
|
|
99
|
+
_errorCode__ = _implementation__->LatencyThreshold(_value_);
|
|
100
|
+
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
result.Null(true);
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
return (_errorCode__);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
// Property: 'memoryThreshold' - Maximum allowed RSS growth in bytes per method (0 = no memory check)
|
|
110
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Benchmark::MemoryThresholdData, Core::JSON::DecUInt64>(_T("memoryThreshold"),
|
|
111
|
+
[_implementation__](const JsonData::Benchmark::MemoryThresholdData& params, Core::JSON::DecUInt64& result) -> uint32_t {
|
|
112
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
113
|
+
|
|
114
|
+
if (params.IsSet() == false) {
|
|
115
|
+
uint64_t _result_{};
|
|
116
|
+
|
|
117
|
+
_errorCode__ = (static_cast<const IBenchmark*>(_implementation__))->MemoryThreshold(_result_);
|
|
118
|
+
|
|
119
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
120
|
+
result = _result_;
|
|
121
|
+
}
|
|
122
|
+
}
|
|
123
|
+
else {
|
|
124
|
+
|
|
125
|
+
if (params.IsDataValid() == false) {
|
|
126
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBenchmark"), _T("memoryThreshold")));
|
|
127
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
128
|
+
}
|
|
129
|
+
else {
|
|
130
|
+
const uint64_t _value_{params.Value};
|
|
131
|
+
|
|
132
|
+
_errorCode__ = _implementation__->MemoryThreshold(_value_);
|
|
133
|
+
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
result.Null(true);
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
return (_errorCode__);
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
template<typename MODULE>
|
|
145
|
+
static void Unregister(MODULE& _module__)
|
|
146
|
+
{
|
|
147
|
+
// Unregister methods and properties...
|
|
148
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("trigger"));
|
|
149
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("collectData"));
|
|
150
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("latencyThreshold"));
|
|
151
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("memoryThreshold"));
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
namespace Event {
|
|
155
|
+
|
|
156
|
+
// Event: 'performanceCheckCompleted'
|
|
157
|
+
template<typename MODULE>
|
|
158
|
+
static void PerformanceCheckCompleted(const MODULE& module_, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
159
|
+
{
|
|
160
|
+
module_.Notify(_T("performanceCheckCompleted"), sendIfMethod_);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
} // namespace Event
|
|
164
|
+
|
|
165
|
+
POP_WARNING()
|
|
166
|
+
POP_WARNING()
|
|
167
|
+
POP_WARNING()
|
|
168
|
+
|
|
169
|
+
} // namespace JBenchmark
|
|
170
|
+
|
|
171
|
+
} // namespace QualityAssurance
|
|
172
|
+
|
|
173
|
+
} // namespace Thunder
|
|
174
|
+
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_ComRpc.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JComRpc {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IComRpc* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JComRpc"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'testbigstring' - Validates big string over proxy-stub with given length of KB
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::ComRpc::TestBigStringParamsData, void>(_T("testbigstring"),
|
|
37
|
+
[_implementation__](const JsonData::ComRpc::TestBigStringParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JComRpc"), _T("testbigstring")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint32_t _length_{params.Length};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->TestBigString(_length_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
template<typename MODULE>
|
|
57
|
+
static void Unregister(MODULE& _module__)
|
|
58
|
+
{
|
|
59
|
+
// Unregister methods and properties...
|
|
60
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("testbigstring"));
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
POP_WARNING()
|
|
64
|
+
POP_WARNING()
|
|
65
|
+
POP_WARNING()
|
|
66
|
+
|
|
67
|
+
} // namespace JComRpc
|
|
68
|
+
|
|
69
|
+
} // namespace QualityAssurance
|
|
70
|
+
|
|
71
|
+
} // namespace Thunder
|
|
72
|
+
|
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_Memory.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JMemory {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, IMemory* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JMemory"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'allocatememory' - Allocates Memory as given size of MB
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::Memory::AllocateMemoryParamsData, void>(_T("allocatememory"),
|
|
37
|
+
[_implementation__](const JsonData::Memory::AllocateMemoryParamsData& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemory"), _T("allocatememory")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint32_t _size_{params.Size};
|
|
46
|
+
|
|
47
|
+
_errorCode__ = _implementation__->AllocateMemory(_size_);
|
|
48
|
+
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
return (_errorCode__);
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
// Method: 'freeallocatedmemory' - Frees the allocated memory
|
|
55
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("freeallocatedmemory"),
|
|
56
|
+
[_implementation__]() -> uint32_t {
|
|
57
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
58
|
+
|
|
59
|
+
_errorCode__ = _implementation__->FreeAllocatedMemory();
|
|
60
|
+
|
|
61
|
+
return (_errorCode__);
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
template<typename MODULE>
|
|
67
|
+
static void Unregister(MODULE& _module__)
|
|
68
|
+
{
|
|
69
|
+
// Unregister methods and properties...
|
|
70
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("allocatememory"));
|
|
71
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("freeallocatedmemory"));
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
POP_WARNING()
|
|
75
|
+
POP_WARNING()
|
|
76
|
+
POP_WARNING()
|
|
77
|
+
|
|
78
|
+
} // namespace JMemory
|
|
79
|
+
|
|
80
|
+
} // namespace QualityAssurance
|
|
81
|
+
|
|
82
|
+
} // namespace Thunder
|
|
83
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'TestController.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestController.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JTestController {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JTestController
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,131 @@
|
|
|
1
|
+
// Generated automatically from 'ITestPlugin.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestPlugin.h"
|
|
6
|
+
#include <qa_interfaces/ITestPlugin.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JTestPlugin {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ITestPlugin* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestPlugin"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'echo'
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestPlugin::EchoParamsData, Core::JSON::String>(_T("echo"),
|
|
37
|
+
[_implementation__](const JsonData::TestPlugin::EchoParamsData& params, Core::JSON::String& output) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestPlugin"), _T("echo")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const string _input_{params.Input};
|
|
46
|
+
string _output_{};
|
|
47
|
+
|
|
48
|
+
_errorCode__ = _implementation__->Echo(_input_, _output_);
|
|
49
|
+
|
|
50
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
51
|
+
output = _output_;
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
return (_errorCode__);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
// Method: 'greet'
|
|
59
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestPlugin::GreetParamsData, Core::JSON::String>(_T("greet"),
|
|
60
|
+
[_implementation__](const JsonData::TestPlugin::GreetParamsData& params, Core::JSON::String& message) -> uint32_t {
|
|
61
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
62
|
+
|
|
63
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
64
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestPlugin"), _T("greet")));
|
|
65
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
66
|
+
}
|
|
67
|
+
else {
|
|
68
|
+
const string _name_{params.Name};
|
|
69
|
+
string _message_{};
|
|
70
|
+
|
|
71
|
+
_errorCode__ = _implementation__->Greet(_name_, _message_);
|
|
72
|
+
|
|
73
|
+
if (_errorCode__ == Core::ERROR_NONE) {
|
|
74
|
+
message = _message_;
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
return (_errorCode__);
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
template<typename MODULE>
|
|
84
|
+
static void Unregister(MODULE& _module__)
|
|
85
|
+
{
|
|
86
|
+
// Unregister methods and properties...
|
|
87
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("echo"));
|
|
88
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("greet"));
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
namespace Event {
|
|
92
|
+
|
|
93
|
+
// Event: 'onGreeting'
|
|
94
|
+
template<typename MODULE>
|
|
95
|
+
static void OnGreeting(const MODULE& module_, const JsonData::TestPlugin::OnGreetingParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
96
|
+
{
|
|
97
|
+
module_.Notify(_T("onGreeting"), params, sendIfMethod_);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
// Event: 'onGreeting'
|
|
101
|
+
template<typename MODULE>
|
|
102
|
+
static void OnGreeting(const MODULE& module_, const Core::JSON::String& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
103
|
+
{
|
|
104
|
+
JsonData::TestPlugin::OnGreetingParamsData params_;
|
|
105
|
+
params_.Message = message;
|
|
106
|
+
|
|
107
|
+
OnGreeting(module_, params_, sendIfMethod_);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
// Event: 'onGreeting'
|
|
111
|
+
template<typename MODULE>
|
|
112
|
+
static void OnGreeting(const MODULE& module_, const string& message, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
113
|
+
{
|
|
114
|
+
JsonData::TestPlugin::OnGreetingParamsData params_;
|
|
115
|
+
params_.Message = message;
|
|
116
|
+
|
|
117
|
+
OnGreeting(module_, params_, sendIfMethod_);
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
} // namespace Event
|
|
121
|
+
|
|
122
|
+
POP_WARNING()
|
|
123
|
+
POP_WARNING()
|
|
124
|
+
POP_WARNING()
|
|
125
|
+
|
|
126
|
+
} // namespace JTestPlugin
|
|
127
|
+
|
|
128
|
+
} // namespace QualityAssurance
|
|
129
|
+
|
|
130
|
+
} // namespace Thunder
|
|
131
|
+
|
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestTextOptions.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JTestTextOptions {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ITestTextOptions* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestTextOptions"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'testStandard' - Validates standard which is camelCase
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestStandardParamsInfo, void>(_T("testStandard"),
|
|
37
|
+
[_implementation__](const JsonData::TestTextOptions::TestStandardParamsInfo& params) -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
41
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestTextOptions"), _T("testStandard")));
|
|
42
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
43
|
+
}
|
|
44
|
+
else {
|
|
45
|
+
const uint32_t _firstTestParam_{params.FirstTestParam};
|
|
46
|
+
const uint32_t _secondTestParam_{params.SecondTestParam};
|
|
47
|
+
const QualityAssurance::ITestTextOptions::TestDetails _thirdTestParam_(params.ThirdTestParam);
|
|
48
|
+
const QualityAssurance::ITestTextOptions::EnumTextOptions _fourthTestParam_{params.FourthTestParam};
|
|
49
|
+
|
|
50
|
+
_errorCode__ = _implementation__->TestStandard(_firstTestParam_, _secondTestParam_, _thirdTestParam_, _fourthTestParam_);
|
|
51
|
+
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
return (_errorCode__);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
template<typename MODULE>
|
|
60
|
+
static void Unregister(MODULE& _module__)
|
|
61
|
+
{
|
|
62
|
+
// Unregister methods and properties...
|
|
63
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("testStandard"));
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
namespace Event {
|
|
67
|
+
|
|
68
|
+
// Event: 'testEvent'
|
|
69
|
+
template<typename MODULE>
|
|
70
|
+
static void TestEvent(const MODULE& module_, const JsonData::TestTextOptions::TestStandardParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
71
|
+
{
|
|
72
|
+
module_.Notify(_T("testEvent"), params, sendIfMethod_);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
// Event: 'testEvent'
|
|
76
|
+
template<typename MODULE>
|
|
77
|
+
static void TestEvent(const MODULE& module_, const Core::JSON::DecUInt32& firstTestParam, const Core::JSON::DecUInt32& secondTestParam, const JsonData::TestTextOptions::TestDetailsInfo& thirdTestParam, const Core::JSON::EnumType<QualityAssurance::ITestTextOptions::EnumTextOptions>& fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
78
|
+
{
|
|
79
|
+
JsonData::TestTextOptions::TestStandardParamsInfo params_;
|
|
80
|
+
params_.FirstTestParam = firstTestParam;
|
|
81
|
+
params_.SecondTestParam = secondTestParam;
|
|
82
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
83
|
+
params_.FourthTestParam = fourthTestParam;
|
|
84
|
+
|
|
85
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// Event: 'testEvent'
|
|
89
|
+
template<typename MODULE>
|
|
90
|
+
static void TestEvent(const MODULE& module_, const uint32_t firstTestParam, const uint32_t secondTestParam, const ITestTextOptions::TestDetails& thirdTestParam, const ITestTextOptions::EnumTextOptions fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
91
|
+
{
|
|
92
|
+
JsonData::TestTextOptions::TestStandardParamsInfo params_;
|
|
93
|
+
params_.FirstTestParam = firstTestParam;
|
|
94
|
+
params_.SecondTestParam = secondTestParam;
|
|
95
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
96
|
+
params_.FourthTestParam = fourthTestParam;
|
|
97
|
+
|
|
98
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
} // namespace Event
|
|
102
|
+
|
|
103
|
+
POP_WARNING()
|
|
104
|
+
POP_WARNING()
|
|
105
|
+
POP_WARNING()
|
|
106
|
+
|
|
107
|
+
} // namespace JTestTextOptions
|
|
108
|
+
|
|
109
|
+
} // namespace QualityAssurance
|
|
110
|
+
|
|
111
|
+
} // namespace Thunder
|
|
112
|
+
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestTextOptionsTestCustom.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace TestTextOptions {
|
|
13
|
+
|
|
14
|
+
namespace JTestCustom {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, ITestTextOptions::ITestCustom* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestCustom"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Method: 'TESTCUSTOM' - Validates custom generation
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo, void>(_T("TESTCUSTOM"),
|
|
39
|
+
[_implementation__](const JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo& params) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestCustom"), _T("TESTCUSTOM")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const uint32_t _firstTestParam_{params.FirstTestParam};
|
|
48
|
+
const uint32_t _secondTestParam_{params.SecondTestParam};
|
|
49
|
+
const QualityAssurance::ITestTextOptions::ITestCustom::TestDetails _thirdTestParam_(params.ThirdTestParam);
|
|
50
|
+
const QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions _fourthTestParam_{params.FourthTestParam};
|
|
51
|
+
|
|
52
|
+
_errorCode__ = _implementation__->TestCustom(_firstTestParam_, _secondTestParam_, _thirdTestParam_, _fourthTestParam_);
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
template<typename MODULE>
|
|
62
|
+
static void Unregister(MODULE& _module__)
|
|
63
|
+
{
|
|
64
|
+
// Unregister methods and properties...
|
|
65
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("TESTCUSTOM"));
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
namespace Event {
|
|
69
|
+
|
|
70
|
+
// Event: 'test_event'
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void TestEvent(const MODULE& module_, const JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
73
|
+
{
|
|
74
|
+
module_.Notify(_T("test_event"), params, sendIfMethod_);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
// Event: 'test_event'
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void TestEvent(const MODULE& module_, const Core::JSON::DecUInt32& firstTestParam, const Core::JSON::DecUInt32& secondTestParam, const JsonData::TestTextOptions::TestCustom::TestDetailsInfo& thirdTestParam, const Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions>& fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
80
|
+
{
|
|
81
|
+
JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo params_;
|
|
82
|
+
params_.FirstTestParam = firstTestParam;
|
|
83
|
+
params_.SecondTestParam = secondTestParam;
|
|
84
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
85
|
+
params_.FourthTestParam = fourthTestParam;
|
|
86
|
+
|
|
87
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// Event: 'test_event'
|
|
91
|
+
template<typename MODULE>
|
|
92
|
+
static void TestEvent(const MODULE& module_, const uint32_t firstTestParam, const uint32_t secondTestParam, const ITestTextOptions::ITestCustom::TestDetails& thirdTestParam, const ITestTextOptions::ITestCustom::EnumTextOptions fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
93
|
+
{
|
|
94
|
+
JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo params_;
|
|
95
|
+
params_.FirstTestParam = firstTestParam;
|
|
96
|
+
params_.SecondTestParam = secondTestParam;
|
|
97
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
98
|
+
params_.FourthTestParam = fourthTestParam;
|
|
99
|
+
|
|
100
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
} // namespace Event
|
|
104
|
+
|
|
105
|
+
POP_WARNING()
|
|
106
|
+
POP_WARNING()
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
|
|
109
|
+
} // namespace JTestCustom
|
|
110
|
+
|
|
111
|
+
} // namespace TestTextOptions
|
|
112
|
+
|
|
113
|
+
} // namespace QualityAssurance
|
|
114
|
+
|
|
115
|
+
} // namespace Thunder
|
|
116
|
+
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestTextOptionsTestKeep.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace TestTextOptions {
|
|
13
|
+
|
|
14
|
+
namespace JTestKeep {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, ITestTextOptions::ITestKeep* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestKeep"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Method: 'TestKeeP' - Validates keep which is as same as it's coded
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestKeep::TestKeePParamsData, void>(_T("TestKeeP"),
|
|
39
|
+
[_implementation__](const JsonData::TestTextOptions::TestKeep::TestKeePParamsData& params) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestKeep"), _T("TestKeeP")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const uint32_t _firstTestParaM_{params.FirstTestParaM};
|
|
48
|
+
const uint32_t _secondTestParaM_{params.SecondTestParaM};
|
|
49
|
+
const QualityAssurance::ITestTextOptions::ITestKeep::TestDetails _thirdTestParaM_(params.ThirdTestParaM);
|
|
50
|
+
const QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions _fourthTestParaM_{params.FourthTestParaM};
|
|
51
|
+
|
|
52
|
+
_errorCode__ = _implementation__->TestKeeP(_firstTestParaM_, _secondTestParaM_, _thirdTestParaM_, _fourthTestParaM_);
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
template<typename MODULE>
|
|
62
|
+
static void Unregister(MODULE& _module__)
|
|
63
|
+
{
|
|
64
|
+
// Unregister methods and properties...
|
|
65
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("TestKeeP"));
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
namespace Event {
|
|
69
|
+
|
|
70
|
+
// Event: 'TestEvent'
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void TestEvent(const MODULE& module_, const JsonData::TestTextOptions::TestKeep::TestEventParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
73
|
+
{
|
|
74
|
+
module_.Notify(_T("TestEvent"), params, sendIfMethod_);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
// Event: 'TestEvent'
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void TestEvent(const MODULE& module_, const Core::JSON::DecUInt32& firstTestParam, const Core::JSON::DecUInt32& secondTestParam, const JsonData::TestTextOptions::TestKeep::TestDetailsInfo& thirdTestParam, const Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions>& fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
80
|
+
{
|
|
81
|
+
JsonData::TestTextOptions::TestKeep::TestEventParamsData params_;
|
|
82
|
+
params_.FirstTestParam = firstTestParam;
|
|
83
|
+
params_.SecondTestParam = secondTestParam;
|
|
84
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
85
|
+
params_.FourthTestParam = fourthTestParam;
|
|
86
|
+
|
|
87
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// Event: 'TestEvent'
|
|
91
|
+
template<typename MODULE>
|
|
92
|
+
static void TestEvent(const MODULE& module_, const uint32_t firstTestParam, const uint32_t secondTestParam, const ITestTextOptions::ITestKeep::TestDetails& thirdTestParam, const ITestTextOptions::ITestKeep::EnumTextOptions fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
93
|
+
{
|
|
94
|
+
JsonData::TestTextOptions::TestKeep::TestEventParamsData params_;
|
|
95
|
+
params_.FirstTestParam = firstTestParam;
|
|
96
|
+
params_.SecondTestParam = secondTestParam;
|
|
97
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
98
|
+
params_.FourthTestParam = fourthTestParam;
|
|
99
|
+
|
|
100
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
} // namespace Event
|
|
104
|
+
|
|
105
|
+
POP_WARNING()
|
|
106
|
+
POP_WARNING()
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
|
|
109
|
+
} // namespace JTestKeep
|
|
110
|
+
|
|
111
|
+
} // namespace TestTextOptions
|
|
112
|
+
|
|
113
|
+
} // namespace QualityAssurance
|
|
114
|
+
|
|
115
|
+
} // namespace Thunder
|
|
116
|
+
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestTextOptionsTestLegacy.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace TestTextOptions {
|
|
13
|
+
|
|
14
|
+
namespace JTestLegacy {
|
|
15
|
+
|
|
16
|
+
namespace Version {
|
|
17
|
+
|
|
18
|
+
constexpr uint8_t Major = 1;
|
|
19
|
+
constexpr uint8_t Minor = 0;
|
|
20
|
+
constexpr uint8_t Patch = 0;
|
|
21
|
+
|
|
22
|
+
} // namespace Version
|
|
23
|
+
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
25
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
26
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
27
|
+
|
|
28
|
+
template<typename MODULE>
|
|
29
|
+
static void Register(MODULE& _module__, ITestTextOptions::ITestLegacy* _implementation__)
|
|
30
|
+
{
|
|
31
|
+
ASSERT(_implementation__ != nullptr);
|
|
32
|
+
|
|
33
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestLegacy"), Version::Major, Version::Minor, Version::Patch);
|
|
34
|
+
|
|
35
|
+
// Register methods and properties...
|
|
36
|
+
|
|
37
|
+
// Method: 'testlegacy' - Validates legacy which is lowercase
|
|
38
|
+
_module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo, void>(_T("testlegacy"),
|
|
39
|
+
[_implementation__](const JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo& params) -> uint32_t {
|
|
40
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
41
|
+
|
|
42
|
+
if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
|
|
43
|
+
TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestLegacy"), _T("testlegacy")));
|
|
44
|
+
_errorCode__ = Core::ERROR_BAD_REQUEST;
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const uint32_t _firstTestParam_{params.FirstTestParam};
|
|
48
|
+
const uint32_t _secondTestParam_{params.SecondTestParam};
|
|
49
|
+
const QualityAssurance::ITestTextOptions::ITestLegacy::TestDetails _thirdTestParam_(params.ThirdTestParam);
|
|
50
|
+
const QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions _fourthTestParam_{params.FourthTestParam};
|
|
51
|
+
|
|
52
|
+
_errorCode__ = _implementation__->TestLegacy(_firstTestParam_, _secondTestParam_, _thirdTestParam_, _fourthTestParam_);
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return (_errorCode__);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
template<typename MODULE>
|
|
62
|
+
static void Unregister(MODULE& _module__)
|
|
63
|
+
{
|
|
64
|
+
// Unregister methods and properties...
|
|
65
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("testlegacy"));
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
namespace Event {
|
|
69
|
+
|
|
70
|
+
// Event: 'testevent'
|
|
71
|
+
template<typename MODULE>
|
|
72
|
+
static void TestEvent(const MODULE& module_, const JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
73
|
+
{
|
|
74
|
+
module_.Notify(_T("testevent"), params, sendIfMethod_);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
// Event: 'testevent'
|
|
78
|
+
template<typename MODULE>
|
|
79
|
+
static void TestEvent(const MODULE& module_, const Core::JSON::DecUInt32& firstTestParam, const Core::JSON::DecUInt32& secondTestParam, const JsonData::TestTextOptions::TestLegacy::TestDetailsInfo& thirdTestParam, const Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions>& fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
80
|
+
{
|
|
81
|
+
JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo params_;
|
|
82
|
+
params_.FirstTestParam = firstTestParam;
|
|
83
|
+
params_.SecondTestParam = secondTestParam;
|
|
84
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
85
|
+
params_.FourthTestParam = fourthTestParam;
|
|
86
|
+
|
|
87
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// Event: 'testevent'
|
|
91
|
+
template<typename MODULE>
|
|
92
|
+
static void TestEvent(const MODULE& module_, const uint32_t firstTestParam, const uint32_t secondTestParam, const ITestTextOptions::ITestLegacy::TestDetails& thirdTestParam, const ITestTextOptions::ITestLegacy::EnumTextOptions fourthTestParam, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
|
|
93
|
+
{
|
|
94
|
+
JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo params_;
|
|
95
|
+
params_.FirstTestParam = firstTestParam;
|
|
96
|
+
params_.SecondTestParam = secondTestParam;
|
|
97
|
+
params_.ThirdTestParam = thirdTestParam;
|
|
98
|
+
params_.FourthTestParam = fourthTestParam;
|
|
99
|
+
|
|
100
|
+
TestEvent(module_, params_, sendIfMethod_);
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
} // namespace Event
|
|
104
|
+
|
|
105
|
+
POP_WARNING()
|
|
106
|
+
POP_WARNING()
|
|
107
|
+
POP_WARNING()
|
|
108
|
+
|
|
109
|
+
} // namespace JTestLegacy
|
|
110
|
+
|
|
111
|
+
} // namespace TestTextOptions
|
|
112
|
+
|
|
113
|
+
} // namespace QualityAssurance
|
|
114
|
+
|
|
115
|
+
} // namespace Thunder
|
|
116
|
+
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
// Generated automatically from 'TestUtility.json'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestUtility.h"
|
|
6
|
+
|
|
7
|
+
namespace Thunder {
|
|
8
|
+
|
|
9
|
+
namespace Exchange {
|
|
10
|
+
|
|
11
|
+
namespace JTestUtility {
|
|
12
|
+
|
|
13
|
+
namespace Version {
|
|
14
|
+
|
|
15
|
+
constexpr uint8_t Major = 1;
|
|
16
|
+
constexpr uint8_t Minor = 0;
|
|
17
|
+
constexpr uint8_t Patch = 0;
|
|
18
|
+
|
|
19
|
+
} // namespace Version
|
|
20
|
+
|
|
21
|
+
} // namespace JTestUtility
|
|
22
|
+
|
|
23
|
+
} // namespace Exchange
|
|
24
|
+
|
|
25
|
+
} // namespace Thunder
|
|
26
|
+
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
#pragma once
|
|
4
|
+
#include "Module.h"
|
|
5
|
+
#include "JsonData_TestUtils.h"
|
|
6
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
7
|
+
|
|
8
|
+
namespace Thunder {
|
|
9
|
+
|
|
10
|
+
namespace QualityAssurance {
|
|
11
|
+
|
|
12
|
+
namespace JTestUtils {
|
|
13
|
+
|
|
14
|
+
namespace Version {
|
|
15
|
+
|
|
16
|
+
constexpr uint8_t Major = 1;
|
|
17
|
+
constexpr uint8_t Minor = 0;
|
|
18
|
+
constexpr uint8_t Patch = 0;
|
|
19
|
+
|
|
20
|
+
} // namespace Version
|
|
21
|
+
|
|
22
|
+
PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
|
|
23
|
+
PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
|
|
24
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
25
|
+
|
|
26
|
+
template<typename MODULE>
|
|
27
|
+
static void Register(MODULE& _module__, ITestUtils* _implementation__)
|
|
28
|
+
{
|
|
29
|
+
ASSERT(_implementation__ != nullptr);
|
|
30
|
+
|
|
31
|
+
_module__.PluginHost::JSONRPC::RegisterVersion(_T("JTestUtils"), Version::Major, Version::Minor, Version::Patch);
|
|
32
|
+
|
|
33
|
+
// Register methods and properties...
|
|
34
|
+
|
|
35
|
+
// Method: 'crash' - Causes a crash
|
|
36
|
+
_module__.PluginHost::JSONRPC::template Register<void, void>(_T("crash"),
|
|
37
|
+
[_implementation__]() -> uint32_t {
|
|
38
|
+
uint32_t _errorCode__ = Core::ERROR_NONE;
|
|
39
|
+
|
|
40
|
+
_errorCode__ = _implementation__->Crash();
|
|
41
|
+
|
|
42
|
+
return (_errorCode__);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
template<typename MODULE>
|
|
48
|
+
static void Unregister(MODULE& _module__)
|
|
49
|
+
{
|
|
50
|
+
// Unregister methods and properties...
|
|
51
|
+
_module__.PluginHost::JSONRPC::Unregister(_T("crash"));
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
POP_WARNING()
|
|
55
|
+
POP_WARNING()
|
|
56
|
+
POP_WARNING()
|
|
57
|
+
|
|
58
|
+
} // namespace JTestUtils
|
|
59
|
+
|
|
60
|
+
} // namespace QualityAssurance
|
|
61
|
+
|
|
62
|
+
} // namespace Thunder
|
|
63
|
+
|
|
@@ -0,0 +1,437 @@
|
|
|
1
|
+
// C++ types for Benchmark API.
|
|
2
|
+
// Generated automatically from 'IBenchmark.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/IBenchmark.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Benchmark {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class BenchmarkResultData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
class MemoryStatsData : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
MemoryStatsData()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
_Init();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
MemoryStatsData(const MemoryStatsData& _other)
|
|
33
|
+
: Core::JSON::Container()
|
|
34
|
+
, ResidentBefore(_other.ResidentBefore)
|
|
35
|
+
, ResidentAfter(_other.ResidentAfter)
|
|
36
|
+
, AllocatedBefore(_other.AllocatedBefore)
|
|
37
|
+
, AllocatedAfter(_other.AllocatedAfter)
|
|
38
|
+
{
|
|
39
|
+
_Init();
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
MemoryStatsData(MemoryStatsData&& _other) noexcept
|
|
43
|
+
: Core::JSON::Container()
|
|
44
|
+
, ResidentBefore(std::move(_other.ResidentBefore))
|
|
45
|
+
, ResidentAfter(std::move(_other.ResidentAfter))
|
|
46
|
+
, AllocatedBefore(std::move(_other.AllocatedBefore))
|
|
47
|
+
, AllocatedAfter(std::move(_other.AllocatedAfter))
|
|
48
|
+
{
|
|
49
|
+
_Init();
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
MemoryStatsData(const QualityAssurance::IBenchmark::MemoryStats& _other)
|
|
53
|
+
: Core::JSON::Container()
|
|
54
|
+
{
|
|
55
|
+
ResidentBefore = _other.residentBefore;
|
|
56
|
+
ResidentAfter = _other.residentAfter;
|
|
57
|
+
AllocatedBefore = _other.allocatedBefore;
|
|
58
|
+
AllocatedAfter = _other.allocatedAfter;
|
|
59
|
+
_Init();
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
MemoryStatsData& operator=(const MemoryStatsData& _rhs)
|
|
63
|
+
{
|
|
64
|
+
ResidentBefore = _rhs.ResidentBefore;
|
|
65
|
+
ResidentAfter = _rhs.ResidentAfter;
|
|
66
|
+
AllocatedBefore = _rhs.AllocatedBefore;
|
|
67
|
+
AllocatedAfter = _rhs.AllocatedAfter;
|
|
68
|
+
return (*this);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
MemoryStatsData& operator=(MemoryStatsData&& _rhs) noexcept
|
|
72
|
+
{
|
|
73
|
+
ResidentBefore = std::move(_rhs.ResidentBefore);
|
|
74
|
+
ResidentAfter = std::move(_rhs.ResidentAfter);
|
|
75
|
+
AllocatedBefore = std::move(_rhs.AllocatedBefore);
|
|
76
|
+
AllocatedAfter = std::move(_rhs.AllocatedAfter);
|
|
77
|
+
return (*this);
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
MemoryStatsData& operator=(const QualityAssurance::IBenchmark::MemoryStats& _rhs)
|
|
81
|
+
{
|
|
82
|
+
ResidentBefore = _rhs.residentBefore;
|
|
83
|
+
ResidentAfter = _rhs.residentAfter;
|
|
84
|
+
AllocatedBefore = _rhs.allocatedBefore;
|
|
85
|
+
AllocatedAfter = _rhs.allocatedAfter;
|
|
86
|
+
return (*this);
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
operator QualityAssurance::IBenchmark::MemoryStats() const
|
|
90
|
+
{
|
|
91
|
+
QualityAssurance::IBenchmark::MemoryStats _value{};
|
|
92
|
+
_value.residentBefore = ResidentBefore;
|
|
93
|
+
_value.residentAfter = ResidentAfter;
|
|
94
|
+
_value.allocatedBefore = AllocatedBefore;
|
|
95
|
+
_value.allocatedAfter = AllocatedAfter;
|
|
96
|
+
return (_value);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
~MemoryStatsData() = default;
|
|
100
|
+
|
|
101
|
+
public:
|
|
102
|
+
bool IsDataValid() const
|
|
103
|
+
{
|
|
104
|
+
return ((ResidentBefore.IsSet() == true) && (ResidentAfter.IsSet() == true) && (AllocatedBefore.IsSet() == true) && (AllocatedAfter.IsSet() == true));
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
private:
|
|
108
|
+
void _Init()
|
|
109
|
+
{
|
|
110
|
+
Add(_T("residentBefore"), &ResidentBefore);
|
|
111
|
+
Add(_T("residentAfter"), &ResidentAfter);
|
|
112
|
+
Add(_T("allocatedBefore"), &AllocatedBefore);
|
|
113
|
+
Add(_T("allocatedAfter"), &AllocatedAfter);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
public:
|
|
117
|
+
Core::JSON::DecUInt64 ResidentBefore;
|
|
118
|
+
Core::JSON::DecUInt64 ResidentAfter;
|
|
119
|
+
Core::JSON::DecUInt64 AllocatedBefore;
|
|
120
|
+
Core::JSON::DecUInt64 AllocatedAfter;
|
|
121
|
+
}; // class MemoryStatsData
|
|
122
|
+
|
|
123
|
+
class RoundTripStatsData : public Core::JSON::Container {
|
|
124
|
+
public:
|
|
125
|
+
RoundTripStatsData()
|
|
126
|
+
: Core::JSON::Container()
|
|
127
|
+
{
|
|
128
|
+
_Init();
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
RoundTripStatsData(const RoundTripStatsData& _other)
|
|
132
|
+
: Core::JSON::Container()
|
|
133
|
+
, MinNs(_other.MinNs)
|
|
134
|
+
, AvgNs(_other.AvgNs)
|
|
135
|
+
, MaxNs(_other.MaxNs)
|
|
136
|
+
, StddevNs(_other.StddevNs)
|
|
137
|
+
{
|
|
138
|
+
_Init();
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
RoundTripStatsData(RoundTripStatsData&& _other) noexcept
|
|
142
|
+
: Core::JSON::Container()
|
|
143
|
+
, MinNs(std::move(_other.MinNs))
|
|
144
|
+
, AvgNs(std::move(_other.AvgNs))
|
|
145
|
+
, MaxNs(std::move(_other.MaxNs))
|
|
146
|
+
, StddevNs(std::move(_other.StddevNs))
|
|
147
|
+
{
|
|
148
|
+
_Init();
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
RoundTripStatsData(const QualityAssurance::IBenchmark::RoundTripStats& _other)
|
|
152
|
+
: Core::JSON::Container()
|
|
153
|
+
{
|
|
154
|
+
MinNs = _other.minNs;
|
|
155
|
+
AvgNs = _other.avgNs;
|
|
156
|
+
MaxNs = _other.maxNs;
|
|
157
|
+
StddevNs = _other.stddevNs;
|
|
158
|
+
_Init();
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
RoundTripStatsData& operator=(const RoundTripStatsData& _rhs)
|
|
162
|
+
{
|
|
163
|
+
MinNs = _rhs.MinNs;
|
|
164
|
+
AvgNs = _rhs.AvgNs;
|
|
165
|
+
MaxNs = _rhs.MaxNs;
|
|
166
|
+
StddevNs = _rhs.StddevNs;
|
|
167
|
+
return (*this);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
RoundTripStatsData& operator=(RoundTripStatsData&& _rhs) noexcept
|
|
171
|
+
{
|
|
172
|
+
MinNs = std::move(_rhs.MinNs);
|
|
173
|
+
AvgNs = std::move(_rhs.AvgNs);
|
|
174
|
+
MaxNs = std::move(_rhs.MaxNs);
|
|
175
|
+
StddevNs = std::move(_rhs.StddevNs);
|
|
176
|
+
return (*this);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
RoundTripStatsData& operator=(const QualityAssurance::IBenchmark::RoundTripStats& _rhs)
|
|
180
|
+
{
|
|
181
|
+
MinNs = _rhs.minNs;
|
|
182
|
+
AvgNs = _rhs.avgNs;
|
|
183
|
+
MaxNs = _rhs.maxNs;
|
|
184
|
+
StddevNs = _rhs.stddevNs;
|
|
185
|
+
return (*this);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
operator QualityAssurance::IBenchmark::RoundTripStats() const
|
|
189
|
+
{
|
|
190
|
+
QualityAssurance::IBenchmark::RoundTripStats _value{};
|
|
191
|
+
_value.minNs = MinNs;
|
|
192
|
+
_value.avgNs = AvgNs;
|
|
193
|
+
_value.maxNs = MaxNs;
|
|
194
|
+
_value.stddevNs = StddevNs;
|
|
195
|
+
return (_value);
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
~RoundTripStatsData() = default;
|
|
199
|
+
|
|
200
|
+
public:
|
|
201
|
+
bool IsDataValid() const
|
|
202
|
+
{
|
|
203
|
+
return ((MinNs.IsSet() == true) && (AvgNs.IsSet() == true) && (MaxNs.IsSet() == true) && (StddevNs.IsSet() == true));
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
private:
|
|
207
|
+
void _Init()
|
|
208
|
+
{
|
|
209
|
+
Add(_T("minNs"), &MinNs);
|
|
210
|
+
Add(_T("avgNs"), &AvgNs);
|
|
211
|
+
Add(_T("maxNs"), &MaxNs);
|
|
212
|
+
Add(_T("stddevNs"), &StddevNs);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
public:
|
|
216
|
+
Core::JSON::DecUInt64 MinNs;
|
|
217
|
+
Core::JSON::DecUInt64 AvgNs;
|
|
218
|
+
Core::JSON::DecUInt64 MaxNs;
|
|
219
|
+
Core::JSON::DecUInt64 StddevNs;
|
|
220
|
+
}; // class RoundTripStatsData
|
|
221
|
+
|
|
222
|
+
BenchmarkResultData()
|
|
223
|
+
: Core::JSON::Container()
|
|
224
|
+
{
|
|
225
|
+
_Init();
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
BenchmarkResultData(const BenchmarkResultData& _other)
|
|
229
|
+
: Core::JSON::Container()
|
|
230
|
+
, ApiName(_other.ApiName)
|
|
231
|
+
, Iterations(_other.Iterations)
|
|
232
|
+
, RoundTrip(_other.RoundTrip)
|
|
233
|
+
, Memory(_other.Memory)
|
|
234
|
+
, Passed(_other.Passed)
|
|
235
|
+
, FailureReason(_other.FailureReason)
|
|
236
|
+
{
|
|
237
|
+
_Init();
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
BenchmarkResultData(BenchmarkResultData&& _other) noexcept
|
|
241
|
+
: Core::JSON::Container()
|
|
242
|
+
, ApiName(std::move(_other.ApiName))
|
|
243
|
+
, Iterations(std::move(_other.Iterations))
|
|
244
|
+
, RoundTrip(std::move(_other.RoundTrip))
|
|
245
|
+
, Memory(std::move(_other.Memory))
|
|
246
|
+
, Passed(std::move(_other.Passed))
|
|
247
|
+
, FailureReason(std::move(_other.FailureReason))
|
|
248
|
+
{
|
|
249
|
+
_Init();
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
BenchmarkResultData(const QualityAssurance::IBenchmark::BenchmarkResult& _other)
|
|
253
|
+
: Core::JSON::Container()
|
|
254
|
+
{
|
|
255
|
+
ApiName = _other.apiName;
|
|
256
|
+
Iterations = _other.iterations;
|
|
257
|
+
RoundTrip.Set(true);
|
|
258
|
+
RoundTrip = _other.roundTrip;
|
|
259
|
+
Memory.Set(true);
|
|
260
|
+
Memory = _other.memory;
|
|
261
|
+
Passed = _other.passed;
|
|
262
|
+
if (_other.failureReason.IsSet() == true) {
|
|
263
|
+
FailureReason = _other.failureReason.Value();
|
|
264
|
+
}
|
|
265
|
+
_Init();
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
BenchmarkResultData& operator=(const BenchmarkResultData& _rhs)
|
|
269
|
+
{
|
|
270
|
+
ApiName = _rhs.ApiName;
|
|
271
|
+
Iterations = _rhs.Iterations;
|
|
272
|
+
RoundTrip = _rhs.RoundTrip;
|
|
273
|
+
Memory = _rhs.Memory;
|
|
274
|
+
Passed = _rhs.Passed;
|
|
275
|
+
if (_rhs.FailureReason.IsSet() == true) {
|
|
276
|
+
FailureReason = _rhs.FailureReason;
|
|
277
|
+
}
|
|
278
|
+
return (*this);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
BenchmarkResultData& operator=(BenchmarkResultData&& _rhs) noexcept
|
|
282
|
+
{
|
|
283
|
+
ApiName = std::move(_rhs.ApiName);
|
|
284
|
+
Iterations = std::move(_rhs.Iterations);
|
|
285
|
+
RoundTrip = std::move(_rhs.RoundTrip);
|
|
286
|
+
Memory = std::move(_rhs.Memory);
|
|
287
|
+
Passed = std::move(_rhs.Passed);
|
|
288
|
+
FailureReason = std::move(_rhs.FailureReason);
|
|
289
|
+
return (*this);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
BenchmarkResultData& operator=(const QualityAssurance::IBenchmark::BenchmarkResult& _rhs)
|
|
293
|
+
{
|
|
294
|
+
ApiName = _rhs.apiName;
|
|
295
|
+
Iterations = _rhs.iterations;
|
|
296
|
+
RoundTrip.Set(true);
|
|
297
|
+
RoundTrip = _rhs.roundTrip;
|
|
298
|
+
Memory.Set(true);
|
|
299
|
+
Memory = _rhs.memory;
|
|
300
|
+
Passed = _rhs.passed;
|
|
301
|
+
if (_rhs.failureReason.IsSet() == true) {
|
|
302
|
+
FailureReason = _rhs.failureReason.Value();
|
|
303
|
+
}
|
|
304
|
+
return (*this);
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
operator QualityAssurance::IBenchmark::BenchmarkResult() const
|
|
308
|
+
{
|
|
309
|
+
QualityAssurance::IBenchmark::BenchmarkResult _value{};
|
|
310
|
+
_value.apiName = ApiName;
|
|
311
|
+
_value.iterations = Iterations;
|
|
312
|
+
_value.roundTrip = RoundTrip;
|
|
313
|
+
_value.memory = Memory;
|
|
314
|
+
_value.passed = Passed;
|
|
315
|
+
if (FailureReason.IsSet() == true) {
|
|
316
|
+
_value.failureReason = FailureReason;
|
|
317
|
+
}
|
|
318
|
+
return (_value);
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
~BenchmarkResultData() = default;
|
|
322
|
+
|
|
323
|
+
public:
|
|
324
|
+
bool IsDataValid() const
|
|
325
|
+
{
|
|
326
|
+
return ((ApiName.IsSet() == true) && (Iterations.IsSet() == true) && ((RoundTrip.IsSet() == true) && (RoundTrip.IsDataValid() == true)) && ((Memory.IsSet() == true) && (Memory.IsDataValid() == true)) && (Passed.IsSet() == true));
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
private:
|
|
330
|
+
void _Init()
|
|
331
|
+
{
|
|
332
|
+
Add(_T("apiName"), &ApiName);
|
|
333
|
+
Add(_T("iterations"), &Iterations);
|
|
334
|
+
Add(_T("roundTrip"), &RoundTrip);
|
|
335
|
+
Add(_T("memory"), &Memory);
|
|
336
|
+
Add(_T("passed"), &Passed);
|
|
337
|
+
Add(_T("failureReason"), &FailureReason);
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
public:
|
|
341
|
+
Core::JSON::String ApiName;
|
|
342
|
+
Core::JSON::DecUInt32 Iterations;
|
|
343
|
+
BenchmarkResultData::RoundTripStatsData RoundTrip;
|
|
344
|
+
BenchmarkResultData::MemoryStatsData Memory;
|
|
345
|
+
Core::JSON::Boolean Passed;
|
|
346
|
+
Core::JSON::EnumType<QualityAssurance::IBenchmark::FailureReason> FailureReason;
|
|
347
|
+
}; // class BenchmarkResultData
|
|
348
|
+
|
|
349
|
+
class LatencyThresholdData : public Core::JSON::Container {
|
|
350
|
+
public:
|
|
351
|
+
LatencyThresholdData()
|
|
352
|
+
: Core::JSON::Container()
|
|
353
|
+
{
|
|
354
|
+
Add(_T("value"), &Value);
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
LatencyThresholdData(const LatencyThresholdData&) = delete;
|
|
358
|
+
LatencyThresholdData(LatencyThresholdData&&) noexcept = delete;
|
|
359
|
+
|
|
360
|
+
LatencyThresholdData& operator=(const LatencyThresholdData&) = delete;
|
|
361
|
+
LatencyThresholdData& operator=(LatencyThresholdData&&) noexcept = delete;
|
|
362
|
+
|
|
363
|
+
~LatencyThresholdData() = default;
|
|
364
|
+
|
|
365
|
+
public:
|
|
366
|
+
bool IsDataValid() const
|
|
367
|
+
{
|
|
368
|
+
return (Value.IsSet() == true);
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
public:
|
|
372
|
+
Core::JSON::DecUInt32 Value; // Maximum allowed deviation in avg latency compared to first-run baseline, in millipercent (1000 = 1%, 0 = no latency check)
|
|
373
|
+
}; // class LatencyThresholdData
|
|
374
|
+
|
|
375
|
+
class MemoryThresholdData : public Core::JSON::Container {
|
|
376
|
+
public:
|
|
377
|
+
MemoryThresholdData()
|
|
378
|
+
: Core::JSON::Container()
|
|
379
|
+
{
|
|
380
|
+
Add(_T("value"), &Value);
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
MemoryThresholdData(const MemoryThresholdData&) = delete;
|
|
384
|
+
MemoryThresholdData(MemoryThresholdData&&) noexcept = delete;
|
|
385
|
+
|
|
386
|
+
MemoryThresholdData& operator=(const MemoryThresholdData&) = delete;
|
|
387
|
+
MemoryThresholdData& operator=(MemoryThresholdData&&) noexcept = delete;
|
|
388
|
+
|
|
389
|
+
~MemoryThresholdData() = default;
|
|
390
|
+
|
|
391
|
+
public:
|
|
392
|
+
bool IsDataValid() const
|
|
393
|
+
{
|
|
394
|
+
return (Value.IsSet() == true);
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
public:
|
|
398
|
+
Core::JSON::DecUInt64 Value; // Maximum allowed RSS growth in bytes per method (0 = no memory check)
|
|
399
|
+
}; // class MemoryThresholdData
|
|
400
|
+
|
|
401
|
+
class TriggerParamsData : public Core::JSON::Container {
|
|
402
|
+
public:
|
|
403
|
+
TriggerParamsData()
|
|
404
|
+
: Core::JSON::Container()
|
|
405
|
+
{
|
|
406
|
+
Add(_T("iterations"), &Iterations);
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
TriggerParamsData(const TriggerParamsData&) = delete;
|
|
410
|
+
TriggerParamsData(TriggerParamsData&&) noexcept = delete;
|
|
411
|
+
|
|
412
|
+
TriggerParamsData& operator=(const TriggerParamsData&) = delete;
|
|
413
|
+
TriggerParamsData& operator=(TriggerParamsData&&) noexcept = delete;
|
|
414
|
+
|
|
415
|
+
~TriggerParamsData() = default;
|
|
416
|
+
|
|
417
|
+
public:
|
|
418
|
+
bool IsDataValid() const
|
|
419
|
+
{
|
|
420
|
+
return (Iterations.IsSet() == true);
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
public:
|
|
424
|
+
Core::JSON::DecUInt32 Iterations; // Denotes the number of iterations the benchmark should run
|
|
425
|
+
}; // class TriggerParamsData
|
|
426
|
+
|
|
427
|
+
} // namespace Benchmark
|
|
428
|
+
|
|
429
|
+
POP_WARNING()
|
|
430
|
+
|
|
431
|
+
} // namespace JsonData
|
|
432
|
+
|
|
433
|
+
// Enum conversion handlers
|
|
434
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::IBenchmark::FailureReason)
|
|
435
|
+
|
|
436
|
+
}
|
|
437
|
+
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
// C++ types for ComRpc API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace ComRpc {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class TestBigStringParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
TestBigStringParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("length"), &Length);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
TestBigStringParamsData(const TestBigStringParamsData&) = delete;
|
|
31
|
+
TestBigStringParamsData(TestBigStringParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
TestBigStringParamsData& operator=(const TestBigStringParamsData&) = delete;
|
|
34
|
+
TestBigStringParamsData& operator=(TestBigStringParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~TestBigStringParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Length.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecUInt32 Length; // Validates big string over proxy-stub with given length of KB
|
|
46
|
+
}; // class TestBigStringParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace ComRpc
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
// C++ types for Memory API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace Memory {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class AllocateMemoryParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
AllocateMemoryParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("size"), &Size);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
AllocateMemoryParamsData(const AllocateMemoryParamsData&) = delete;
|
|
31
|
+
AllocateMemoryParamsData(AllocateMemoryParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
AllocateMemoryParamsData& operator=(const AllocateMemoryParamsData&) = delete;
|
|
34
|
+
AllocateMemoryParamsData& operator=(AllocateMemoryParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~AllocateMemoryParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Size.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::DecUInt32 Size; // Allocates Memory as given size of MB
|
|
46
|
+
}; // class AllocateMemoryParamsData
|
|
47
|
+
|
|
48
|
+
} // namespace Memory
|
|
49
|
+
|
|
50
|
+
POP_WARNING()
|
|
51
|
+
|
|
52
|
+
} // namespace JsonData
|
|
53
|
+
|
|
54
|
+
}
|
|
55
|
+
|
|
@@ -0,0 +1,142 @@
|
|
|
1
|
+
// C++ types for Test Controller API.
|
|
2
|
+
// Generated automatically from 'TestController.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
namespace JsonData {
|
|
13
|
+
|
|
14
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
15
|
+
|
|
16
|
+
namespace TestController {
|
|
17
|
+
|
|
18
|
+
// Method params/result classes
|
|
19
|
+
//
|
|
20
|
+
|
|
21
|
+
class DescriptionData : public Core::JSON::Container {
|
|
22
|
+
public:
|
|
23
|
+
DescriptionData()
|
|
24
|
+
: Core::JSON::Container()
|
|
25
|
+
{
|
|
26
|
+
Add(_T("description"), &Description);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
DescriptionData(const DescriptionData&) = delete;
|
|
30
|
+
DescriptionData(DescriptionData&&) noexcept = delete;
|
|
31
|
+
|
|
32
|
+
DescriptionData& operator=(const DescriptionData&) = delete;
|
|
33
|
+
DescriptionData& operator=(DescriptionData&&) noexcept = delete;
|
|
34
|
+
|
|
35
|
+
~DescriptionData() = default;
|
|
36
|
+
|
|
37
|
+
public:
|
|
38
|
+
bool IsDataValid() const
|
|
39
|
+
{
|
|
40
|
+
return (Description.IsSet() == true);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
public:
|
|
44
|
+
Core::JSON::String Description; // Test description
|
|
45
|
+
}; // class DescriptionData
|
|
46
|
+
|
|
47
|
+
class RunParamsData : public Core::JSON::Container {
|
|
48
|
+
public:
|
|
49
|
+
RunParamsData()
|
|
50
|
+
: Core::JSON::Container()
|
|
51
|
+
{
|
|
52
|
+
Add(_T("category"), &Category);
|
|
53
|
+
Add(_T("test"), &Test);
|
|
54
|
+
Add(_T("args"), &Args);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
RunParamsData(const RunParamsData&) = delete;
|
|
58
|
+
RunParamsData(RunParamsData&&) noexcept = delete;
|
|
59
|
+
|
|
60
|
+
RunParamsData& operator=(const RunParamsData&) = delete;
|
|
61
|
+
RunParamsData& operator=(RunParamsData&&) noexcept = delete;
|
|
62
|
+
|
|
63
|
+
~RunParamsData() = default;
|
|
64
|
+
|
|
65
|
+
public:
|
|
66
|
+
bool IsDataValid() const
|
|
67
|
+
{
|
|
68
|
+
return ((Category.IsSet() == true) && (Test.IsSet() == true) && (Args.IsSet() == true));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
public:
|
|
72
|
+
Core::JSON::String Category; // Test category name, if omitted: all tests are executed
|
|
73
|
+
Core::JSON::String Test; // Test name, if omitted: all tests of category are executed
|
|
74
|
+
Core::JSON::String Args; // The test arguments in JSON format
|
|
75
|
+
}; // class RunParamsData
|
|
76
|
+
|
|
77
|
+
class RunResultDataElem : public Core::JSON::Container {
|
|
78
|
+
public:
|
|
79
|
+
RunResultDataElem()
|
|
80
|
+
: Core::JSON::Container()
|
|
81
|
+
{
|
|
82
|
+
_Init();
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
RunResultDataElem(const RunResultDataElem& _other)
|
|
86
|
+
: Core::JSON::Container()
|
|
87
|
+
, Test(_other.Test)
|
|
88
|
+
, Status(_other.Status)
|
|
89
|
+
{
|
|
90
|
+
_Init();
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
RunResultDataElem(RunResultDataElem&& _other) noexcept
|
|
94
|
+
: Core::JSON::Container()
|
|
95
|
+
, Test(std::move(_other.Test))
|
|
96
|
+
, Status(std::move(_other.Status))
|
|
97
|
+
{
|
|
98
|
+
_Init();
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
RunResultDataElem& operator=(const RunResultDataElem& _rhs)
|
|
102
|
+
{
|
|
103
|
+
Test = _rhs.Test;
|
|
104
|
+
Status = _rhs.Status;
|
|
105
|
+
return (*this);
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
RunResultDataElem& operator=(RunResultDataElem&& _rhs) noexcept
|
|
109
|
+
{
|
|
110
|
+
Test = std::move(_rhs.Test);
|
|
111
|
+
Status = std::move(_rhs.Status);
|
|
112
|
+
return (*this);
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
~RunResultDataElem() = default;
|
|
116
|
+
|
|
117
|
+
public:
|
|
118
|
+
bool IsDataValid() const
|
|
119
|
+
{
|
|
120
|
+
return ((Test.IsSet() == true) && (Status.IsSet() == true));
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
private:
|
|
124
|
+
void _Init()
|
|
125
|
+
{
|
|
126
|
+
Add(_T("test"), &Test);
|
|
127
|
+
Add(_T("status"), &Status);
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
public:
|
|
131
|
+
Core::JSON::String Test; // Test name
|
|
132
|
+
Core::JSON::String Status; // Test status
|
|
133
|
+
}; // class RunResultDataElem
|
|
134
|
+
|
|
135
|
+
} // namespace TestController
|
|
136
|
+
|
|
137
|
+
POP_WARNING()
|
|
138
|
+
|
|
139
|
+
} // namespace JsonData
|
|
140
|
+
|
|
141
|
+
}
|
|
142
|
+
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
// C++ types for Test API.
|
|
2
|
+
// Generated automatically from 'ITestPlugin.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestPlugin.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestPlugin {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class EchoParamsData : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
EchoParamsData()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
Add(_T("input"), &Input);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
EchoParamsData(const EchoParamsData&) = delete;
|
|
31
|
+
EchoParamsData(EchoParamsData&&) noexcept = delete;
|
|
32
|
+
|
|
33
|
+
EchoParamsData& operator=(const EchoParamsData&) = delete;
|
|
34
|
+
EchoParamsData& operator=(EchoParamsData&&) noexcept = delete;
|
|
35
|
+
|
|
36
|
+
~EchoParamsData() = default;
|
|
37
|
+
|
|
38
|
+
public:
|
|
39
|
+
bool IsDataValid() const
|
|
40
|
+
{
|
|
41
|
+
return (Input.IsSet() == true);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
public:
|
|
45
|
+
Core::JSON::String Input;
|
|
46
|
+
}; // class EchoParamsData
|
|
47
|
+
|
|
48
|
+
class GreetParamsData : public Core::JSON::Container {
|
|
49
|
+
public:
|
|
50
|
+
GreetParamsData()
|
|
51
|
+
: Core::JSON::Container()
|
|
52
|
+
{
|
|
53
|
+
Add(_T("name"), &Name);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
GreetParamsData(const GreetParamsData&) = delete;
|
|
57
|
+
GreetParamsData(GreetParamsData&&) noexcept = delete;
|
|
58
|
+
|
|
59
|
+
GreetParamsData& operator=(const GreetParamsData&) = delete;
|
|
60
|
+
GreetParamsData& operator=(GreetParamsData&&) noexcept = delete;
|
|
61
|
+
|
|
62
|
+
~GreetParamsData() = default;
|
|
63
|
+
|
|
64
|
+
public:
|
|
65
|
+
bool IsDataValid() const
|
|
66
|
+
{
|
|
67
|
+
return (Name.IsSet() == true);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
public:
|
|
71
|
+
Core::JSON::String Name;
|
|
72
|
+
}; // class GreetParamsData
|
|
73
|
+
|
|
74
|
+
class OnGreetingParamsData : public Core::JSON::Container {
|
|
75
|
+
public:
|
|
76
|
+
OnGreetingParamsData()
|
|
77
|
+
: Core::JSON::Container()
|
|
78
|
+
{
|
|
79
|
+
Add(_T("message"), &Message);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
OnGreetingParamsData(const OnGreetingParamsData&) = delete;
|
|
83
|
+
OnGreetingParamsData(OnGreetingParamsData&&) noexcept = delete;
|
|
84
|
+
|
|
85
|
+
OnGreetingParamsData& operator=(const OnGreetingParamsData&) = delete;
|
|
86
|
+
OnGreetingParamsData& operator=(OnGreetingParamsData&&) noexcept = delete;
|
|
87
|
+
|
|
88
|
+
~OnGreetingParamsData() = default;
|
|
89
|
+
|
|
90
|
+
public:
|
|
91
|
+
bool IsDataValid() const
|
|
92
|
+
{
|
|
93
|
+
return (Message.IsSet() == true);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
public:
|
|
97
|
+
Core::JSON::String Message;
|
|
98
|
+
}; // class OnGreetingParamsData
|
|
99
|
+
|
|
100
|
+
} // namespace TestPlugin
|
|
101
|
+
|
|
102
|
+
POP_WARNING()
|
|
103
|
+
|
|
104
|
+
} // namespace JsonData
|
|
105
|
+
|
|
106
|
+
}
|
|
107
|
+
|
|
@@ -0,0 +1,148 @@
|
|
|
1
|
+
// C++ types for TestTextOptions API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestTextOptions {
|
|
18
|
+
|
|
19
|
+
// Common classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
class TestDetailsInfo : public Core::JSON::Container {
|
|
23
|
+
public:
|
|
24
|
+
TestDetailsInfo()
|
|
25
|
+
: Core::JSON::Container()
|
|
26
|
+
{
|
|
27
|
+
_Init();
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
TestDetailsInfo(const TestDetailsInfo& _other)
|
|
31
|
+
: Core::JSON::Container()
|
|
32
|
+
, TestDetailsFirst(_other.TestDetailsFirst)
|
|
33
|
+
, TestDetailsSecond(_other.TestDetailsSecond)
|
|
34
|
+
{
|
|
35
|
+
_Init();
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
TestDetailsInfo(TestDetailsInfo&& _other) noexcept
|
|
39
|
+
: Core::JSON::Container()
|
|
40
|
+
, TestDetailsFirst(std::move(_other.TestDetailsFirst))
|
|
41
|
+
, TestDetailsSecond(std::move(_other.TestDetailsSecond))
|
|
42
|
+
{
|
|
43
|
+
_Init();
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
TestDetailsInfo(const QualityAssurance::ITestTextOptions::TestDetails& _other)
|
|
47
|
+
: Core::JSON::Container()
|
|
48
|
+
{
|
|
49
|
+
TestDetailsFirst = _other.testDetailsFirst;
|
|
50
|
+
TestDetailsSecond = _other.testDetailsSecond;
|
|
51
|
+
_Init();
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
TestDetailsInfo& operator=(const TestDetailsInfo& _rhs)
|
|
55
|
+
{
|
|
56
|
+
TestDetailsFirst = _rhs.TestDetailsFirst;
|
|
57
|
+
TestDetailsSecond = _rhs.TestDetailsSecond;
|
|
58
|
+
return (*this);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
TestDetailsInfo& operator=(TestDetailsInfo&& _rhs) noexcept
|
|
62
|
+
{
|
|
63
|
+
TestDetailsFirst = std::move(_rhs.TestDetailsFirst);
|
|
64
|
+
TestDetailsSecond = std::move(_rhs.TestDetailsSecond);
|
|
65
|
+
return (*this);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
TestDetailsInfo& operator=(const QualityAssurance::ITestTextOptions::TestDetails& _rhs)
|
|
69
|
+
{
|
|
70
|
+
TestDetailsFirst = _rhs.testDetailsFirst;
|
|
71
|
+
TestDetailsSecond = _rhs.testDetailsSecond;
|
|
72
|
+
return (*this);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
operator QualityAssurance::ITestTextOptions::TestDetails() const
|
|
76
|
+
{
|
|
77
|
+
QualityAssurance::ITestTextOptions::TestDetails _value{};
|
|
78
|
+
_value.testDetailsFirst = TestDetailsFirst;
|
|
79
|
+
_value.testDetailsSecond = TestDetailsSecond;
|
|
80
|
+
return (_value);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
~TestDetailsInfo() = default;
|
|
84
|
+
|
|
85
|
+
public:
|
|
86
|
+
bool IsDataValid() const
|
|
87
|
+
{
|
|
88
|
+
return ((TestDetailsFirst.IsSet() == true) && (TestDetailsSecond.IsSet() == true));
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
private:
|
|
92
|
+
void _Init()
|
|
93
|
+
{
|
|
94
|
+
Add(_T("testDetailsFirst"), &TestDetailsFirst);
|
|
95
|
+
Add(_T("testDetailsSecond"), &TestDetailsSecond);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
public:
|
|
99
|
+
Core::JSON::String TestDetailsFirst;
|
|
100
|
+
Core::JSON::String TestDetailsSecond;
|
|
101
|
+
}; // class TestDetailsInfo
|
|
102
|
+
|
|
103
|
+
class TestStandardParamsInfo : public Core::JSON::Container {
|
|
104
|
+
public:
|
|
105
|
+
TestStandardParamsInfo()
|
|
106
|
+
: Core::JSON::Container()
|
|
107
|
+
{
|
|
108
|
+
Add(_T("firstTestParam"), &FirstTestParam);
|
|
109
|
+
Add(_T("secondTestParam"), &SecondTestParam);
|
|
110
|
+
Add(_T("thirdTestParam"), &ThirdTestParam);
|
|
111
|
+
Add(_T("fourthTestParam"), &FourthTestParam);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
TestStandardParamsInfo(const TestStandardParamsInfo&) = delete;
|
|
115
|
+
TestStandardParamsInfo(TestStandardParamsInfo&&) noexcept = delete;
|
|
116
|
+
|
|
117
|
+
TestStandardParamsInfo& operator=(const TestStandardParamsInfo&) = delete;
|
|
118
|
+
TestStandardParamsInfo& operator=(TestStandardParamsInfo&&) noexcept = delete;
|
|
119
|
+
|
|
120
|
+
~TestStandardParamsInfo() = default;
|
|
121
|
+
|
|
122
|
+
public:
|
|
123
|
+
bool IsDataValid() const
|
|
124
|
+
{
|
|
125
|
+
return ((FirstTestParam.IsSet() == true) && (SecondTestParam.IsSet() == true) && ((ThirdTestParam.IsSet() == true) && (ThirdTestParam.IsDataValid() == true)) && (FourthTestParam.IsSet() == true));
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
public:
|
|
129
|
+
Core::JSON::DecUInt32 FirstTestParam; // Validates standard which is camelCase
|
|
130
|
+
Core::JSON::DecUInt32 SecondTestParam; // Validates standard which is camelCase
|
|
131
|
+
TestDetailsInfo ThirdTestParam; // Validates standard which is camelCase
|
|
132
|
+
Core::JSON::EnumType<QualityAssurance::ITestTextOptions::EnumTextOptions> FourthTestParam; // Validates standard which is camelCase
|
|
133
|
+
}; // class TestStandardParamsInfo
|
|
134
|
+
|
|
135
|
+
// Method params/result classes
|
|
136
|
+
//
|
|
137
|
+
|
|
138
|
+
} // namespace TestTextOptions
|
|
139
|
+
|
|
140
|
+
POP_WARNING()
|
|
141
|
+
|
|
142
|
+
} // namespace JsonData
|
|
143
|
+
|
|
144
|
+
// Enum conversion handlers
|
|
145
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
146
|
+
|
|
147
|
+
}
|
|
148
|
+
|
|
@@ -0,0 +1,155 @@
|
|
|
1
|
+
// C++ types for TestCustom API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestTextOptions {
|
|
18
|
+
|
|
19
|
+
namespace TestCustom {
|
|
20
|
+
|
|
21
|
+
// Common classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class TestDetailsInfo : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
TestDetailsInfo()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
_Init();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
TestDetailsInfo(const TestDetailsInfo& _other)
|
|
33
|
+
: Core::JSON::Container()
|
|
34
|
+
, TestDetailsFirst(_other.TestDetailsFirst)
|
|
35
|
+
, TestDetailsSecond(_other.TestDetailsSecond)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
TestDetailsInfo(TestDetailsInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, TestDetailsFirst(std::move(_other.TestDetailsFirst))
|
|
43
|
+
, TestDetailsSecond(std::move(_other.TestDetailsSecond))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
TestDetailsInfo(const QualityAssurance::ITestTextOptions::ITestCustom::TestDetails& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
TestDetailsFirst = _other.testDetailsFirst;
|
|
52
|
+
TestDetailsSecond = _other.testDetailsSecond;
|
|
53
|
+
_Init();
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
TestDetailsInfo& operator=(const TestDetailsInfo& _rhs)
|
|
57
|
+
{
|
|
58
|
+
TestDetailsFirst = _rhs.TestDetailsFirst;
|
|
59
|
+
TestDetailsSecond = _rhs.TestDetailsSecond;
|
|
60
|
+
return (*this);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
TestDetailsInfo& operator=(TestDetailsInfo&& _rhs) noexcept
|
|
64
|
+
{
|
|
65
|
+
TestDetailsFirst = std::move(_rhs.TestDetailsFirst);
|
|
66
|
+
TestDetailsSecond = std::move(_rhs.TestDetailsSecond);
|
|
67
|
+
return (*this);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
TestDetailsInfo& operator=(const QualityAssurance::ITestTextOptions::ITestCustom::TestDetails& _rhs)
|
|
71
|
+
{
|
|
72
|
+
TestDetailsFirst = _rhs.testDetailsFirst;
|
|
73
|
+
TestDetailsSecond = _rhs.testDetailsSecond;
|
|
74
|
+
return (*this);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
operator QualityAssurance::ITestTextOptions::ITestCustom::TestDetails() const
|
|
78
|
+
{
|
|
79
|
+
QualityAssurance::ITestTextOptions::ITestCustom::TestDetails _value{};
|
|
80
|
+
_value.testDetailsFirst = TestDetailsFirst;
|
|
81
|
+
_value.testDetailsSecond = TestDetailsSecond;
|
|
82
|
+
return (_value);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
~TestDetailsInfo() = default;
|
|
86
|
+
|
|
87
|
+
public:
|
|
88
|
+
bool IsDataValid() const
|
|
89
|
+
{
|
|
90
|
+
return ((TestDetailsFirst.IsSet() == true) && (TestDetailsSecond.IsSet() == true));
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
private:
|
|
94
|
+
void _Init()
|
|
95
|
+
{
|
|
96
|
+
Add(_T("TestDetailsFirst"), &TestDetailsFirst);
|
|
97
|
+
Add(_T("TestDetailsSecond"), &TestDetailsSecond);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
Core::JSON::String TestDetailsFirst;
|
|
102
|
+
Core::JSON::String TestDetailsSecond;
|
|
103
|
+
}; // class TestDetailsInfo
|
|
104
|
+
|
|
105
|
+
class TestCustomParamsInfo : public Core::JSON::Container {
|
|
106
|
+
public:
|
|
107
|
+
TestCustomParamsInfo()
|
|
108
|
+
: Core::JSON::Container()
|
|
109
|
+
{
|
|
110
|
+
Add(_T("FIRST_TEST_PARAM"), &FirstTestParam);
|
|
111
|
+
Add(_T("SECOND_TEST_PARAM"), &SecondTestParam);
|
|
112
|
+
Add(_T("THIRD_TEST_PARAM"), &ThirdTestParam);
|
|
113
|
+
Add(_T("FOURTH_TEST_PARAM"), &FourthTestParam);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
TestCustomParamsInfo(const TestCustomParamsInfo&) = delete;
|
|
117
|
+
TestCustomParamsInfo(TestCustomParamsInfo&&) noexcept = delete;
|
|
118
|
+
|
|
119
|
+
TestCustomParamsInfo& operator=(const TestCustomParamsInfo&) = delete;
|
|
120
|
+
TestCustomParamsInfo& operator=(TestCustomParamsInfo&&) noexcept = delete;
|
|
121
|
+
|
|
122
|
+
~TestCustomParamsInfo() = default;
|
|
123
|
+
|
|
124
|
+
public:
|
|
125
|
+
bool IsDataValid() const
|
|
126
|
+
{
|
|
127
|
+
return ((FirstTestParam.IsSet() == true) && (SecondTestParam.IsSet() == true) && ((ThirdTestParam.IsSet() == true) && (ThirdTestParam.IsDataValid() == true)) && (FourthTestParam.IsSet() == true));
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
public:
|
|
131
|
+
Core::JSON::DecUInt32 FirstTestParam; // Validates custom generation
|
|
132
|
+
Core::JSON::DecUInt32 SecondTestParam; // Validates custom generation
|
|
133
|
+
TestDetailsInfo ThirdTestParam; // Validates custom generation
|
|
134
|
+
Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions> FourthTestParam; // Validates custom generation
|
|
135
|
+
}; // class TestCustomParamsInfo
|
|
136
|
+
|
|
137
|
+
// Method params/result classes
|
|
138
|
+
//
|
|
139
|
+
|
|
140
|
+
} // namespace TestCustom
|
|
141
|
+
|
|
142
|
+
} // namespace TestTextOptions
|
|
143
|
+
|
|
144
|
+
POP_WARNING()
|
|
145
|
+
|
|
146
|
+
} // namespace JsonData
|
|
147
|
+
|
|
148
|
+
// Enum conversion handlers
|
|
149
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
150
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
151
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions)
|
|
152
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions)
|
|
153
|
+
|
|
154
|
+
}
|
|
155
|
+
|
|
@@ -0,0 +1,186 @@
|
|
|
1
|
+
// C++ types for TestKeep API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestTextOptions {
|
|
18
|
+
|
|
19
|
+
namespace TestKeep {
|
|
20
|
+
|
|
21
|
+
// Common classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class TestDetailsInfo : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
TestDetailsInfo()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
_Init();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
TestDetailsInfo(const TestDetailsInfo& _other)
|
|
33
|
+
: Core::JSON::Container()
|
|
34
|
+
, TestDetailsFirst(_other.TestDetailsFirst)
|
|
35
|
+
, TestDetailsSecond(_other.TestDetailsSecond)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
TestDetailsInfo(TestDetailsInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, TestDetailsFirst(std::move(_other.TestDetailsFirst))
|
|
43
|
+
, TestDetailsSecond(std::move(_other.TestDetailsSecond))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
TestDetailsInfo(const QualityAssurance::ITestTextOptions::ITestKeep::TestDetails& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
TestDetailsFirst = _other.testDetailsFirst;
|
|
52
|
+
TestDetailsSecond = _other.testDetailsSecond;
|
|
53
|
+
_Init();
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
TestDetailsInfo& operator=(const TestDetailsInfo& _rhs)
|
|
57
|
+
{
|
|
58
|
+
TestDetailsFirst = _rhs.TestDetailsFirst;
|
|
59
|
+
TestDetailsSecond = _rhs.TestDetailsSecond;
|
|
60
|
+
return (*this);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
TestDetailsInfo& operator=(TestDetailsInfo&& _rhs) noexcept
|
|
64
|
+
{
|
|
65
|
+
TestDetailsFirst = std::move(_rhs.TestDetailsFirst);
|
|
66
|
+
TestDetailsSecond = std::move(_rhs.TestDetailsSecond);
|
|
67
|
+
return (*this);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
TestDetailsInfo& operator=(const QualityAssurance::ITestTextOptions::ITestKeep::TestDetails& _rhs)
|
|
71
|
+
{
|
|
72
|
+
TestDetailsFirst = _rhs.testDetailsFirst;
|
|
73
|
+
TestDetailsSecond = _rhs.testDetailsSecond;
|
|
74
|
+
return (*this);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
operator QualityAssurance::ITestTextOptions::ITestKeep::TestDetails() const
|
|
78
|
+
{
|
|
79
|
+
QualityAssurance::ITestTextOptions::ITestKeep::TestDetails _value{};
|
|
80
|
+
_value.testDetailsFirst = TestDetailsFirst;
|
|
81
|
+
_value.testDetailsSecond = TestDetailsSecond;
|
|
82
|
+
return (_value);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
~TestDetailsInfo() = default;
|
|
86
|
+
|
|
87
|
+
public:
|
|
88
|
+
bool IsDataValid() const
|
|
89
|
+
{
|
|
90
|
+
return ((TestDetailsFirst.IsSet() == true) && (TestDetailsSecond.IsSet() == true));
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
private:
|
|
94
|
+
void _Init()
|
|
95
|
+
{
|
|
96
|
+
Add(_T("testDetailsFirst"), &TestDetailsFirst);
|
|
97
|
+
Add(_T("testDetailsSecond"), &TestDetailsSecond);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
Core::JSON::String TestDetailsFirst;
|
|
102
|
+
Core::JSON::String TestDetailsSecond;
|
|
103
|
+
}; // class TestDetailsInfo
|
|
104
|
+
|
|
105
|
+
// Method params/result classes
|
|
106
|
+
//
|
|
107
|
+
|
|
108
|
+
class TestEventParamsData : public Core::JSON::Container {
|
|
109
|
+
public:
|
|
110
|
+
TestEventParamsData()
|
|
111
|
+
: Core::JSON::Container()
|
|
112
|
+
{
|
|
113
|
+
Add(_T("firstTestParam"), &FirstTestParam);
|
|
114
|
+
Add(_T("secondTestParam"), &SecondTestParam);
|
|
115
|
+
Add(_T("thirdTestParam"), &ThirdTestParam);
|
|
116
|
+
Add(_T("fourthTestParam"), &FourthTestParam);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
TestEventParamsData(const TestEventParamsData&) = delete;
|
|
120
|
+
TestEventParamsData(TestEventParamsData&&) noexcept = delete;
|
|
121
|
+
|
|
122
|
+
TestEventParamsData& operator=(const TestEventParamsData&) = delete;
|
|
123
|
+
TestEventParamsData& operator=(TestEventParamsData&&) noexcept = delete;
|
|
124
|
+
|
|
125
|
+
~TestEventParamsData() = default;
|
|
126
|
+
|
|
127
|
+
public:
|
|
128
|
+
bool IsDataValid() const
|
|
129
|
+
{
|
|
130
|
+
return ((FirstTestParam.IsSet() == true) && (SecondTestParam.IsSet() == true) && ((ThirdTestParam.IsSet() == true) && (ThirdTestParam.IsDataValid() == true)) && (FourthTestParam.IsSet() == true));
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
public:
|
|
134
|
+
Core::JSON::DecUInt32 FirstTestParam;
|
|
135
|
+
Core::JSON::DecUInt32 SecondTestParam;
|
|
136
|
+
TestDetailsInfo ThirdTestParam;
|
|
137
|
+
Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions> FourthTestParam;
|
|
138
|
+
}; // class TestEventParamsData
|
|
139
|
+
|
|
140
|
+
class TestKeePParamsData : public Core::JSON::Container {
|
|
141
|
+
public:
|
|
142
|
+
TestKeePParamsData()
|
|
143
|
+
: Core::JSON::Container()
|
|
144
|
+
{
|
|
145
|
+
Add(_T("firstTestParaM"), &FirstTestParaM);
|
|
146
|
+
Add(_T("secondTestParaM"), &SecondTestParaM);
|
|
147
|
+
Add(_T("thirdTestParaM"), &ThirdTestParaM);
|
|
148
|
+
Add(_T("fourthTestParaM"), &FourthTestParaM);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
TestKeePParamsData(const TestKeePParamsData&) = delete;
|
|
152
|
+
TestKeePParamsData(TestKeePParamsData&&) noexcept = delete;
|
|
153
|
+
|
|
154
|
+
TestKeePParamsData& operator=(const TestKeePParamsData&) = delete;
|
|
155
|
+
TestKeePParamsData& operator=(TestKeePParamsData&&) noexcept = delete;
|
|
156
|
+
|
|
157
|
+
~TestKeePParamsData() = default;
|
|
158
|
+
|
|
159
|
+
public:
|
|
160
|
+
bool IsDataValid() const
|
|
161
|
+
{
|
|
162
|
+
return ((FirstTestParaM.IsSet() == true) && (SecondTestParaM.IsSet() == true) && ((ThirdTestParaM.IsSet() == true) && (ThirdTestParaM.IsDataValid() == true)) && (FourthTestParaM.IsSet() == true));
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
public:
|
|
166
|
+
Core::JSON::DecUInt32 FirstTestParaM; // Validates keep which is as same as it's coded
|
|
167
|
+
Core::JSON::DecUInt32 SecondTestParaM; // Validates keep which is as same as it's coded
|
|
168
|
+
TestDetailsInfo ThirdTestParaM; // Validates keep which is as same as it's coded
|
|
169
|
+
Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions> FourthTestParaM; // Validates keep which is as same as it's coded
|
|
170
|
+
}; // class TestKeePParamsData
|
|
171
|
+
|
|
172
|
+
} // namespace TestKeep
|
|
173
|
+
|
|
174
|
+
} // namespace TestTextOptions
|
|
175
|
+
|
|
176
|
+
POP_WARNING()
|
|
177
|
+
|
|
178
|
+
} // namespace JsonData
|
|
179
|
+
|
|
180
|
+
// Enum conversion handlers
|
|
181
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
182
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
183
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions)
|
|
184
|
+
|
|
185
|
+
}
|
|
186
|
+
|
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
// C++ types for TestLegacy API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestTextOptions {
|
|
18
|
+
|
|
19
|
+
namespace TestLegacy {
|
|
20
|
+
|
|
21
|
+
// Common classes
|
|
22
|
+
//
|
|
23
|
+
|
|
24
|
+
class TestDetailsInfo : public Core::JSON::Container {
|
|
25
|
+
public:
|
|
26
|
+
TestDetailsInfo()
|
|
27
|
+
: Core::JSON::Container()
|
|
28
|
+
{
|
|
29
|
+
_Init();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
TestDetailsInfo(const TestDetailsInfo& _other)
|
|
33
|
+
: Core::JSON::Container()
|
|
34
|
+
, TestDetailsFirst(_other.TestDetailsFirst)
|
|
35
|
+
, TestDetailsSecond(_other.TestDetailsSecond)
|
|
36
|
+
{
|
|
37
|
+
_Init();
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
TestDetailsInfo(TestDetailsInfo&& _other) noexcept
|
|
41
|
+
: Core::JSON::Container()
|
|
42
|
+
, TestDetailsFirst(std::move(_other.TestDetailsFirst))
|
|
43
|
+
, TestDetailsSecond(std::move(_other.TestDetailsSecond))
|
|
44
|
+
{
|
|
45
|
+
_Init();
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
TestDetailsInfo(const QualityAssurance::ITestTextOptions::ITestLegacy::TestDetails& _other)
|
|
49
|
+
: Core::JSON::Container()
|
|
50
|
+
{
|
|
51
|
+
TestDetailsFirst = _other.testDetailsFirst;
|
|
52
|
+
TestDetailsSecond = _other.testDetailsSecond;
|
|
53
|
+
_Init();
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
TestDetailsInfo& operator=(const TestDetailsInfo& _rhs)
|
|
57
|
+
{
|
|
58
|
+
TestDetailsFirst = _rhs.TestDetailsFirst;
|
|
59
|
+
TestDetailsSecond = _rhs.TestDetailsSecond;
|
|
60
|
+
return (*this);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
TestDetailsInfo& operator=(TestDetailsInfo&& _rhs) noexcept
|
|
64
|
+
{
|
|
65
|
+
TestDetailsFirst = std::move(_rhs.TestDetailsFirst);
|
|
66
|
+
TestDetailsSecond = std::move(_rhs.TestDetailsSecond);
|
|
67
|
+
return (*this);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
TestDetailsInfo& operator=(const QualityAssurance::ITestTextOptions::ITestLegacy::TestDetails& _rhs)
|
|
71
|
+
{
|
|
72
|
+
TestDetailsFirst = _rhs.testDetailsFirst;
|
|
73
|
+
TestDetailsSecond = _rhs.testDetailsSecond;
|
|
74
|
+
return (*this);
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
operator QualityAssurance::ITestTextOptions::ITestLegacy::TestDetails() const
|
|
78
|
+
{
|
|
79
|
+
QualityAssurance::ITestTextOptions::ITestLegacy::TestDetails _value{};
|
|
80
|
+
_value.testDetailsFirst = TestDetailsFirst;
|
|
81
|
+
_value.testDetailsSecond = TestDetailsSecond;
|
|
82
|
+
return (_value);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
~TestDetailsInfo() = default;
|
|
86
|
+
|
|
87
|
+
public:
|
|
88
|
+
bool IsDataValid() const
|
|
89
|
+
{
|
|
90
|
+
return ((TestDetailsFirst.IsSet() == true) && (TestDetailsSecond.IsSet() == true));
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
private:
|
|
94
|
+
void _Init()
|
|
95
|
+
{
|
|
96
|
+
Add(_T("testdetailsfirst"), &TestDetailsFirst);
|
|
97
|
+
Add(_T("testdetailssecond"), &TestDetailsSecond);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
public:
|
|
101
|
+
Core::JSON::String TestDetailsFirst;
|
|
102
|
+
Core::JSON::String TestDetailsSecond;
|
|
103
|
+
}; // class TestDetailsInfo
|
|
104
|
+
|
|
105
|
+
class TestLegacyParamsInfo : public Core::JSON::Container {
|
|
106
|
+
public:
|
|
107
|
+
TestLegacyParamsInfo()
|
|
108
|
+
: Core::JSON::Container()
|
|
109
|
+
{
|
|
110
|
+
Add(_T("firsttestparam"), &FirstTestParam);
|
|
111
|
+
Add(_T("secondtestparam"), &SecondTestParam);
|
|
112
|
+
Add(_T("thirdtestparam"), &ThirdTestParam);
|
|
113
|
+
Add(_T("fourthtestparam"), &FourthTestParam);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
TestLegacyParamsInfo(const TestLegacyParamsInfo&) = delete;
|
|
117
|
+
TestLegacyParamsInfo(TestLegacyParamsInfo&&) noexcept = delete;
|
|
118
|
+
|
|
119
|
+
TestLegacyParamsInfo& operator=(const TestLegacyParamsInfo&) = delete;
|
|
120
|
+
TestLegacyParamsInfo& operator=(TestLegacyParamsInfo&&) noexcept = delete;
|
|
121
|
+
|
|
122
|
+
~TestLegacyParamsInfo() = default;
|
|
123
|
+
|
|
124
|
+
public:
|
|
125
|
+
bool IsDataValid() const
|
|
126
|
+
{
|
|
127
|
+
return ((FirstTestParam.IsSet() == true) && (SecondTestParam.IsSet() == true) && ((ThirdTestParam.IsSet() == true) && (ThirdTestParam.IsDataValid() == true)) && (FourthTestParam.IsSet() == true));
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
public:
|
|
131
|
+
Core::JSON::DecUInt32 FirstTestParam; // Validates legacy which is lowercase
|
|
132
|
+
Core::JSON::DecUInt32 SecondTestParam; // Validates legacy which is lowercase
|
|
133
|
+
TestDetailsInfo ThirdTestParam; // Validates legacy which is lowercase
|
|
134
|
+
Core::JSON::EnumType<QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions> FourthTestParam; // Validates legacy which is lowercase
|
|
135
|
+
}; // class TestLegacyParamsInfo
|
|
136
|
+
|
|
137
|
+
// Method params/result classes
|
|
138
|
+
//
|
|
139
|
+
|
|
140
|
+
} // namespace TestLegacy
|
|
141
|
+
|
|
142
|
+
} // namespace TestTextOptions
|
|
143
|
+
|
|
144
|
+
POP_WARNING()
|
|
145
|
+
|
|
146
|
+
} // namespace JsonData
|
|
147
|
+
|
|
148
|
+
// Enum conversion handlers
|
|
149
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
150
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
151
|
+
|
|
152
|
+
}
|
|
153
|
+
|
|
@@ -0,0 +1,253 @@
|
|
|
1
|
+
// C++ types for Test Utility API.
|
|
2
|
+
// Generated automatically from 'TestUtility.json'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <core/Enumerate.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestUtility {
|
|
18
|
+
|
|
19
|
+
// Common enums
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
// Test command parameter type
|
|
23
|
+
enum class TypeType : uint8_t {
|
|
24
|
+
NUMBER,
|
|
25
|
+
STRING,
|
|
26
|
+
BOOLEAN,
|
|
27
|
+
OBJECT,
|
|
28
|
+
SYMBOL
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
// Common classes
|
|
32
|
+
//
|
|
33
|
+
|
|
34
|
+
class ParameterInfo : public Core::JSON::Container {
|
|
35
|
+
public:
|
|
36
|
+
ParameterInfo()
|
|
37
|
+
: Core::JSON::Container()
|
|
38
|
+
{
|
|
39
|
+
_Init();
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
ParameterInfo(const ParameterInfo& _other)
|
|
43
|
+
: Core::JSON::Container()
|
|
44
|
+
, Name(_other.Name)
|
|
45
|
+
, Type(_other.Type)
|
|
46
|
+
, Comment(_other.Comment)
|
|
47
|
+
{
|
|
48
|
+
_Init();
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
ParameterInfo(ParameterInfo&& _other) noexcept
|
|
52
|
+
: Core::JSON::Container()
|
|
53
|
+
, Name(std::move(_other.Name))
|
|
54
|
+
, Type(std::move(_other.Type))
|
|
55
|
+
, Comment(std::move(_other.Comment))
|
|
56
|
+
{
|
|
57
|
+
_Init();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
ParameterInfo& operator=(const ParameterInfo& _rhs)
|
|
61
|
+
{
|
|
62
|
+
Name = _rhs.Name;
|
|
63
|
+
Type = _rhs.Type;
|
|
64
|
+
Comment = _rhs.Comment;
|
|
65
|
+
return (*this);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
ParameterInfo& operator=(ParameterInfo&& _rhs) noexcept
|
|
69
|
+
{
|
|
70
|
+
Name = std::move(_rhs.Name);
|
|
71
|
+
Type = std::move(_rhs.Type);
|
|
72
|
+
Comment = std::move(_rhs.Comment);
|
|
73
|
+
return (*this);
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
~ParameterInfo() = default;
|
|
77
|
+
|
|
78
|
+
public:
|
|
79
|
+
bool IsDataValid() const
|
|
80
|
+
{
|
|
81
|
+
return ((Name.IsSet() == true) && (Type.IsSet() == true) && (Comment.IsSet() == true));
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
private:
|
|
85
|
+
void _Init()
|
|
86
|
+
{
|
|
87
|
+
Add(_T("name"), &Name);
|
|
88
|
+
Add(_T("type"), &Type);
|
|
89
|
+
Add(_T("comment"), &Comment);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
public:
|
|
93
|
+
Core::JSON::String Name; // Test command parameter
|
|
94
|
+
Core::JSON::EnumType<TypeType> Type; // Test command parameter type
|
|
95
|
+
Core::JSON::String Comment; // Test command parameter description
|
|
96
|
+
}; // class ParameterInfo
|
|
97
|
+
|
|
98
|
+
// Method params/result classes
|
|
99
|
+
//
|
|
100
|
+
|
|
101
|
+
class DescriptionData : public Core::JSON::Container {
|
|
102
|
+
public:
|
|
103
|
+
DescriptionData()
|
|
104
|
+
: Core::JSON::Container()
|
|
105
|
+
{
|
|
106
|
+
Add(_T("description"), &Description);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
DescriptionData(const DescriptionData&) = delete;
|
|
110
|
+
DescriptionData(DescriptionData&&) noexcept = delete;
|
|
111
|
+
|
|
112
|
+
DescriptionData& operator=(const DescriptionData&) = delete;
|
|
113
|
+
DescriptionData& operator=(DescriptionData&&) noexcept = delete;
|
|
114
|
+
|
|
115
|
+
~DescriptionData() = default;
|
|
116
|
+
|
|
117
|
+
public:
|
|
118
|
+
bool IsDataValid() const
|
|
119
|
+
{
|
|
120
|
+
return (Description.IsSet() == true);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
public:
|
|
124
|
+
Core::JSON::String Description; // Test command description
|
|
125
|
+
}; // class DescriptionData
|
|
126
|
+
|
|
127
|
+
class ParametersData : public Core::JSON::Container {
|
|
128
|
+
public:
|
|
129
|
+
ParametersData()
|
|
130
|
+
: Core::JSON::Container()
|
|
131
|
+
{
|
|
132
|
+
Add(_T("input"), &Input);
|
|
133
|
+
Add(_T("output"), &Output);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
ParametersData(const ParametersData&) = delete;
|
|
137
|
+
ParametersData(ParametersData&&) noexcept = delete;
|
|
138
|
+
|
|
139
|
+
ParametersData& operator=(const ParametersData&) = delete;
|
|
140
|
+
ParametersData& operator=(ParametersData&&) noexcept = delete;
|
|
141
|
+
|
|
142
|
+
~ParametersData() = default;
|
|
143
|
+
|
|
144
|
+
public:
|
|
145
|
+
bool IsDataValid() const
|
|
146
|
+
{
|
|
147
|
+
return ((Output.IsSet() == true) && (Output.IsDataValid() == true));
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
public:
|
|
151
|
+
Core::JSON::ArrayType<ParameterInfo> Input; // Input parameter list
|
|
152
|
+
ParameterInfo Output; // Output parameter list
|
|
153
|
+
}; // class ParametersData
|
|
154
|
+
|
|
155
|
+
class RuncrashParamsData : public Core::JSON::Container {
|
|
156
|
+
public:
|
|
157
|
+
RuncrashParamsData()
|
|
158
|
+
: Core::JSON::Container()
|
|
159
|
+
{
|
|
160
|
+
Add(_T("command"), &Command);
|
|
161
|
+
Add(_T("delay"), &Delay);
|
|
162
|
+
Add(_T("count"), &Count);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
RuncrashParamsData(const RuncrashParamsData&) = delete;
|
|
166
|
+
RuncrashParamsData(RuncrashParamsData&&) noexcept = delete;
|
|
167
|
+
|
|
168
|
+
RuncrashParamsData& operator=(const RuncrashParamsData&) = delete;
|
|
169
|
+
RuncrashParamsData& operator=(RuncrashParamsData&&) noexcept = delete;
|
|
170
|
+
|
|
171
|
+
~RuncrashParamsData() = default;
|
|
172
|
+
|
|
173
|
+
public:
|
|
174
|
+
bool IsDataValid() const
|
|
175
|
+
{
|
|
176
|
+
return (Command.IsSet() == true);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
public:
|
|
180
|
+
Core::JSON::String Command; // Test command name
|
|
181
|
+
Core::JSON::DecUInt8 Delay; // Delay (in seconds) before the crash attempt (applicable for *Crash* command)
|
|
182
|
+
Core::JSON::DecUInt8 Count; // How many times a Crash command will be executed consecutively (applicable for *CrashNTimes* command)
|
|
183
|
+
}; // class RuncrashParamsData
|
|
184
|
+
|
|
185
|
+
class RunmemoryParamsData : public Core::JSON::Container {
|
|
186
|
+
public:
|
|
187
|
+
RunmemoryParamsData()
|
|
188
|
+
: Core::JSON::Container()
|
|
189
|
+
{
|
|
190
|
+
Add(_T("command"), &Command);
|
|
191
|
+
Add(_T("size"), &Size);
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
RunmemoryParamsData(const RunmemoryParamsData&) = delete;
|
|
195
|
+
RunmemoryParamsData(RunmemoryParamsData&&) noexcept = delete;
|
|
196
|
+
|
|
197
|
+
RunmemoryParamsData& operator=(const RunmemoryParamsData&) = delete;
|
|
198
|
+
RunmemoryParamsData& operator=(RunmemoryParamsData&&) noexcept = delete;
|
|
199
|
+
|
|
200
|
+
~RunmemoryParamsData() = default;
|
|
201
|
+
|
|
202
|
+
public:
|
|
203
|
+
bool IsDataValid() const
|
|
204
|
+
{
|
|
205
|
+
return (Command.IsSet() == true);
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
public:
|
|
209
|
+
Core::JSON::String Command; // Test command name
|
|
210
|
+
Core::JSON::DecUInt32 Size; // The amount of memory in KB for allocation (applicable for *Malloc* commands)
|
|
211
|
+
}; // class RunmemoryParamsData
|
|
212
|
+
|
|
213
|
+
class RunmemoryResultData : public Core::JSON::Container {
|
|
214
|
+
public:
|
|
215
|
+
RunmemoryResultData()
|
|
216
|
+
: Core::JSON::Container()
|
|
217
|
+
{
|
|
218
|
+
Add(_T("allocated"), &Allocated);
|
|
219
|
+
Add(_T("size"), &Size);
|
|
220
|
+
Add(_T("resident"), &Resident);
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
RunmemoryResultData(const RunmemoryResultData&) = delete;
|
|
224
|
+
RunmemoryResultData(RunmemoryResultData&&) noexcept = delete;
|
|
225
|
+
|
|
226
|
+
RunmemoryResultData& operator=(const RunmemoryResultData&) = delete;
|
|
227
|
+
RunmemoryResultData& operator=(RunmemoryResultData&&) noexcept = delete;
|
|
228
|
+
|
|
229
|
+
~RunmemoryResultData() = default;
|
|
230
|
+
|
|
231
|
+
public:
|
|
232
|
+
bool IsDataValid() const
|
|
233
|
+
{
|
|
234
|
+
return ((Allocated.IsSet() == true) && (Size.IsSet() == true) && (Resident.IsSet() == true));
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
public:
|
|
238
|
+
Core::JSON::DecUInt32 Allocated; // Already allocated memory in KB
|
|
239
|
+
Core::JSON::DecUInt32 Size; // Current allocation in KB
|
|
240
|
+
Core::JSON::DecUInt32 Resident; // Resident memory in KB
|
|
241
|
+
}; // class RunmemoryResultData
|
|
242
|
+
|
|
243
|
+
} // namespace TestUtility
|
|
244
|
+
|
|
245
|
+
POP_WARNING()
|
|
246
|
+
|
|
247
|
+
} // namespace JsonData
|
|
248
|
+
|
|
249
|
+
// Enum conversion handlers
|
|
250
|
+
ENUM_CONVERSION_HANDLER(JsonData::TestUtility::TypeType)
|
|
251
|
+
|
|
252
|
+
}
|
|
253
|
+
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
// C++ types for TestUtils API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
// Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
|
|
5
|
+
|
|
6
|
+
#pragma once
|
|
7
|
+
|
|
8
|
+
#include <core/JSON.h>
|
|
9
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
10
|
+
|
|
11
|
+
namespace Thunder {
|
|
12
|
+
|
|
13
|
+
namespace JsonData {
|
|
14
|
+
|
|
15
|
+
PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
|
|
16
|
+
|
|
17
|
+
namespace TestUtils {
|
|
18
|
+
|
|
19
|
+
// Method params/result classes
|
|
20
|
+
//
|
|
21
|
+
|
|
22
|
+
} // namespace TestUtils
|
|
23
|
+
|
|
24
|
+
POP_WARNING()
|
|
25
|
+
|
|
26
|
+
} // namespace JsonData
|
|
27
|
+
|
|
28
|
+
// Enum conversion handlers
|
|
29
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
30
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
31
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions)
|
|
32
|
+
ENUM_CONVERSION_HANDLER(QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions)
|
|
33
|
+
|
|
34
|
+
}
|
|
35
|
+
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for Benchmark API.
|
|
2
|
+
// Generated automatically from 'IBenchmark.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <qa_interfaces/IBenchmark.h>
|
|
8
|
+
#include "JsonData_Benchmark.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(QualityAssurance::IBenchmark::FailureReason)
|
|
13
|
+
{ QualityAssurance::IBenchmark::FailureReason::LATENCY_THRESHOLD_EXCEEDED, _TXT("LATENCY_THRESHOLD_EXCEEDED") },
|
|
14
|
+
{ QualityAssurance::IBenchmark::FailureReason::MEMORY_THRESHOLD_EXCEEDED, _TXT("MEMORY_THRESHOLD_EXCEEDED") },
|
|
15
|
+
{ QualityAssurance::IBenchmark::FailureReason::LATENCY_AND_MEMORY_THRESHOLD_EXCEEDED, _TXT("LATENCY_AND_MEMORY_THRESHOLD_EXCEEDED") },
|
|
16
|
+
ENUM_CONVERSION_END(QualityAssurance::IBenchmark::FailureReason)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for TestTextOptions API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
8
|
+
#include "JsonData_TestTextOptions.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
13
|
+
{ QualityAssurance::ITestTextOptions::EnumTextOptions::FIRST_OPTION, _TXT("FIRST_OPTION") },
|
|
14
|
+
{ QualityAssurance::ITestTextOptions::EnumTextOptions::SECOND_OPTION, _TXT("SECOND_OPTION") },
|
|
15
|
+
{ QualityAssurance::ITestTextOptions::EnumTextOptions::ThirdOption, _TXT("THIRD_OPTION") },
|
|
16
|
+
ENUM_CONVERSION_END(QualityAssurance::ITestTextOptions::EnumTextOptions)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for TestCustom API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
8
|
+
#include "JsonData_TestTextOptionsTestCustom.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions)
|
|
13
|
+
{ QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions::FIRST_OPTION, _TXT("first_option") },
|
|
14
|
+
{ QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions::SECOND_OPTION, _TXT("second_option") },
|
|
15
|
+
{ QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions::ThirdOption, _TXT("thirdoption") },
|
|
16
|
+
ENUM_CONVERSION_END(QualityAssurance::ITestTextOptions::ITestCustom::EnumTextOptions)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for TestKeep API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
8
|
+
#include "JsonData_TestTextOptionsTestKeep.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions)
|
|
13
|
+
{ QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions::FIRST_OPTION, _TXT("FIRST_OPTION") },
|
|
14
|
+
{ QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions::SECOND_OPTION, _TXT("SECOND_OPTION") },
|
|
15
|
+
{ QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions::ThirdOption, _TXT("ThirdOption") },
|
|
16
|
+
ENUM_CONVERSION_END(QualityAssurance::ITestTextOptions::ITestKeep::EnumTextOptions)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
// Enumeration code for TestLegacy API.
|
|
2
|
+
// Generated automatically from 'ITestAutomation.h'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include <qa_interfaces/ITestAutomation.h>
|
|
8
|
+
#include "JsonData_TestTextOptionsTestLegacy.h"
|
|
9
|
+
|
|
10
|
+
namespace Thunder {
|
|
11
|
+
|
|
12
|
+
ENUM_CONVERSION_BEGIN(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
13
|
+
{ QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions::FIRST_OPTION, _TXT("FirstOption") },
|
|
14
|
+
{ QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions::SECOND_OPTION, _TXT("SecondOption") },
|
|
15
|
+
{ QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions::ThirdOption, _TXT("ThirdOption") },
|
|
16
|
+
ENUM_CONVERSION_END(QualityAssurance::ITestTextOptions::ITestLegacy::EnumTextOptions)
|
|
17
|
+
|
|
18
|
+
}
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
// Enumeration code for Test Utility API.
|
|
2
|
+
// Generated automatically from 'TestUtility.json'.
|
|
3
|
+
|
|
4
|
+
#include <core/Enumerate.h>
|
|
5
|
+
|
|
6
|
+
#include "definitions.h"
|
|
7
|
+
#include "JsonData_TestUtility.h"
|
|
8
|
+
|
|
9
|
+
namespace Thunder {
|
|
10
|
+
|
|
11
|
+
ENUM_CONVERSION_BEGIN(JsonData::TestUtility::TypeType)
|
|
12
|
+
{ JsonData::TestUtility::TypeType::NUMBER, _TXT("Number") },
|
|
13
|
+
{ JsonData::TestUtility::TypeType::STRING, _TXT("String") },
|
|
14
|
+
{ JsonData::TestUtility::TypeType::BOOLEAN, _TXT("Boolean") },
|
|
15
|
+
{ JsonData::TestUtility::TypeType::OBJECT, _TXT("Object") },
|
|
16
|
+
{ JsonData::TestUtility::TypeType::SYMBOL, _TXT("Symbol") },
|
|
17
|
+
ENUM_CONVERSION_END(JsonData::TestUtility::TypeType)
|
|
18
|
+
|
|
19
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// IBenchmark API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Benchmark.h"
|
|
7
|
+
#include "JBenchmark.h"
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
// ITestAutomation API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_Memory.h"
|
|
7
|
+
#include "JsonData_ComRpc.h"
|
|
8
|
+
#include "JsonData_TestTextOptions.h"
|
|
9
|
+
#include "JsonData_TestTextOptionsTestLegacy.h"
|
|
10
|
+
#include "JsonData_TestTextOptionsTestKeep.h"
|
|
11
|
+
#include "JsonData_TestTextOptionsTestCustom.h"
|
|
12
|
+
#include "JsonData_TestUtils.h"
|
|
13
|
+
#include "JMemory.h"
|
|
14
|
+
#include "JComRpc.h"
|
|
15
|
+
#include "JTestTextOptions.h"
|
|
16
|
+
#include "JTestTextOptionsTestLegacy.h"
|
|
17
|
+
#include "JTestTextOptionsTestKeep.h"
|
|
18
|
+
#include "JTestTextOptionsTestCustom.h"
|
|
19
|
+
#include "JTestUtils.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// ITestPlugin API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_TestPlugin.h"
|
|
7
|
+
#include "JTestPlugin.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// TestController API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_TestController.h"
|
|
7
|
+
#include "JTestController.h"
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
// TestUtility API
|
|
2
|
+
// Generated automatically. DO NOT EDIT.
|
|
3
|
+
|
|
4
|
+
#pragma once
|
|
5
|
+
|
|
6
|
+
#include "JsonData_TestUtility.h"
|
|
7
|
+
#include "JTestUtility.h"
|