// // Copyright (c) 2019 Rally Tactical Systems, Inc. // All rights reserved. // /** \file ConfigurationObjects.h \brief Place to look for configuration helper */ /** * Detailed description of the ConfigurationObjects.h file * * This file contains all the configuration objects * * Copyright (c) 2019 Rally Tactical Systems, Inc. * All rights reserved. * */ #ifndef ConfigurationObjects_h #define ConfigurationObjects_h #include "Platform.h" #include "EngageConstants.h" #include #include #include #include #include #include #include #ifndef WIN32 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-function" #endif #if !defined(ENGAGE_IGNORE_COMPILER_UNUSED_WARNING) #if defined(__GNUC__) #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING __attribute__((unused)) #else #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING #endif #endif // ENGAGE_IGNORE_COMPILER_UNUSED_WARNING // We'll use a different namespace depending on whether we're building the RTS core code // or if this is being included in an app-land project. #if defined(RTS_CORE_BUILD) namespace ConfigurationObjects #else namespace AppConfigurationObjects #endif { static const char *ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT = "_attached"; //----------------------------------------------------------- #pragma pack(push, 1) typedef struct _DataSeriesHeader_t { /** @brief DataSeries Type. * Currently supported types * * Type | Value | Range | JSON Object Name | Detail * --- | --- | --- | --- | --- * Heart Rate | 1 | 0-255 | heartRate | Beats per minute * Skin Temperature | 2 | 0-255 | skinTemp | Celsius * Core Temperature | 3 | 0-255 | coreTemp | Celsius * Hydration Percentage | 4 | 0-100 | hydration | Percentage * Blood Oxygenation Percentage | 5 | 0-100 | bloodOxygenation | Percentage * Fatigue Level | 6 | 0-10 | fatigueLevel | 0 = low fatigue, 10 = maximum fatigue * Task Effectiveness Level | 7 | 0-10 | taskEffectiveness | 0 = minimal effectiveness, 10 = maximum effectiveness * */ uint8_t t; /** * @brief Timestamp representing the number of seconds elapsed since January 1, 1970 - based on traditional Unix time */ uint32_t ts; /** @brief Increment type. * Valid Types: * * Type | Value * ------------- | ------------- * 0 | Seconds * 1 | Milliseconds * 2 | Minutes * 3 | Hours * 4 | Days * */ uint8_t it; /** * @brief Increment multiplier. * The increment multiplier is an additional field that allows you apply a multiplier of 1-255 for time offset increments. * For example: let's assume that our data is being gathered at 20-millisecond intervals. We could certainly represent the * data as [0,37,60,38,20,42,140,36] where the time offset "3" becomes "60", "1" becomes "20", and "7" becomes "140". * * Valid range is 1 to 255 */ uint8_t im; /** * @brief Value type */ uint8_t vt; /** * @brief Series size (element count) */ uint8_t ss; } DataSeriesHeader_t; typedef struct _DataElementUint8_t { uint8_t ofs; uint8_t val; } DataElementUint8_t; typedef struct _DataElementUnint16_t { uint8_t ofs; uint16_t val; } DataElementUnint16_t; typedef struct _DataElementUnint32_t { uint8_t ofs; uint32_t val; } DataElementUnint32_t; typedef struct _DataElementUnint64_t { uint8_t ofs; uint64_t val; } DataElementUnint64_t; #pragma pack(pop) typedef enum { invalid = 0, uint8 = 1, uint16 = 2, uint32 = 3, uint64 = 4 } DataSeriesValueType_t; /** * @brief Human Biometric Types. * * TODO: More detailed HumanBiometricsTypes_t description. */ typedef enum { unknown = 0, heartRate = 1, skinTemp = 2, coreTemp = 3, hydration = 4, bloodOxygenation = 5, fatigueLevel = 6, taskEffectiveness = 7 } HumanBiometricsTypes_t; //----------------------------------------------------------- static FILE *_internalFileOpener(const char *fn, const char *mode) { FILE *fp = nullptr; #ifndef WIN32 fp = fopen(fn, mode); #else if(fopen_s(&fp, fn, mode) != 0) { fp = nullptr; } #endif return fp; } #define JSON_SERIALIZED_CLASS(_cn) \ class _cn; \ static void to_json(nlohmann::json& j, const _cn& p); \ static void from_json(const nlohmann::json& j, _cn& p); #define IMPLEMENT_JSON_DOCUMENTATION(_cn) \ public: \ static void document(const char *path = nullptr) \ { \ _cn example; \ example.initForDocumenting(); \ std::string theJson = example.serialize(3); \ std::cout << "------------------------------------------------" << std::endl \ << #_cn << std::endl \ << theJson << std::endl \ << "------------------------------------------------" << std::endl; \ \ if(path != nullptr && path[0] != 0) \ { \ std::string fn = path; \ fn.append("/"); \ fn.append(#_cn); \ fn.append(".json"); \ \ FILE *fp = _internalFileOpener(fn.c_str(), "wt");\ \ if(fp != nullptr) \ { \ fputs(theJson.c_str(), fp); \ fclose(fp); \ } \ else \ { \ std::cout << "ERROR: Cannot write to " << fn << std::endl; \ } \ } \ } \ static const char *className() \ { \ return #_cn; \ } #define IMPLEMENT_JSON_SERIALIZATION() \ public: \ bool deserialize(const char *s) \ { \ try \ { \ if(s != nullptr && s[0] != 0) \ { \ from_json(nlohmann::json::parse(s), *this); \ } \ else \ { \ return false; \ } \ } \ catch(...) \ { \ return false; \ } \ return true; \ } \ \ std::string serialize(const int indent = -1) \ { \ try \ { \ nlohmann::json j; \ to_json(j, *this); \ return j.dump(indent); \ } \ catch(...) \ { \ return std::string("{}"); \ } \ } #define IMPLEMENT_WRAPPED_JSON_SERIALIZATION(_cn) \ public: \ std::string serializeWrapped(const int indent = -1) \ { \ try \ { \ nlohmann::json j; \ to_json(j, *this); \ \ std::string rc; \ char firstChar[2]; \ firstChar[0] = #_cn[0]; \ firstChar[1] = 0; \ firstChar[0] = tolower(firstChar[0]); \ rc.assign("{\""); \ rc.append(firstChar); \ rc.append((#_cn) + 1); \ rc.append("\":"); \ rc.append(j.dump(indent)); \ rc.append("}"); \ \ return rc; \ } \ catch(...) \ { \ return std::string("{}"); \ } \ } #define TOJSON_IMPL(__var) \ {#__var, p.__var} #define FROMJSON_IMPL_SIMPLE(__var) \ getOptional(#__var, p.__var, j) #define FROMJSON_IMPL(__var, __type, __default) \ getOptional<__type>(#__var, p.__var, j, __default) #define TOJSON_BASE_IMPL() \ to_json(j, (ConfigurationObjectBase&)p) #define FROMJSON_BASE_IMPL() \ from_json(j, (ConfigurationObjectBase&)p); //----------------------------------------------------------- static std::string EMPTY_STRING; template static void getOptional(const char *name, T& v, const nlohmann::json& j, T def) { try { if(j.contains(name)) { j.at(name).get_to(v); } else { v = def; } } catch(...) { v = def; } } template static void getOptional(const char *name, T& v, const nlohmann::json& j) { try { if(j.contains(name)) { j.at(name).get_to(v); } } catch(...) { } } template static void getOptionalWithIndicator(const char *name, T& v, const nlohmann::json& j, T def, bool *wasFound) { try { if(j.contains(name)) { j.at(name).get_to(v); *wasFound = true; } else { v = def; *wasFound = false; } } catch(...) { v = def; *wasFound = false; } } template static void getOptionalWithIndicator(const char *name, T& v, const nlohmann::json& j, bool *wasFound) { try { if(j.contains(name)) { j.at(name).get_to(v); *wasFound = true; } else { *wasFound = false; } } catch(...) { *wasFound = false; } } class ConfigurationObjectBase { public: ConfigurationObjectBase() { _documenting = false; } virtual ~ConfigurationObjectBase() { } virtual void initForDocumenting() { _documenting = true; } virtual std::string toString() { return std::string(""); } inline virtual bool isDocumenting() const { return _documenting; } nlohmann::json _attached; protected: bool _documenting; }; static void to_json(nlohmann::json& j, const ConfigurationObjectBase& p) { try { if(p._attached != nullptr) { j[ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT] = p._attached; } } catch(...) { } } static void from_json(const nlohmann::json& j, ConfigurationObjectBase& p) { try { if(j.contains(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT)) { p._attached = j.at(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT); } } catch(...) { } } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(KvPair) /** * @brief Holds a key/value pair * * Helper C++ class to serialize and de-serialize KvPair JSON * */ class KvPair : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(KvPair) public: /** @brief Key */ std::string key; /** @brief Value */ std::string value; KvPair() { clear(); } void clear() { key.clear(); value.clear(); } }; static void to_json(nlohmann::json& j, const KvPair& p) { j = nlohmann::json{ TOJSON_IMPL(key), TOJSON_IMPL(value) }; } static void from_json(const nlohmann::json& j, KvPair& p) { p.clear(); getOptional("key", p.key, j, EMPTY_STRING); getOptional("tags", p.value, j, EMPTY_STRING); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TuningSettings) class TuningSettings : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TuningSettings) public: /** @brief [Optional, Default 0 (no max)] Maximum number of RTP bytes allowed to be pooled */ uint32_t maxPooledRtpMb; /** @brief [Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be pooled */ uint32_t maxPooledRtpObjects; /** @brief [Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be active */ uint32_t maxActiveRtpObjects; /** @brief [Optional, Default 0 (no max)] Maximum number of blob bytes allowed to be pooled */ uint32_t maxPooledBlobMb; /** @brief [Optional, Default 0 (no max)] Maximum number of blob objects allowed to be pooled */ uint32_t maxPooledBlobObjects; /** @brief [Optional, Default 0 (no max)] Maximum number of blob objects allowed to be active */ uint32_t maxActiveBlobObjects; /** @brief [Optional, Default 0 (no max)] Maximum number of buffer bytes allowed to be pooled */ uint32_t maxPooledBufferMb; /** @brief [Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be pooled */ uint32_t maxPooledBufferObjects; /** @brief [Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be active */ uint32_t maxActiveBufferObjects; /** @brief [Optional, Default 0 (no max)] Maximum number concurrent RTP processors */ uint32_t maxActiveRtpProcessors; TuningSettings() { clear(); } void clear() { maxPooledRtpMb = 0; maxPooledRtpObjects = 0; maxActiveRtpObjects = 0; maxPooledBlobMb = 0; maxPooledBlobObjects = 0; maxActiveBlobObjects = 0; maxPooledBufferMb = 0; maxPooledBufferObjects = 0; maxActiveBufferObjects = 0; maxActiveRtpProcessors = 0; } virtual void initForDocumenting() { clear(); } }; static void to_json(nlohmann::json& j, const TuningSettings& p) { j = nlohmann::json{ TOJSON_IMPL(maxPooledRtpMb), TOJSON_IMPL(maxPooledRtpObjects), TOJSON_IMPL(maxActiveRtpObjects), TOJSON_IMPL(maxPooledBlobMb), TOJSON_IMPL(maxPooledBlobObjects), TOJSON_IMPL(maxActiveBlobObjects), TOJSON_IMPL(maxPooledBufferMb), TOJSON_IMPL(maxPooledBufferObjects), TOJSON_IMPL(maxActiveBufferObjects), TOJSON_IMPL(maxActiveRtpProcessors) }; } static void from_json(const nlohmann::json& j, TuningSettings& p) { p.clear(); FROMJSON_IMPL(maxPooledRtpMb, uint32_t, 0); FROMJSON_IMPL(maxPooledRtpObjects, uint32_t, 0); FROMJSON_IMPL(maxActiveRtpObjects, uint32_t, 0); FROMJSON_IMPL(maxPooledBlobMb, uint32_t, 0); FROMJSON_IMPL(maxPooledBlobObjects, uint32_t, 0); FROMJSON_IMPL(maxActiveBlobObjects, uint32_t, 0); FROMJSON_IMPL(maxPooledBufferMb, uint32_t, 0); FROMJSON_IMPL(maxPooledBufferObjects, uint32_t, 0); FROMJSON_IMPL(maxActiveBufferObjects, uint32_t, 0); FROMJSON_IMPL(maxActiveRtpProcessors, uint32_t, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(FipsCryptoSettings) class FipsCryptoSettings : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(FipsCryptoSettings) public: /** @brief [Optional, Default false] If true, requires FIPS140-2 crypto operation. */ bool enabled; /** @brief Path where the crypto engine module is located */ std::string path; /** @brief [Optional, Default false] If true, requests the crypto engine module to run in debugging mode. */ bool debug; /** @brief [Optional] Specifies the NIST-approved curves to be used for FIPS */ std::string curves; /** @brief [Optional] Specifies the NIST-approved ciphers to be used for FIPS */ std::string ciphers; FipsCryptoSettings() { clear(); } void clear() { enabled = false; path.clear(); debug = false; curves.clear(); ciphers.clear(); } virtual void initForDocumenting() { clear(); } }; static void to_json(nlohmann::json& j, const FipsCryptoSettings& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(path), TOJSON_IMPL(debug), TOJSON_IMPL(curves), TOJSON_IMPL(ciphers) }; } static void from_json(const nlohmann::json& j, FipsCryptoSettings& p) { p.clear(); FROMJSON_IMPL_SIMPLE(enabled); FROMJSON_IMPL_SIMPLE(path); FROMJSON_IMPL_SIMPLE(debug); FROMJSON_IMPL_SIMPLE(curves); FROMJSON_IMPL_SIMPLE(ciphers); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(WatchdogSettings) class WatchdogSettings : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(WatchdogSettings) public: /** @brief [Optional, Default: true] Enables/disables a watchdog. */ bool enabled; /** @brief [Optional, Default: 5000] Interval at which checks are made. */ int intervalMs; /** @brief [Optional, Default: 2000] Number of milliseconds that must pass before a hang is assumed. */ int hangDetectionMs; /** @brief [Optional, Default: true] If true, aborts the process if a hang is detected. */ bool abortOnHang; /** @brief [Optional, Default: 100] Maximum number of milliseconds that a task may take before being considered slow. */ int slowExecutionThresholdMs; WatchdogSettings() { clear(); } void clear() { enabled = true; intervalMs = 5000; hangDetectionMs = 2000; abortOnHang = true; slowExecutionThresholdMs = 100; } virtual void initForDocumenting() { clear(); } }; static void to_json(nlohmann::json& j, const WatchdogSettings& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(intervalMs), TOJSON_IMPL(hangDetectionMs), TOJSON_IMPL(abortOnHang), TOJSON_IMPL(slowExecutionThresholdMs) }; } static void from_json(const nlohmann::json& j, WatchdogSettings& p) { p.clear(); getOptional("enabled", p.enabled, j, true); getOptional("intervalMs", p.intervalMs, j, 5000); getOptional("hangDetectionMs", p.hangDetectionMs, j, 2000); getOptional("abortOnHang", p.abortOnHang, j, true); getOptional("slowExecutionThresholdMs", p.slowExecutionThresholdMs, j, 100); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(FileRecordingRequest) class FileRecordingRequest : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(FileRecordingRequest) public: std::string id; std::string fileName; uint32_t maxMs; FileRecordingRequest() { clear(); } void clear() { id.clear(); fileName.clear(); maxMs = 60000; } virtual void initForDocumenting() { clear(); id = "1-2-3-4-5-6-7-8-9"; fileName = "/tmp/test.wav"; maxMs = 10000; } }; static void to_json(nlohmann::json& j, const FileRecordingRequest& p) { j = nlohmann::json{ TOJSON_IMPL(id), TOJSON_IMPL(fileName), TOJSON_IMPL(maxMs) }; } static void from_json(const nlohmann::json& j, FileRecordingRequest& p) { p.clear(); j.at("id").get_to(p.id); j.at("fileName").get_to(p.fileName); getOptional("maxMs", p.maxMs, j, 60000); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Feature) class Feature : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Feature) public: std::string id; std::string name; std::string description; std::string comments; int count; int used; // NOTE: Ignored during deserialization! Feature() { clear(); } void clear() { id.clear(); name.clear(); description.clear(); comments.clear(); count = 0; used = 0; } virtual void initForDocumenting() { clear(); id = "{af9540d1-3e86-4fa6-8b80-e26daecb61ab}"; name = "A sample feature"; description = "This is an example of a feature"; comments = "These are comments for this feature"; count = 42; used = 16; } }; static void to_json(nlohmann::json& j, const Feature& p) { j = nlohmann::json{ TOJSON_IMPL(id), TOJSON_IMPL(name), TOJSON_IMPL(description), TOJSON_IMPL(comments), TOJSON_IMPL(count), TOJSON_IMPL(used) }; } static void from_json(const nlohmann::json& j, Feature& p) { p.clear(); j.at("id").get_to(p.id); getOptional("name", p.name, j); getOptional("description", p.description, j); getOptional("comments", p.comments, j); getOptional("count", p.count, j, 0); // NOTE: Not deserialized! //getOptional("used", p.used, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Featureset) class Featureset : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Featureset) public: std::string signature; bool lockToDeviceId; std::vector features; Featureset() { clear(); } void clear() { signature.clear(); lockToDeviceId = false; features.clear(); } virtual void initForDocumenting() { clear(); signature = "c39df3f36c6444e686e47e70fc45cf91e6ed2d8de62d4a1e89f507d567ff48aaabb1a70e54b44377b46fc4a1a2e319e5b77e4abffc444db98f8eb55d709aad5f"; lockToDeviceId = false; } }; static void to_json(nlohmann::json& j, const Featureset& p) { j = nlohmann::json{ TOJSON_IMPL(signature), TOJSON_IMPL(lockToDeviceId), TOJSON_IMPL(features) }; } static void from_json(const nlohmann::json& j, Featureset& p) { p.clear(); getOptional("signature", p.signature, j); getOptional("lockToDeviceId", p.lockToDeviceId, j, false); getOptional>("features", p.features, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Agc) /** * @brief Agc * * Helper C++ class to serialize and de-serialize Agc JSON * * * Example: @include[doc] examples/Agc.json * */ class Agc : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Agc) public: /** @brief [Optional, Default: false] Enables automatic gain control. */ bool enabled; /** @brief [Optional, Default: 0] Minimum level. */ int minLevel; /** @brief [Optional, Default: 255] Maximum level. */ int maxLevel; /** @brief [Optional, Default: 25, Minimum = 0, Maximum = 125] Gain in db. */ int compressionGainDb; /** @brief [Optional, Default: false] Enables limiter to prevent overdrive. */ bool enableLimiter; /** @brief [Optional, Default: 9] Target gain level if there is no compression gain. */ int targetLevelDb; Agc() { clear(); } void clear() { enabled = false; minLevel = 0; maxLevel = 255; compressionGainDb = 25; enableLimiter = false; targetLevelDb = 3; } }; static void to_json(nlohmann::json& j, const Agc& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(minLevel), TOJSON_IMPL(maxLevel), TOJSON_IMPL(compressionGainDb), TOJSON_IMPL(enableLimiter), TOJSON_IMPL(targetLevelDb) }; } static void from_json(const nlohmann::json& j, Agc& p) { p.clear(); getOptional("enabled", p.enabled, j, false); getOptional("minLevel", p.minLevel, j, 0); getOptional("maxLevel", p.maxLevel, j, 255); getOptional("compressionGainDb", p.compressionGainDb, j, 25); getOptional("enableLimiter", p.enableLimiter, j, false); getOptional("targetLevelDb", p.targetLevelDb, j, 3); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(RtpPayloadTypeTranslation) /** * @brief RtpPayloadTypeTranslation * * Helper C++ class to serialize and de-serialize RtpPayloadTypeTranslation JSON * * * Example: @include[doc] examples/RtpPayloadTypeTranslation.json * */ class RtpPayloadTypeTranslation : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(RtpPayloadTypeTranslation) public: /** @brief The payload type used by the external entity */ uint16_t external; /** @brief The payload type used by Engage */ uint16_t engage; RtpPayloadTypeTranslation() { clear(); } void clear() { external = 0; engage = 0; } bool matches(const RtpPayloadTypeTranslation& other) { return ( (external == other.external) && (engage == other.engage) ); } }; static void to_json(nlohmann::json& j, const RtpPayloadTypeTranslation& p) { j = nlohmann::json{ TOJSON_IMPL(external), TOJSON_IMPL(engage) }; } static void from_json(const nlohmann::json& j, RtpPayloadTypeTranslation& p) { p.clear(); getOptional("external", p.external, j); getOptional("engage", p.engage, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkInterfaceDevice) class NetworkInterfaceDevice : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkInterfaceDevice) public: std::string name; std::string friendlyName; std::string description; int family; std::string address; bool available; bool isLoopback; bool supportsMulticast; std::string hardwareAddress; NetworkInterfaceDevice() { clear(); } void clear() { name.clear(); friendlyName.clear(); description.clear(); family = -1; address.clear(); available = false; isLoopback = false; supportsMulticast = false; hardwareAddress.clear(); } virtual void initForDocumenting() { clear(); name = "en0"; friendlyName = "Wi-Fi"; description = "A wi-fi adapter"; family = 1; address = "127.0.0.1"; available = true; isLoopback = true; supportsMulticast = false; hardwareAddress = "DE:AD:BE:EF:01:02:03"; } }; static void to_json(nlohmann::json& j, const NetworkInterfaceDevice& p) { j = nlohmann::json{ TOJSON_IMPL(name), TOJSON_IMPL(friendlyName), TOJSON_IMPL(description), TOJSON_IMPL(family), TOJSON_IMPL(address), TOJSON_IMPL(available), TOJSON_IMPL(isLoopback), TOJSON_IMPL(supportsMulticast), TOJSON_IMPL(hardwareAddress) }; } static void from_json(const nlohmann::json& j, NetworkInterfaceDevice& p) { p.clear(); getOptional("name", p.name, j); getOptional("friendlyName", p.friendlyName, j); getOptional("description", p.description, j); getOptional("family", p.family, j, -1); getOptional("address", p.address, j); getOptional("available", p.available, j, false); getOptional("isLoopback", p.isLoopback, j, false); getOptional("supportsMulticast", p.supportsMulticast, j, false); getOptional("hardwareAddress", p.hardwareAddress, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(ListOfNetworkInterfaceDevice) class ListOfNetworkInterfaceDevice : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(ListOfNetworkInterfaceDevice) public: std::vector list; ListOfNetworkInterfaceDevice() { clear(); } void clear() { list.clear(); } }; static void to_json(nlohmann::json& j, const ListOfNetworkInterfaceDevice& p) { j = nlohmann::json{ TOJSON_IMPL(list) }; } static void from_json(const nlohmann::json& j, ListOfNetworkInterfaceDevice& p) { p.clear(); getOptional>("list", p.list, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(RtpHeader) /** * @brief RTP header information as per RFC 3550. * * @see BlobInfo * * Example JSON: @include[lineno] examples/RtpHeader.json * */ class RtpHeader : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(RtpHeader) public: /** @brief A valid RTP payload between 0 and 127 See IANA Real-Time Transport Protocol (RTP) Parameters */ int pt; /** @brief Indicates whether this is the start of the media stream burst. */ bool marker; /** @brief Packet sequence number. */ uint16_t seq; /** @brief Psuedo-random synchronization source. */ uint32_t ssrc; /** @brief Media sample timestamp. */ uint32_t ts; RtpHeader() { clear(); } void clear() { pt = -1; marker = false; seq = 0; ssrc = 0; ts = 0; } virtual void initForDocumenting() { clear(); pt = 0; marker = false; seq = 123; ssrc = 12345678; ts = 87654321; } }; static void to_json(nlohmann::json& j, const RtpHeader& p) { if(p.pt != -1) { j = nlohmann::json{ TOJSON_IMPL(pt), TOJSON_IMPL(marker), TOJSON_IMPL(seq), TOJSON_IMPL(ssrc), TOJSON_IMPL(ts) }; } } static void from_json(const nlohmann::json& j, RtpHeader& p) { p.clear(); getOptional("pt", p.pt, j, -1); getOptional("marker", p.marker, j, false); getOptional("seq", p.seq, j, 0); getOptional("ssrc", p.ssrc, j, 0); getOptional("ts", p.ts, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Rfc4733Event) /** * @brief RFC4733 event information * * Example JSON: @include[lineno] examples/Rfc4733Event.json * */ class Rfc4733Event : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Rfc4733Event) public: /** @brief The event ID */ int id; /** @brief Indicates whether this is the end of the event. */ bool end; /** @brief Reserved */ int reserved; /** @brief Volume */ int volume; /** @brief Duration */ int duration; Rfc4733Event() { clear(); } void clear() { id = -1; end = false; reserved = 0; volume = 0; duration = 0; } virtual void initForDocumenting() { clear(); id = 0; end = false; reserved = 0; volume = 0; duration = 0; } }; static void to_json(nlohmann::json& j, const Rfc4733Event& p) { j = nlohmann::json{ TOJSON_IMPL(id), TOJSON_IMPL(end), TOJSON_IMPL(reserved), TOJSON_IMPL(volume), TOJSON_IMPL(duration) }; } static void from_json(const nlohmann::json& j, Rfc4733Event& p) { p.clear(); getOptional("id", p.id, j, -1); getOptional("end", p.end, j, false); getOptional("reserved", p.reserved, j, 0); getOptional("volume", p.volume, j, 0); getOptional("duration", p.duration, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(BlobInfo) /** @brief Describes the Blob data being sent used in the @ref engageSendGroupBlob API * * Helper C++ class to serialize and de-serialize BlobInfo JSON * * Example JSON: @include[lineno] examples/BlobInfo.json * * @see engageSendGroupBlob */ class BlobInfo : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(BlobInfo) public: /** @brief Payload type. * BlobInfo RTP supported Payload types. */ typedef enum { /** @brief Unknown type */ bptUndefined = 0, /** @brief Plain UTF 8 text. This is typically used to send plain text messages */ bptAppTextUtf8 = 1, /** @brief JSON UFT 8 text. This is used to send JSON formatted messages */ bptJsonTextUtf8 = 2, /** @brief Binary payload. Used to send binary data */ bptAppBinary = 3, /** @brief Biometrics payload. Used to send biometric series data. See WIKI post for more info */ bptEngageBinaryHumanBiometrics = 4, /** @brief The payload is MIME-encoded as per RFC 2045 */ bptAppMimeMessage = 5, /** @brief The payload is an array of RFC4733 events */ bptRfc4733Events = 6, /** @brief The payload is internal to Engage */ bptEngageInternal = 42 } PayloadType_t; /** @brief [Optional, Default : 0] Size of the payload */ size_t size; /** @brief [Optional, Default: empty string] The nodeId of Engage Engine that sent the message. If this is empty the Blob info will be anonymous. */ std::string source; /** @brief [Optional, Default: empty string] The nodeId to which this message is targeted. If this is empty, the Blob will targeted at all endpoints. */ std::string target; /** @brief [Optional, Default: @ref bptUndefined] The payload type to send in the blob @see PayloadType_t */ PayloadType_t payloadType; /** @brief Custom RTP header */ RtpHeader rtpHeader; /** @brief [Optional but required if txnTimeoutSecs is > 0]*/ std::string txnId; /** @brief [Optional, Default: 0] Number of seconds after which to time out delivery to the target node */ int txnTimeoutSecs; BlobInfo() { clear(); } void clear() { size = 0; source.clear(); target.clear(); rtpHeader.clear(); payloadType = PayloadType_t::bptUndefined; txnId.clear(); txnTimeoutSecs = 0; } virtual void initForDocumenting() { clear(); rtpHeader.initForDocumenting(); } }; static void to_json(nlohmann::json& j, const BlobInfo& p) { j = nlohmann::json{ TOJSON_IMPL(size), TOJSON_IMPL(source), TOJSON_IMPL(target), TOJSON_IMPL(rtpHeader), TOJSON_IMPL(payloadType), TOJSON_IMPL(txnId), TOJSON_IMPL(txnTimeoutSecs) }; } static void from_json(const nlohmann::json& j, BlobInfo& p) { p.clear(); getOptional("size", p.size, j, 0); getOptional("source", p.source, j, EMPTY_STRING); getOptional("target", p.target, j, EMPTY_STRING); getOptional("rtpHeader", p.rtpHeader, j); getOptional("payloadType", p.payloadType, j, BlobInfo::PayloadType_t::bptUndefined); getOptional("txnId", p.txnId, j, EMPTY_STRING); getOptional("txnTimeoutSecs", p.txnTimeoutSecs, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TxAudioUri) /** * @brief Optional audio streaming from a URI for @ref engageBeginGroupTxAdvanced * * Helper C++ class to serialize and de-serialize TxAudioUri JSON * * Example JSON: @include[lineno] examples/TxAudioUri.json * * TODO: Completed class properties * * @see engageBeginGroupTxAdvanced, txFlags */ class TxAudioUri : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TxAudioUri) public: /** @brief URI for the file */ std::string uri; /** @brief [Optional, Default: 0] Number of times to repeat */ int repeatCount; TxAudioUri() { clear(); } void clear() { uri.clear(); repeatCount = 0; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const TxAudioUri& p) { j = nlohmann::json{ TOJSON_IMPL(uri), TOJSON_IMPL(repeatCount) }; } static void from_json(const nlohmann::json& j, TxAudioUri& p) { p.clear(); getOptional("uri", p.uri, j, EMPTY_STRING); getOptional("repeatCount", p.repeatCount, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(AdvancedTxParams) /** * @brief Configuration when using the @ref engageBeginGroupTxAdvanced API * * Helper C++ class to serialize and de-serialize AdvancedTxParams JSON * * Example JSON: @include[lineno] examples/AdvancedTxParams.json * * TODO: Completed class properties * * @see engageBeginGroupTxAdvanced, txFlags */ class AdvancedTxParams : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(AdvancedTxParams) public: /** @brief [Optional, Default: 0] Combination of the ENGAGE_TXFLAG_xxx flags */ uint16_t flags; /** @brief [Optional, Default: 0] Transmit priority between 0 (lowest) and 255 (highest). */ uint8_t priority; /** @brief [Optional, Default: 0] Defines a sub channel within a group. Audio will be opaque to all other clients on the same group not on the same sub channel. */ uint16_t subchannelTag; /** @brief [Optional, Default: false] The Engage Engine should transmit the NodeId as part of the header extension in the RTP packet. */ bool includeNodeId; /** @brief [Optional, Default: empty string] The Engage Engine should transmit the user's alias as part of the header extension in the RTP packet. */ std::string alias; /** @brief [Optional, Default: false] While the microphone should be opened, captured audio should be ignored until unmuted. */ bool muted; /** @brief [Optional, Default: 0] Transmission ID */ uint32_t txId; /** @brief [Optional] A URI to stream from instead of the audio input device */ TxAudioUri audioUri; /** @brief [Optional, Default: 0] Defines a numeric affinity value to be included in the transmission. If defined, 3 bytes of the transmitted alias will be truncated. */ uint16_t aliasSpecializer; /** @brief [Optional, Default: false] Indicates that the aliasSpecializer must cause receivers to mute this transmission if they have an affinity for the specializer.. */ bool receiverRxMuteForAliasSpecializer; /** @brief [Optional, Default: false] Indicates that the transmission should be restarted. */ bool reBegin; AdvancedTxParams() { clear(); } void clear() { flags = 0; priority = 0; subchannelTag = 0; includeNodeId = false; alias.clear(); muted = false; txId = 0; audioUri.clear(); aliasSpecializer = 0; receiverRxMuteForAliasSpecializer = false; reBegin = false; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const AdvancedTxParams& p) { j = nlohmann::json{ TOJSON_IMPL(flags), TOJSON_IMPL(priority), TOJSON_IMPL(subchannelTag), TOJSON_IMPL(includeNodeId), TOJSON_IMPL(alias), TOJSON_IMPL(muted), TOJSON_IMPL(txId), TOJSON_IMPL(audioUri), TOJSON_IMPL(aliasSpecializer), TOJSON_IMPL(receiverRxMuteForAliasSpecializer), TOJSON_IMPL(reBegin) }; } static void from_json(const nlohmann::json& j, AdvancedTxParams& p) { p.clear(); getOptional("flags", p.flags, j, 0); getOptional("priority", p.priority, j, 0); getOptional("subchannelTag", p.subchannelTag, j, 0); getOptional("includeNodeId", p.includeNodeId, j, false); getOptional("alias", p.alias, j, EMPTY_STRING); getOptional("muted", p.muted, j, false); getOptional("txId", p.txId, j, 0); getOptional("audioUri", p.audioUri, j); getOptional("aliasSpecializer", p.aliasSpecializer, j, 0); getOptional("receiverRxMuteForAliasSpecializer", p.receiverRxMuteForAliasSpecializer, j, false); getOptional("reBegin", p.reBegin, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Identity) /** * @brief Users Identity * * Helper C++ class to serialize and de-serialize Identity JSON * * This configuration will be used by the Engine when transmitting presence data on behalf of the application. * * Example JSON: @include[lineno] examples/Identity.json * * @see engageInitialize, PresenceDescriptor */ class Identity : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Identity) public: /** * @brief [Optional, Default: Auto Generated] This is the Node ID to use to represent instance on the network. * * The application can generate and persist this Id or if an Id is not provided, the Engage Engine will generate a random Id and will be advertised in the PresenceDescriptor JSON with the self attribute set to true in the PFN_ENGAGE_GROUP_NODE_DISCOVERED event @see PresenceDescriptor. */ std::string nodeId; /** @brief [Optional, Default: empty string] The user ID to be used to represent the user. */ std::string userId; /** @brief [Optional, Default: empty string] The display name to be used for the user. */ std::string displayName; /** @brief [Optional, Default: empty string] This is a application defined field used to indicate a users avatar. The Engine doesn't not process this data and is a pass through. */ std::string avatar; Identity() { clear(); } void clear() { nodeId.clear(); userId.clear(); displayName.clear(); avatar.clear(); } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const Identity& p) { j = nlohmann::json{ TOJSON_IMPL(nodeId), TOJSON_IMPL(userId), TOJSON_IMPL(displayName), TOJSON_IMPL(avatar) }; } static void from_json(const nlohmann::json& j, Identity& p) { p.clear(); getOptional("nodeId", p.nodeId, j); getOptional("userId", p.userId, j); getOptional("displayName", p.displayName, j); getOptional("avatar", p.avatar, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Location) /** * @brief Location information used as part of the @ref PresenceDescriptor * * Helper C++ class to serialize and de-serialize Location JSON * * Location is presented by using the World Geodetic System (WGS84) * * Example JSON: @include[lineno] examples/Location.json * * @see PresenceDescriptor */ class Location : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Location) public: constexpr static double INVALID_LOCATION_VALUE = -999.999; /** @brief [Read Only: Unix timestamp - Zulu/UTC] Indicates the timestamp that the location was recorded. */ uint32_t ts; /** @brief Its the latitude position using the using the Signed degrees format (DDD.dddd). Valid range is -90 to 90. */ double latitude; /** @brief Its the longitudinal position using the Signed degrees format (DDD.dddd) format. Valid range is -180 to 180. */ double longitude; /** @brief [Optional, Default: INVALID_LOCATION_VALUE] The altitude above sea level in meters. */ double altitude; /** @brief [Optional, Default: INVALID_LOCATION_VALUE] Direction the endpoint is traveling in degrees. Valid range is 0 to 360 (NOTE: 0 and 360 are both the same heading). */ double direction; /** @brief [Optional, Default: INVALID_LOCATION_VALUE] The speed the endpoint is traveling at in meters per second. */ double speed; Location() { clear(); } void clear() { ts = 0; latitude = INVALID_LOCATION_VALUE; longitude = INVALID_LOCATION_VALUE; altitude = INVALID_LOCATION_VALUE; direction = INVALID_LOCATION_VALUE; speed = INVALID_LOCATION_VALUE; } virtual void initForDocumenting() { clear(); ts = 123456; latitude = 123.456; longitude = 456.789; altitude = 123; direction = 1; speed = 1234; } }; static void to_json(nlohmann::json& j, const Location& p) { if(p.latitude != Location::INVALID_LOCATION_VALUE && p.longitude != Location::INVALID_LOCATION_VALUE) { j = nlohmann::json{ TOJSON_IMPL(latitude), TOJSON_IMPL(longitude), }; if(p.ts != 0) j["ts"] = p.ts; if(p.altitude != Location::INVALID_LOCATION_VALUE) j["altitude"] = p.altitude; if(p.speed != Location::INVALID_LOCATION_VALUE) j["speed"] = p.speed; if(p.direction != Location::INVALID_LOCATION_VALUE) j["direction"] = p.direction; } } static void from_json(const nlohmann::json& j, Location& p) { p.clear(); getOptional("ts", p.ts, j, 0); j.at("latitude").get_to(p.latitude); j.at("longitude").get_to(p.longitude); getOptional("altitude", p.altitude, j, Location::INVALID_LOCATION_VALUE); getOptional("direction", p.direction, j, Location::INVALID_LOCATION_VALUE); getOptional("speed", p.speed, j, Location::INVALID_LOCATION_VALUE); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Power) /** * @brief Device Power Information used as part of the @ref PresenceDescriptor * * Helper C++ class to serialize and de-serialize Power JSON * * Example JSON: @include[lineno] examples/Power.json * * @see PresenceDescriptor */ class Power : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Power) public: /** @brief [Optional, Default: 0] Is the source the power is being delivered from * * Valid values are * * Value | Description * --- | --- * 0 | Undefined * 1 | Battery * 2 | Wired * */ int source; /** @brief [Optional, Default: 0] Is the current state that the power system is in. * * Valid values are * * Value | Description * --- | --- * 0 | Undefined * 1 | Charging * 2 | Discharging * 3 | Not Charging * 4 | Full */ int state; /** @brief [Optional, Default: 0] Is the current level of the battery or power system as a percentage. Valid range is 0 to 100. */ int level; Power() { clear(); } void clear() { source = 0; state = 0; level = 0; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const Power& p) { if(p.source != 0 && p.state != 0 && p.level != 0) { j = nlohmann::json{ TOJSON_IMPL(source), TOJSON_IMPL(state), TOJSON_IMPL(level) }; } } static void from_json(const nlohmann::json& j, Power& p) { p.clear(); getOptional("source", p.source, j, 0); getOptional("state", p.state, j, 0); getOptional("level", p.level, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Connectivity) /** * @brief Connectivity Information used as part of the @ref PresenceDescriptor * * Helper C++ class to serialize and de-serialize Connectivity JSON * * Example JSON: @include[lineno] examples/Connectivity.json * * @see PresenceDescriptor */ class Connectivity : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Connectivity) public: /** * @brief Is the type of connectivity the device has to the network * * Valid values are * * Value | Description * --- | --- * 0 | Undefined * 1 | Wired * 2 | Wireless WiFi * 3 | Wireless Cellular * */ int type; /** @brief Is the strength of the connection connection as reported by the OS - usually in dbm. */ int strength; /** @brief Is the quality of the network connection as reported by the OS - OS dependent. */ int rating; Connectivity() { clear(); } void clear() { type = 0; strength = 0; rating = 0; } virtual void initForDocumenting() { clear(); type = 1; strength = 2; rating = 3; } }; static void to_json(nlohmann::json& j, const Connectivity& p) { if(p.type != 0) { j = nlohmann::json{ TOJSON_IMPL(type), TOJSON_IMPL(strength), TOJSON_IMPL(rating) }; } } static void from_json(const nlohmann::json& j, Connectivity& p) { p.clear(); getOptional("type", p.type, j, 0); getOptional("strength", p.strength, j, 0); getOptional("rating", p.rating, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(PresenceDescriptorGroupItem) /** * @brief Group Alias used as part of the @ref PresenceDescriptor * * Helper C++ class to serialize and de-serialize PresenceDescriptorGroupItem JSON * * Example JSON: @include[lineno] examples/PresenceDescriptorGroupItem.json * * @see PresenceDescriptor */ class PresenceDescriptorGroupItem : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(PresenceDescriptorGroupItem) public: /** @brief Group Id the alias is associated with. */ std::string groupId; /** @brief User's alias for the group. */ std::string alias; /** @brief Status flags for the user's participation on the group */ uint16_t status; PresenceDescriptorGroupItem() { clear(); } void clear() { groupId.clear(); alias.clear(); status = 0; } virtual void initForDocumenting() { groupId = "{123-456}"; alias = "MYALIAS"; status = 0; } }; static void to_json(nlohmann::json& j, const PresenceDescriptorGroupItem& p) { j = nlohmann::json{ TOJSON_IMPL(groupId), TOJSON_IMPL(alias), TOJSON_IMPL(status) }; } static void from_json(const nlohmann::json& j, PresenceDescriptorGroupItem& p) { p.clear(); getOptional("groupId", p.groupId, j); getOptional("alias", p.alias, j); getOptional("status", p.status, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(PresenceDescriptor) /** * @brief Represents an endpoints presence properties. Used in @ref engageUpdatePresenceDescriptor API and PFN_ENGAGE_GROUP_NODE events. * * Helper C++ class to serialize and de-serialize PresenceDescriptor JSON * * Example: @include[doc] examples/PresenceDescriptor.json * * @see engageUpdatePresenceDescriptor, PFN_ENGAGE_GROUP_NODE_DISCOVERED, PFN_ENGAGE_GROUP_NODE_REDISCOVERED */ class PresenceDescriptor : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(PresenceDescriptor) public: /** * @brief [Read Only] Indicates that this presence declaration was generated by the Engage Engine the application currently connected to. * * NOTE: This is useful in identifying the nodeId that is automatically generated by the Engage Engine when the application does not provide the nodeId. */ bool self; /** * @brief [Read Only, Unix timestamp - Zulu/UTC] Indicates the timestamp that the message was originally sent. * * Use this property and the @ref nextUpdate attribute to determine if the endpoint is still on the network. */ uint32_t ts; /** * @brief [Read Only, Unix timestamp - Zulu/UTC] Indicates the next time the presence descriptor will be sent. * * This attributed together with the @ref ts attribute is used by the Engage Engage Engine to "timeout" the endpoint. (Unix timestamp - Zulu/UTC) */ uint32_t nextUpdate; /** @brief [Optional, Default see @ref Identity] Endpoint's identity information. */ Identity identity; /** @brief [Optional] No defined limit on size but the total size of the serialized JSON object must fit inside the current network transport's MTU. */ std::string comment; /** * @brief [Optional] Indicates the users disposition * * This may be any value set by the application. Such as: * * Value | Description * --- | --- * 0x00000000 | Undefined * 0x00000001 | Emergency * 0x00000002 | Available * 0x00000004 | Busy * etc | etc */ uint32_t disposition; /** @brief [Read Only] List of group items associated with this presence descriptor. */ std::vector groupAliases; /** @brief [Optional, Default: see @ref Location] Location information @see Location for more info. */ Location location; /** @brief [Optional, Default: empty string] Custom string application can use of presence descriptor. TODO: Whats the max length. */ std::string custom; /** @brief [Read Only] Indicates that the Engine will announce its PresenceDescriptor in response to this message. */ bool announceOnReceive; /** @brief [Optional, Default: see @ref Connectivity] Device connectivity information like wifi/cellular, strength etc. */ Connectivity connectivity; /** @brief [Optional, Default: see @ref Power] Device power information like charging state, battery level, etc. */ Power power; PresenceDescriptor() { clear(); } void clear() { self = false; ts = 0; nextUpdate = 0; identity.clear(); comment.clear(); disposition = 0; groupAliases.clear(); location.clear(); custom.clear(); announceOnReceive = false; connectivity.clear(); power.clear(); } virtual void initForDocumenting() { clear(); self = true; ts = 123; nextUpdate = 0; identity.initForDocumenting(); comment = "This is a comment"; disposition = 123; PresenceDescriptorGroupItem gi; gi.initForDocumenting(); groupAliases.push_back(gi); location.initForDocumenting(); custom = "{}"; announceOnReceive = true; connectivity.initForDocumenting(); power.initForDocumenting(); } }; static void to_json(nlohmann::json& j, const PresenceDescriptor& p) { j = nlohmann::json{ TOJSON_IMPL(ts), TOJSON_IMPL(nextUpdate), TOJSON_IMPL(identity), TOJSON_IMPL(comment), TOJSON_IMPL(disposition), TOJSON_IMPL(groupAliases), TOJSON_IMPL(location), TOJSON_IMPL(custom), TOJSON_IMPL(announceOnReceive), TOJSON_IMPL(connectivity), TOJSON_IMPL(power) }; if(!p.comment.empty()) j["comment"] = p.comment; if(!p.custom.empty()) j["custom"] = p.custom; if(p.self) { j["self"] = true; } } static void from_json(const nlohmann::json& j, PresenceDescriptor& p) { p.clear(); getOptional("self", p.self, j); getOptional("ts", p.ts, j); getOptional("nextUpdate", p.nextUpdate, j); getOptional("identity", p.identity, j); getOptional("comment", p.comment, j); getOptional("disposition", p.disposition, j); getOptional>("groupAliases", p.groupAliases, j); getOptional("location", p.location, j); getOptional("custom", p.custom, j); getOptional("announceOnReceive", p.announceOnReceive, j); getOptional("connectivity", p.connectivity, j); getOptional("power", p.power, j); } /** * @brief Network Transmission Priority. * * Priority to set on the packets in order for the network to optimize routing of the packets */ typedef enum { /** @brief best effort */ priBestEffort = 0, /** @brief signaling */ priSignaling = 1, /** @brief video */ priVideo = 2, /** @brief voice */ priVoice = 3 } TxPriority_t; /** * @brief Address family resolution policy * * Defines the policy on how to resolve/prefer IPv4 vs IPv6 names */ typedef enum { /** @brief IPv4 only */ arpIpv4Only = 4, /** @brief IPv6 only */ arpIpv6Only = 6, /** @brief IPv4 then IPv6 */ arpIpv4ThenIpv6 = 46, /** @brief IPv6 then IPv4 */ arpIpv6ThenIpv4 = 64 } AddressResolutionPolicy_t; //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkTxOptions) /** * @brief Network Transmit Options * * Helper C++ class to serialize and de-serialize NetworkTxOptions JSON * * TODO: Complete this Class * * Example: @include[doc] examples/NetworkTxOptions.json * * @see Group */ class NetworkTxOptions : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkTxOptions) public: /** @brief [Optional, Default: @ref priVoice] Transmission priority. This has meaning on some operating systems based on how their IP stack operates. It may or may not affect final packet marking. */ TxPriority_t priority; /** * @brief [Optional, Default: 1] Time to live or hop limit is a mechanism that limits the lifespan or lifetime of data in a network. TTL prevents a data packet from circulating indefinitely. * * E.g If you don't want multicast data to leave your local network, set the TTL to 1. */ int ttl; NetworkTxOptions() { clear(); } void clear() { priority = priVoice; ttl = 1; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const NetworkTxOptions& p) { j = nlohmann::json{ TOJSON_IMPL(priority), TOJSON_IMPL(ttl) }; } static void from_json(const nlohmann::json& j, NetworkTxOptions& p) { p.clear(); getOptional("priority", p.priority, j, TxPriority_t::priVoice); getOptional("ttl", p.ttl, j, 1); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TcpNetworkTxOptions) /** * @brief Network Transmit Options for TCP * * Helper C++ class to serialize and de-serialize TcpNetworkTxOptions JSON * * Example: @include[doc] examples/TcpNetworkTxOptions.json */ class TcpNetworkTxOptions : public NetworkTxOptions { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TcpNetworkTxOptions) public: TcpNetworkTxOptions() { clear(); } void clear() { priority = priVoice; ttl = -1; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const TcpNetworkTxOptions& p) { j = nlohmann::json{ TOJSON_IMPL(priority), TOJSON_IMPL(ttl) }; } static void from_json(const nlohmann::json& j, TcpNetworkTxOptions& p) { p.clear(); getOptional("priority", p.priority, j, TxPriority_t::priVoice); getOptional("ttl", p.ttl, j, -1); } typedef enum { /** @brief Unspecified */ ifIpUnspec = 0, /** @brief IPv4 */ ifIp4 = 4, /** @brief IPv6 */ ifIp6 = 6 } IpFamilyType_t; //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkAddress) /** * @brief NetworkAddress * * Helper C++ class to serialize and de-serialize NetworkAddress JSON * * TODO: Complete this Class * * Example: @include[doc] examples/NetworkAddress.json * */ class NetworkAddress : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkAddress) public: /** @brief IP address. */ std::string address; /** @brief Port. */ int port; NetworkAddress() { clear(); } void clear() { address.clear(); port = 0; } bool matches(const NetworkAddress& other) { if(address.compare(other.address) != 0) { return false; } if(port != other.port) { return false; } return true; } }; static void to_json(nlohmann::json& j, const NetworkAddress& p) { j = nlohmann::json{ TOJSON_IMPL(address), TOJSON_IMPL(port) }; } static void from_json(const nlohmann::json& j, NetworkAddress& p) { p.clear(); getOptional("address", p.address, j); getOptional("port", p.port, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkAddressRxTx) /** * @brief NetworkAddressRxTx * * Helper C++ class to serialize and de-serialize NetworkAddressRxTx JSON * * TODO: Complete this Class * * Example: @include[doc] examples/NetworkAddressRxTx.json * */ class NetworkAddressRxTx : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkAddressRxTx) public: /** @brief RX. */ NetworkAddress rx; /** @brief TX. */ NetworkAddress tx; NetworkAddressRxTx() { clear(); } void clear() { rx.clear(); tx.clear(); } }; static void to_json(nlohmann::json& j, const NetworkAddressRxTx& p) { j = nlohmann::json{ TOJSON_IMPL(rx), TOJSON_IMPL(tx) }; } static void from_json(const nlohmann::json& j, NetworkAddressRxTx& p) { p.clear(); getOptional("rx", p.rx, j); getOptional("tx", p.tx, j); } /** @brief Enum describing restriction types. */ typedef enum { /** @brief Registration for groups is allowed by default */ graptPermissive = 0, /** @brief Registration for groups is NOT allowed by default - requires definitive access through something like a whitelist*/ graptStrict = 1 } GroupRestrictionAccessPolicyType_t; static bool isValidGroupRestrictionAccessPolicyType(GroupRestrictionAccessPolicyType_t t) { return (t == GroupRestrictionAccessPolicyType_t::graptPermissive || t == GroupRestrictionAccessPolicyType_t::graptStrict ); } /** @brief Enum describing restriction types. */ typedef enum { /** @brief Undefined */ rtUndefined = 0, /** @brief Elements are whitelisted */ rtWhitelist = 1, /** @brief Elements are blacklisted */ rtBlacklist = 2 } RestrictionType_t; static bool isValidRestrictionType(RestrictionType_t t) { return (t == RestrictionType_t::rtUndefined || t == RestrictionType_t::rtWhitelist || t == RestrictionType_t::rtBlacklist ); } /** @brief Enum describing restriction element types. */ typedef enum { /** @brief A literal group ID */ retGroupId = 0, /** @brief Elements are group ID regex patterns */ retGroupIdPattern = 1, /** @brief Elements are generic access tags regex patterns */ retGenericAccessTagPattern = 2, /** @brief Elements are X.509 certificate serial number regex patterns */ retCertificateSerialNumberPattern = 3, /** @brief Elements are X.509 certificate fingerprint regex patterns */ retCertificateFingerprintPattern = 4, /** @brief Elements are X.509 certificate subject regex patterns */ retCertificateSubjectPattern = 5, /** @brief Elements are X.509 certificate issuer regex patterns */ retCertificateIssuerPattern = 6 } RestrictionElementType_t; static bool isValidRestrictionElementType(RestrictionElementType_t t) { return (t == RestrictionElementType_t::retGroupId || t == RestrictionElementType_t::retGroupIdPattern || t == RestrictionElementType_t::retGenericAccessTagPattern || t == RestrictionElementType_t::retCertificateSerialNumberPattern || t == RestrictionElementType_t::retCertificateFingerprintPattern || t == RestrictionElementType_t::retCertificateSubjectPattern || t == RestrictionElementType_t::retCertificateIssuerPattern); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkAddressRestrictionList) /** * @brief NetworkAddressRestrictionList * * Helper C++ class to serialize and de-serialize NetworkAddressRestrictionList JSON * * TODO: Complete this Class * * Example: @include[doc] examples/NetworkAddressRestrictionList.json * */ class NetworkAddressRestrictionList : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkAddressRestrictionList) public: /** @brief Type indicating how the elements are to be treated **/ RestrictionType_t type; /** @brief List of elements */ std::vector elements; NetworkAddressRestrictionList() { clear(); } void clear() { type = RestrictionType_t::rtUndefined; elements.clear(); } }; static void to_json(nlohmann::json& j, const NetworkAddressRestrictionList& p) { j = nlohmann::json{ TOJSON_IMPL(type), TOJSON_IMPL(elements) }; } static void from_json(const nlohmann::json& j, NetworkAddressRestrictionList& p) { p.clear(); getOptional("type", p.type, j, RestrictionType_t::rtUndefined); getOptional>("elements", p.elements, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(StringRestrictionList) /** * @brief StringRestrictionList * * Helper C++ class to serialize and de-serialize StringRestrictionList JSON * * TODO: Complete this Class * * Example: @include[doc] examples/StringRestrictionList.json * */ class StringRestrictionList : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(StringRestrictionList) public: /** @brief Type indicating how the elements are to be treated **/ RestrictionType_t type; /** @brief Type indicating what kind of data each element contains **/ RestrictionElementType_t elementsType; /** @brief List of elements */ std::vector elements; StringRestrictionList() { type = RestrictionType_t::rtUndefined; elementsType = RestrictionElementType_t::retGroupId; clear(); } void clear() { elements.clear(); } }; static void to_json(nlohmann::json& j, const StringRestrictionList& p) { j = nlohmann::json{ TOJSON_IMPL(type), TOJSON_IMPL(elementsType), TOJSON_IMPL(elements) }; } static void from_json(const nlohmann::json& j, StringRestrictionList& p) { p.clear(); getOptional("type", p.type, j, RestrictionType_t::rtUndefined); getOptional("elementsType", p.elementsType, j, RestrictionElementType_t::retGroupId); getOptional>("elements", p.elements, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(PacketCapturer) /** * @brief Description of a packet capturer * * Helper C++ class to serialize and de-serialize PacketCapturer JSON. * * Example: @include[doc] examples/PacketCapturer.json * */ class PacketCapturer : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(PacketCapturer) public: bool enabled; uint32_t maxMb; std::string filePrefix; PacketCapturer() { clear(); } void clear() { enabled = false; maxMb = 10; filePrefix.clear(); } }; static void to_json(nlohmann::json& j, const PacketCapturer& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(maxMb), TOJSON_IMPL(filePrefix) }; } static void from_json(const nlohmann::json& j, PacketCapturer& p) { p.clear(); getOptional("enabled", p.enabled, j, false); getOptional("maxMb", p.maxMb, j, 10); getOptional("filePrefix", p.filePrefix, j, EMPTY_STRING); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TransportImpairment) /** * @brief Description of a transport impairment * * Helper C++ class to serialize and de-serialize TransportImpairment JSON. * * Example: @include[doc] examples/TransportImpairment.json * */ class TransportImpairment : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TransportImpairment) public: int applicationPercentage; int jitterMs; int lossPercentage; /** @brief [Optional, Default: 0] When > 0, percentage of packets forced to error path. */ int errorPercentage; TransportImpairment() { clear(); } void clear() { applicationPercentage = 0; jitterMs = 0; lossPercentage = 0; errorPercentage = 0; } }; static void to_json(nlohmann::json& j, const TransportImpairment& p) { j = nlohmann::json{ TOJSON_IMPL(applicationPercentage), TOJSON_IMPL(jitterMs), TOJSON_IMPL(lossPercentage), TOJSON_IMPL(errorPercentage) }; } static void from_json(const nlohmann::json& j, TransportImpairment& p) { p.clear(); getOptional("applicationPercentage", p.applicationPercentage, j, 0); getOptional("jitterMs", p.jitterMs, j, 0); getOptional("lossPercentage", p.lossPercentage, j, 0); getOptional("errorPercentage", p.errorPercentage, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NsmNetworking) /** * @brief NsmNetworking * * Helper C++ class to serialize and de-serialize NsmNetworking JSON * * Multicast destination is under JSON key @c path as a @ref NetworkAddress (@c address, @c port). * @c priority is transmit priority (maps to DSCP / socket QoS; see \c Utils::setSocketTransmitPriority). * * Example: @include[doc] examples/NsmNetworking.json * */ class NsmNetworking : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NsmNetworking) public: std::string address; int port; int ttl; TxPriority_t priority; int txOversend; TransportImpairment rxImpairment; TransportImpairment txImpairment; std::string cryptoPassword; int maxUdpPayloadBytes; NsmNetworking() { clear(); } void clear() { address.clear(); port = 0; ttl = 1; priority = TxPriority_t::priVoice; txOversend = 0; rxImpairment.clear(); txImpairment.clear(); cryptoPassword.clear(); maxUdpPayloadBytes = 800; } }; static void to_json(nlohmann::json& j, const NsmNetworking& p) { nlohmann::json pathJson; to_json(pathJson, p.address); j = nlohmann::json{ TOJSON_IMPL(port), TOJSON_IMPL(ttl), TOJSON_IMPL(priority), TOJSON_IMPL(txOversend), TOJSON_IMPL(rxImpairment), TOJSON_IMPL(txImpairment), TOJSON_IMPL(cryptoPassword), TOJSON_IMPL(maxUdpPayloadBytes) }; } static void from_json(const nlohmann::json& j, NsmNetworking& p) { p.clear(); getOptional("address", p.address, j); getOptional("port", p.port, j, 8513); getOptional("ttl", p.ttl, j, 1); getOptional("priority", p.priority, j, TxPriority_t::priVoice); getOptional("txOversend", p.txOversend, j, 0); getOptional("rxImpairment", p.rxImpairment, j); getOptional("txImpairment", p.txImpairment, j); getOptional("cryptoPassword", p.cryptoPassword, j, EMPTY_STRING); getOptional("maxUdpPayloadBytes", p.maxUdpPayloadBytes, j, 800); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NsmNodeResource) /** * @brief One logical resource in the NSM state machine with its election priority (high byte of token). * * @see NsmConfiguration */ class NsmNodeResource : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NsmNodeResource) public: /** Resource id (UTF-8). RTNS v1 encodes length in bytes (max 255). */ std::string id; /** @brief [Optional, Default: -1] Priority byte for token MSB; -1 means use NsmNode.defaultPriority when loaded under an NsmNode. */ int priority; NsmNodeResource() { clear(); } void clear() { id.clear(); priority = -1; } }; static void to_json(nlohmann::json& j, const NsmNodeResource& p) { j = nlohmann::json{ TOJSON_IMPL(id), TOJSON_IMPL(priority) }; } static void from_json(const nlohmann::json& j, NsmNodeResource& p) { p.clear(); getOptional("id", p.id, j); getOptional("priority", p.priority, j, -1); } /** @brief Parse stateMachine.resources: array of objects {"id","priority"}. */ static void nsmConfigurationResourcesFromJson(const nlohmann::json& j, std::vector& out) { out.clear(); if (!j.contains("resources") || !j["resources"].is_array()) { return; } for (const auto& el : j["resources"]) { if (!el.is_object()) { continue; } NsmNodeResource nr; nr.clear(); getOptional("id", nr.id, el); getOptional("priority", nr.priority, el, -1); if (!nr.id.empty()) { out.push_back(nr); } } } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NsmConfiguration) /** * @brief NsmConfiguration * * Helper C++ class to serialize and de-serialize NsmConfiguration JSON * * Example: @include[doc] examples/NsmConfiguration.json * */ class NsmConfiguration : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NsmConfiguration) public: std::string id; bool favorUptime; NsmNetworking networking; std::vector resources; int tokenStart; int tokenEnd; int intervalSecs; int transitionSecsFactor; /** @brief [Optional, Default: 1] Scales TX interval and transition wait (testing / timing). */ int internalMultiplier; /** @brief [Optional, Default: 500] Random delay in ms before entering GOING_ACTIVE (spread elections). */ int goingActiveRandomDelayMs; bool logCommandOutput; NsmConfiguration() { clear(); } void clear() { id.clear(); favorUptime = false; networking.clear(); resources.clear(); tokenStart = 1000000; tokenEnd = 2000000; intervalSecs = 1; transitionSecsFactor = 3; internalMultiplier = 1; goingActiveRandomDelayMs = 500; logCommandOutput = false; } }; static void to_json(nlohmann::json& j, const NsmConfiguration& p) { j = nlohmann::json{ TOJSON_IMPL(id), TOJSON_IMPL(favorUptime), TOJSON_IMPL(networking), TOJSON_IMPL(resources), TOJSON_IMPL(tokenStart), TOJSON_IMPL(tokenEnd), TOJSON_IMPL(intervalSecs), TOJSON_IMPL(transitionSecsFactor), TOJSON_IMPL(internalMultiplier), TOJSON_IMPL(goingActiveRandomDelayMs), TOJSON_IMPL(logCommandOutput), }; } static void from_json(const nlohmann::json& j, NsmConfiguration& p) { p.clear(); getOptional("id", p.id, j); getOptional("favorUptime", p.favorUptime, j, false); getOptional("networking", p.networking, j); nsmConfigurationResourcesFromJson(j, p.resources); getOptional("tokenStart", p.tokenStart, j, 1000000); getOptional("tokenEnd", p.tokenEnd, j, 2000000); getOptional("intervalSecs", p.intervalSecs, j, 1); getOptional("transitionSecsFactor", p.transitionSecsFactor, j, 3); getOptional("internalMultiplier", p.internalMultiplier, j, 1); getOptional("goingActiveRandomDelayMs", p.goingActiveRandomDelayMs, j, 500); getOptional("logCommandOutput", p.logCommandOutput, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Rallypoint) /** * @brief Rallypoint * * Helper C++ class to serialize and de-serialize Rallypoint JSON * * Example: @include[doc] examples/Rallypoint.json */ class Rallypoint : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Rallypoint) public: /** * @brief RP protocol enum. * */ typedef enum { /** @brief [Default] TLS over TCP*/ rppTlsTcp = 0, /** @brief WebSocket over TLS */ rppTlsWs = 1, /** @brief Invalid */ rppInvalid = -1 } RpProtocol_t; /** * @brief This is the host address for the Engine to connect to the RallyPoint service. * */ NetworkAddress host; /** * @brief This is the X509 certificate to use for mutual authentication. * * The full contents of the cert can be specified or the file path to where the cert is located can be specified by using an @ replacement string e.g * * \code{.json} certificate="@/privatestore/certs/rp_cert.pem" * \endcode * * */ std::string certificate; /** * @brief This is the private key used to generate the X509 certificate. * * The full contents of the key can be specified or the file path to where the key is located can be specified by using an @ replacement string e.g * * \code{.json} certificate="@/privatestore/certs/rp_private_key.key" * \endcode * * */ std::string certificateKey; /** * @brief [Optional, Default true] Indicates whether the connection peer is to be verified by checking the validaity of its X.509 certificate. */ bool verifyPeer; /** * @brief [Optional, Default false] Allows the Rallypoint to accept self-signed certificates from the far-end */ bool allowSelfSignedCertificate; /** * @brief [Optional] A vector of certificates (raw content, file names, or certificate store elements) used to verify far-end X.509 certificates. */ std::vector caCertificates; /** * @brief [Optional, Default 10000] Number of milliseconds that a transaction may take before the link is considered broken. */ int transactionTimeoutMs; /** * @brief [Optional, Default false] Indicates whether to forego ECSDA signing of control-plane messages. */ bool disableMessageSigning; /** @brief [Optional, Default: 5] Connection timeout in seconds to the RP */ int connectionTimeoutSecs; /** @brief [Optional] Tx options for the TCP link */ TcpNetworkTxOptions tcpTxOptions; /** * @brief [Optional] A user-defined string sent as the Server Name Indication (SNI) field in * the TLS setup. Be aware that this data is sent in the clear in the client hello message. * */ std::string sni; /** @brief [Optional, Default: rppTlsTcp] Specifies the protocol to be used for the Rallypoint connection. See @ref RpProtocol_t for all protocol types */ RpProtocol_t protocol; /** @brief [Optional, Default: ""] Path to use for the RP connection (only used for WebSocket) */ std::string path; /** @brief [Optional, Default: ""] Additional protocols to use for the Rallypoint connection (only used for WebSocket) */ std::string additionalProtocols; Rallypoint() { clear(); } void clear() { host.clear(); certificate.clear(); certificateKey.clear(); caCertificates.clear(); verifyPeer = false; transactionTimeoutMs = 0; disableMessageSigning = false; connectionTimeoutSecs = 0; tcpTxOptions.clear(); sni.clear(); protocol = rppTlsTcp; path.clear(); additionalProtocols.clear(); } bool matches(const Rallypoint& other) { if(!host.matches(other.host)) { return false; } if(protocol != other.protocol) { return false; } if(path.compare(other.path) != 0) { return false; } if(certificate.compare(other.certificate) != 0) { return false; } if(certificateKey.compare(other.certificateKey) != 0) { return false; } if(verifyPeer != other.verifyPeer) { return false; } if(allowSelfSignedCertificate != other.allowSelfSignedCertificate) { return false; } if(caCertificates.size() != other.caCertificates.size()) { return false; } for(size_t x = 0; x < caCertificates.size(); x++) { bool found = false; for(size_t y = 0; y < other.caCertificates.size(); y++) { if(caCertificates[x].compare(other.caCertificates[y]) == 0) { found = true; break; } } if(!found) { return false; } } if(transactionTimeoutMs != other.transactionTimeoutMs) { return false; } if(disableMessageSigning != other.disableMessageSigning) { return false; } if(connectionTimeoutSecs != other.connectionTimeoutSecs) { return false; } if(tcpTxOptions.priority != other.tcpTxOptions.priority) { return false; } if(sni.compare(other.sni) != 0) { return false; } return true; } }; static void to_json(nlohmann::json& j, const Rallypoint& p) { j = nlohmann::json{ TOJSON_IMPL(host), TOJSON_IMPL(certificate), TOJSON_IMPL(certificateKey), TOJSON_IMPL(verifyPeer), TOJSON_IMPL(allowSelfSignedCertificate), TOJSON_IMPL(caCertificates), TOJSON_IMPL(transactionTimeoutMs), TOJSON_IMPL(disableMessageSigning), TOJSON_IMPL(connectionTimeoutSecs), TOJSON_IMPL(tcpTxOptions), TOJSON_IMPL(sni), TOJSON_IMPL(protocol), TOJSON_IMPL(path), TOJSON_IMPL(additionalProtocols) }; } static void from_json(const nlohmann::json& j, Rallypoint& p) { p.clear(); j.at("host").get_to(p.host); getOptional("certificate", p.certificate, j); getOptional("certificateKey", p.certificateKey, j); getOptional("verifyPeer", p.verifyPeer, j, true); getOptional("allowSelfSignedCertificate", p.allowSelfSignedCertificate, j, false); getOptional>("caCertificates", p.caCertificates, j); getOptional("transactionTimeoutMs", p.transactionTimeoutMs, j, 0); getOptional("disableMessageSigning", p.disableMessageSigning, j, false); getOptional("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0); getOptional("tcpTxOptions", p.tcpTxOptions, j); getOptional("sni", p.sni, j); getOptional("protocol", p.protocol, j, Rallypoint::RpProtocol_t::rppTlsTcp); getOptional("path", p.path, j); getOptional("additionalProtocols", p.additionalProtocols, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(RallypointCluster) /** * @brief RallypointCluster * * Helper C++ class to serialize and de-serialize RallypointCluster JSON * * TODO: Complete this Class * * Example: @include[doc] examples/RallypointCluster.json * */ class RallypointCluster : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(RallypointCluster) public: /** * @brief Connection strategy enum. * * More detailed ConnectionStrategy_t description. */ typedef enum { /** @brief Connect in round-robin fashion */ csRoundRobin = 0, /** @brief Fail back to high-order RP when available */ csFailback = 1 } ConnectionStrategy_t; /** @brief [Optional, Default: @ref csRoundRobin] Specifies the connection strategy to be followed. See @ref ConnectionStrategy_t for all strategy types */ ConnectionStrategy_t connectionStrategy; /** @brief List of Rallypoints */ std::vector rallypoints; /** @brief Seconds between switching to a new target */ int rolloverSecs; /** @brief [Optional, Default: 5] Default connection timeout in seconds to any RP in the cluster */ int connectionTimeoutSecs; /** @brief [Optional, Default: 10000] Default transaction time in milliseconds to any RP in the cluster */ int transactionTimeoutMs; RallypointCluster() { clear(); } void clear() { connectionStrategy = csRoundRobin; rallypoints.clear(); rolloverSecs = 10; connectionTimeoutSecs = 5; transactionTimeoutMs = 10000; } }; static void to_json(nlohmann::json& j, const RallypointCluster& p) { j = nlohmann::json{ TOJSON_IMPL(connectionStrategy), TOJSON_IMPL(rallypoints), TOJSON_IMPL(rolloverSecs), TOJSON_IMPL(connectionTimeoutSecs), TOJSON_IMPL(transactionTimeoutMs) }; } static void from_json(const nlohmann::json& j, RallypointCluster& p) { p.clear(); getOptional("connectionStrategy", p.connectionStrategy, RallypointCluster::ConnectionStrategy_t::csRoundRobin); getOptional>("rallypoints", p.rallypoints, j); getOptional("rolloverSecs", p.rolloverSecs, j, 10); getOptional("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5); getOptional("transactionTimeoutMs", p.transactionTimeoutMs, j, 10000); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(NetworkDeviceDescriptor) /** * @brief Custom Network Device Configuration * * Helper C++ class to serialize and de-serialize NetworkDeviceDescriptor JSON used in @ref engageNetworkDeviceRegister API. * * Example: @include[doc] examples/NetworkDeviceDescriptor.json * * @see engageNetworkDeviceRegister */ class NetworkDeviceDescriptor : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(NetworkDeviceDescriptor) public: /** * @brief [Read Only] Unique device identifier assigned by Engage Engine at time of device creation. * */ int deviceId; /** @brief Name of the device assigned by the platform */ std::string name; /** @brief Device manufacturer (if any) */ std::string manufacturer; /** @brief Device mode (if any) */ std::string model; /** @brief Device hardware ID (if any) */ std::string hardwareId; /** @brief Device serial number (if any) */ std::string serialNumber; /** @brief Device type (if any) */ std::string type; /** @brief Extra data provided by the platform (if any) */ std::string extra; NetworkDeviceDescriptor() { clear(); } void clear() { deviceId = 0; name.clear(); manufacturer.clear(); model.clear(); hardwareId.clear(); serialNumber.clear(); type.clear(); extra.clear(); } virtual std::string toString() { char buff[2048]; snprintf(buff, sizeof(buff), "deviceId=%d, name=%s, manufacturer=%s, model=%s, hardwareId=%s, serialNumber=%s, type=%s, extra=%s", deviceId, name.c_str(), manufacturer.c_str(), model.c_str(), hardwareId.c_str(), serialNumber.c_str(), type.c_str(), extra.c_str()); return std::string(buff); } }; static void to_json(nlohmann::json& j, const NetworkDeviceDescriptor& p) { j = nlohmann::json{ TOJSON_IMPL(deviceId), TOJSON_IMPL(name), TOJSON_IMPL(manufacturer), TOJSON_IMPL(model), TOJSON_IMPL(hardwareId), TOJSON_IMPL(serialNumber), TOJSON_IMPL(type), TOJSON_IMPL(extra) }; } static void from_json(const nlohmann::json& j, NetworkDeviceDescriptor& p) { p.clear(); getOptional("deviceId", p.deviceId, j, 0); getOptional("name", p.name, j); getOptional("manufacturer", p.manufacturer, j); getOptional("model", p.model, j); getOptional("hardwareId", p.hardwareId, j); getOptional("serialNumber", p.serialNumber, j); getOptional("type", p.type, j); getOptional("extra", p.extra, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(AudioGate) /** * @brief Description of an audio gate * * Helper C++ class to serialize and de-serialize AudioGate JSON. * * Example: @include[doc] examples/AudioGate.json * */ class AudioGate : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(AudioGate) public: /** @brief [Optional. Default: false] Enables the audio gate if true */ bool enabled; /** @brief [Optional. Default: false] Use voice activity detection rather than audio energy */ bool useVad; /** @brief [Optional. Default: 1500] Hang timer in milliseconds */ uint32_t hangMs; /** @brief [Optional. Default: 25] Number of 10ms history samples to gather before calculating the noise floor - ignored if useVad is true */ uint32_t windowMin; /** @brief [Optional. Default: 125] Maximum number of 10ms history samples - ignored if useVad is true */ uint32_t windowMax; /** @brief [Optional. Default: 1.75] Coefficient by which to multiply the current history average to determine the floor - ignored if useVad is true */ double coefficient; AudioGate() { clear(); } void clear() { enabled = false; useVad = false; hangMs = 1500; windowMin = 25; windowMax = 125; coefficient = 1.75; } }; static void to_json(nlohmann::json& j, const AudioGate& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(useVad), TOJSON_IMPL(hangMs), TOJSON_IMPL(windowMin), TOJSON_IMPL(windowMax), TOJSON_IMPL(coefficient) }; } static void from_json(const nlohmann::json& j, AudioGate& p) { p.clear(); getOptional("enabled", p.enabled, j, false); getOptional("useVad", p.useVad, j, false); getOptional("hangMs", p.hangMs, j, 1500); getOptional("windowMin", p.windowMin, j, 25); getOptional("windowMax", p.windowMax, j, 125); getOptional("coefficient", p.coefficient, j, 1.75); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TxAudio) /** * @brief Configuration for the audio transmit properties for a group * * Helper C++ class to serialize and de-serialize TxAudio JSON @see Group * * This JSON is used as an object in the Group definition JSON. * *

* Example: @include[doc] examples/TxAudio.json *

* */ class TxAudio : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TxAudio) public: /** * @brief Codec Types enum. * * More detailed TxCodec_t description. */ typedef enum { /** @brief Externally implemented */ ctExternal = -1, /** @brief Unknown Codec type */ ctUnknown = 0, /* G.711 */ /** @brief G711 U-Law 64 (kbit/s) See for more info */ ctG711ulaw = 1, /** @brief G711 A-Law 64 (kbit/s) See for more info */ ctG711alaw = 2, /* GSM */ /** @brief GSM Full Rate 13.2 (kbit/s) See for more info */ ctGsm610 = 3, /* G.729 */ /** @brief G.729a 8 (kbit/s) See for more info */ ctG729a = 4, /* PCM */ /** @brief PCM */ ctPcm = 5, // AMR Narrowband */ /** @brief AMR Narrowband 4.75 (kbit/s) See for more info */ ctAmrNb4750 = 10, /** @brief AMR Narrowband 5.15 (kbit/s) See for more info */ ctAmrNb5150 = 11, /** @brief AMR Narrowband 5.9 (kbit/s) See for more info */ ctAmrNb5900 = 12, /** @brief AMR Narrowband 6.7 (kbit/s) See for more info */ ctAmrNb6700 = 13, /** @brief AMR Narrowband 7.4 (kbit/s) See for more info */ ctAmrNb7400 = 14, /** @brief AMR Narrowband 7.95 (kbit/s) See for more info */ ctAmrNb7950 = 15, /** @brief AMR Narrowband 10.2 (kbit/s) See for more info */ ctAmrNb10200 = 16, /** @brief AMR Narrowband 12.2 (kbit/s) See for more info */ ctAmrNb12200 = 17, /* Opus */ /** @brief Opus 6 (kbit/s) See for more info */ ctOpus6000 = 20, /** @brief Opus 8 (kbit/s) See for more info */ ctOpus8000 = 21, /** @brief Opus 10 (kbit/s) See for more info */ ctOpus10000 = 22, /** @brief Opus 12 (kbit/s) See for more info */ ctOpus12000 = 23, /** @brief Opus 14 (kbit/s) See for more info */ ctOpus14000 = 24, /** @brief Opus 16 (kbit/s) See for more info */ ctOpus16000 = 25, /** @brief Opus 18 (kbit/s) See for more info */ ctOpus18000 = 26, /** @brief Opus 20 (kbit/s) See for more info */ ctOpus20000 = 27, /** @brief Opus 22 (kbit/s) See for more info */ ctOpus22000 = 28, /** @brief Opus 24 (kbit/s) See for more info */ ctOpus24000 = 29, /* Speex */ /** @brief Speex 2.15 (kbit/s) See for more info */ ctSpxNb2150 = 30, /** @brief Speex 3.95 (kbit/s) See for more info */ ctSpxNb3950 = 31, /** @brief Speex 5.95 (kbit/s) See for more info */ ctSpxNb5950 = 32, /** @brief Speex 8 (kbit/s) See for more info */ ctSpxNb8000 = 33, /** @brief Speex 11 (kbit/s) See for more info */ ctSpxNb11000 = 34, /** @brief Speex 15 (kbit/s) See for more info */ ctSpxNb15000 = 35, /** @brief Speex 18.2 (kbit/s) See for more info */ ctSpxNb18200 = 36, /** @brief Speex 24.6 (kbit/s) See for more info */ ctSpxNb24600 = 37, /* Codec2 */ /** @brief Codec2 0.45 (kbit/s) See for more info */ ctC2450 = 40, /** @brief Codec2 0.70 (kbit/s) See for more info */ ctC2700 = 41, /** @brief Codec2 1.2 (kbit/s) See for more info */ ctC21200 = 42, /** @brief Codec2 1.3 (kbit/s) See for more info */ ctC21300 = 43, /** @brief Codec2 1.4 (kbit/s) See for more info */ ctC21400 = 44, /** @brief Codec2 1.6 (kbit/s) See for more info */ ctC21600 = 45, /** @brief Codec2 2.4 (kbit/s) See for more info */ ctC22400 = 46, /** @brief Codec2 3.2 (kbit/s) See for more info */ ctC23200 = 47, /* MELPe */ /** @brief MELPe 0.60 (kbit/s) See for more info */ ctMelpe600 = 50, /** @brief MELPe 1.2 (kbit/s) See for more info */ ctMelpe1200 = 51, /** @brief MELPe 2.4 (kbit/s) See for more info */ ctMelpe2400 = 52, /* CVSD */ /** @brief CVSD (Continuous Variable Slope Delta Modulation) See for more info */ ctCvsd = 60 } TxCodec_t; /** * @brief Header extension types. * * More detailed HeaderExtensionType_t description. */ typedef enum { /** @brief Engage standard header extension type */ hetEngageStandard = 0, /** @brief NATO STANAG 5643 header extension type */ hetNatoStanga5643 = 1 } HeaderExtensionType_t; /** @brief [Optional, Default: true] Audio transmission is enabled */ bool enabled; /** @brief [Optional, Default: @ref ctOpus8000] Specifies the Codec Type to use for the transmission. See @ref TxCodec_t for all codec types */ TxCodec_t encoder; /** @brief [Optional] The name of the external codec - overrides encoder */ std::string encoderName; /** @brief [Optional, Default: 60] Audio sample framing size in milliseconds. */ int framingMs; /** @brief [Optional, Default: 0] If >0, derives framingMs based on the encoder's internal operation */ int blockCount; /** @brief [Optional, Default: false] Indicates if full duplex audio is supported. */ bool fdx; /** * @brief [Optional, Default: false] Set to true whether to disable header extensions. * * Indicates whether the Engine should not add a header extension on the RTP packet. If the header extension is omitted then any of the information such as Alias, NodeID and Tx * Priority will not be transmitted along with the audio. */ bool noHdrExt; /** @brief [Optional, Default: hetEngageStandard] The header extension type to use. See @ref HeaderExtensionType_t for all types */ HeaderExtensionType_t hdrExtType; /** * @brief [Optional, Default: 0] Maximum number of seconds the Engine will transmit for. * * When the time limit is exceeded, the Engine will fire a PFN_ENGAGE_GROUP_MAX_TX_TIME_EXCEEDED event. */ int maxTxSecs; /** * @brief [Optional, Default: 10] The number of packets when to periodically send the header extension. * * Eg, if its 3, then every third packed will contain the header extension. */ int extensionSendInterval; /** @brief [Optional, Default: 5] Number of headers to send at the beginning of a talk burst. */ int initialHeaderBurst; /** @brief [Optional, Default: 5] Number of headers to send at the conclusion of a talk burst. */ int trailingHeaderBurst; /** @brief [Optional, Default: 5] Number of start TX notifications to send when TX is about to begin. */ int startTxNotifications; /** @brief [Optional, Default: -1] The custom RTP payload type to use for transmission. A value of -1 causes the default * Engage-defined RTP payload type to be used for the selected CODEC. */ int customRtpPayloadType; /** @brief [INTERNAL] The Engine-assigned key for the codec */ uint32_t internalKey; /** @brief [Optional, Default: true] Resets RTP counters on each new transmission. */ bool resetRtpOnTx; /** @brief [Optional, Default: true] Smooth input audio */ bool enableSmoothing; /** @brief [Optional, Default: false] Support discontinuous transmission on those CODECs that allow it */ bool dtx; /** @brief [Optional, Default: 0] Hang timer for ongoing TX - only applicable if enableSmoothing is true */ int smoothedHangTimeMs; TxAudio() { clear(); } void clear() { enabled = true; encoder = TxAudio::TxCodec_t::ctUnknown; encoderName.clear(); framingMs = 60; blockCount = 0; fdx = false; noHdrExt = false; maxTxSecs = 0; extensionSendInterval = 10; initialHeaderBurst = 5; trailingHeaderBurst = 5; startTxNotifications = 5; customRtpPayloadType = -1; internalKey = 0; resetRtpOnTx = true; enableSmoothing = true; dtx = false; smoothedHangTimeMs = 0; hdrExtType = HeaderExtensionType_t::hetEngageStandard; } }; static void to_json(nlohmann::json& j, const TxAudio& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(encoder), TOJSON_IMPL(encoderName), TOJSON_IMPL(framingMs), TOJSON_IMPL(blockCount), TOJSON_IMPL(fdx), TOJSON_IMPL(noHdrExt), TOJSON_IMPL(maxTxSecs), TOJSON_IMPL(extensionSendInterval), TOJSON_IMPL(initialHeaderBurst), TOJSON_IMPL(trailingHeaderBurst), TOJSON_IMPL(startTxNotifications), TOJSON_IMPL(customRtpPayloadType), TOJSON_IMPL(resetRtpOnTx), TOJSON_IMPL(enableSmoothing), TOJSON_IMPL(dtx), TOJSON_IMPL(smoothedHangTimeMs), TOJSON_IMPL(hdrExtType) }; // internalKey is not serialized } static void from_json(const nlohmann::json& j, TxAudio& p) { p.clear(); getOptional("enabled", p.enabled, j, true); getOptional("encoder", p.encoder, j, TxAudio::TxCodec_t::ctOpus8000); getOptional("encoderName", p.encoderName, j, EMPTY_STRING); getOptional("framingMs", p.framingMs, j, 60); getOptional("blockCount", p.blockCount, j, 0); getOptional("fdx", p.fdx, j, false); getOptional("noHdrExt", p.noHdrExt, j, false); getOptional("maxTxSecs", p.maxTxSecs, j, 0); getOptional("extensionSendInterval", p.extensionSendInterval, j, 10); getOptional("initialHeaderBurst", p.initialHeaderBurst, j, 5); getOptional("trailingHeaderBurst", p.trailingHeaderBurst, j, 5); getOptional("startTxNotifications", p.startTxNotifications, j, 5); getOptional("customRtpPayloadType", p.customRtpPayloadType, j, -1); getOptional("resetRtpOnTx", p.resetRtpOnTx, j, true); getOptional("enableSmoothing", p.enableSmoothing, j, true); getOptional("dtx", p.dtx, j, false); getOptional("smoothedHangTimeMs", p.smoothedHangTimeMs, j, 0); getOptional("hdrExtType", p.hdrExtType, j, TxAudio::HeaderExtensionType_t::hetEngageStandard); // internalKey is not serialized } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(AudioRegistryDevice) /** * @brief Describes an audio device that is available on the system * * Helper C++ class to serialize and de-serialize AudioRegistryDevice * * Example: @include[doc] examples/AudioRegistryDevice.json * * @see AudioRegistryDevice */ class AudioRegistryDevice : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(AudioRegistryDevice) public: /** @brief The string identifier used to identify the hardware. */ std::string hardwareId; /** @brief True if this is the default device */ bool isDefault; /** @brief Name of the device */ std::string name; /** @brief [Optional] Manufacturer */ std::string manufacturer; /** @brief [Optional] Model */ std::string model; /** @brief [Optional] Serial number */ std::string serialNumber; /** @brief [Optional] Type */ std::string type; /** @brief [Optional] Extra */ std::string extra; AudioRegistryDevice() { clear(); } void clear() { hardwareId.clear(); isDefault = false; name.clear(); manufacturer.clear(); model.clear(); serialNumber.clear(); type.clear(); extra.clear(); } virtual std::string toString() { char buff[2048]; snprintf(buff, sizeof(buff), "hardwareId=%s, isDefault=%d, name=%s, manufacturer=%s, model=%s, serialNumber=%s, type=%s, extra=%s", hardwareId.c_str(), (int)isDefault, name.c_str(), manufacturer.c_str(), model.c_str(), serialNumber.c_str(), type.c_str(), extra.c_str()); return std::string(buff); } }; static void to_json(nlohmann::json& j, const AudioRegistryDevice& p) { j = nlohmann::json{ TOJSON_IMPL(hardwareId), TOJSON_IMPL(isDefault), TOJSON_IMPL(name), TOJSON_IMPL(manufacturer), TOJSON_IMPL(model), TOJSON_IMPL(serialNumber), TOJSON_IMPL(type), TOJSON_IMPL(extra) }; } static void from_json(const nlohmann::json& j, AudioRegistryDevice& p) { p.clear(); getOptional("hardwareId", p.hardwareId, j, EMPTY_STRING); getOptional("isDefault", p.isDefault, j, false); getOptional("name", p.name, j); getOptional("manufacturer", p.manufacturer, j); getOptional("model", p.model, j); getOptional("serialNumber", p.serialNumber, j); getOptional("type", p.type, j); getOptional("extra", p.extra, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(AudioRegistry) /** * @brief Describes an audio registry * * Helper C++ class to serialize and de-serialize AudioRegistry * * Example: @include[doc] examples/AudioRegistry.json * * @see AudioRegistry */ class AudioRegistry : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(AudioRegistry) public: /** @brief [Optional] List of input devices to use for the registry. */ std::vector inputs; /** @brief [Optional] List of output devices to use for the registry. */ std::vector outputs; AudioRegistry() { clear(); } void clear() { inputs.clear(); outputs.clear(); } virtual std::string toString() { return std::string(""); } }; static void to_json(nlohmann::json& j, const AudioRegistry& p) { j = nlohmann::json{ TOJSON_IMPL(inputs), TOJSON_IMPL(outputs) }; } static void from_json(const nlohmann::json& j, AudioRegistry& p) { p.clear(); getOptional>("inputs", p.inputs, j); getOptional>("outputs", p.outputs, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(AudioDeviceDescriptor) /** * @brief Custom Audio Device Configuration * * Helper C++ class to serialize and de-serialize AudioDeviceDescriptor JSON used in @ref engageAudioDeviceRegister API. * * Example: @include[doc] examples/AudioDeviceDescriptor.json * * @see engageAudioDeviceRegister */ class AudioDeviceDescriptor : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(AudioDeviceDescriptor) public: /** @brief Audio Device Direction Enum. */ typedef enum { /** @brief Direction unknown */ dirUnknown = 0, /** @brief This is an input only device */ dirInput, /** @brief This is an output only device */ dirOutput, /** @brief This device supports both input and output */ dirBoth } Direction_t; /** * @brief [Read Only] Unique device identifier assigned by Engage Engine at time of device creation. * */ int deviceId; /** * @brief This is the rate that the device will process the PCM audio data at. * * Valid values are 8000 and 16000. * */ int samplingRate; /** * @brief Indicates the number of audio channels to process. * * Valid values are 1 (mono) and 2 (stereo). * */ int channels; /** @brief Audio direction the device supports @see Direction_t */ Direction_t direction; /** * @brief A percentage at which to gain/attenuate the audio. * * Values above 100% will gain the level, values below will attenuate. * */ int boostPercentage; /** @brief True if the device is an Application-Defined Audio Device */ bool isAdad; /** @brief Name of the device assigned by the platform */ std::string name; /** @brief Device manufacturer (if any) */ std::string manufacturer; /** @brief Device mode (if any) */ std::string model; /** @brief Device hardware ID (if any) */ std::string hardwareId; /** @brief Device serial number (if any) */ std::string serialNumber; /** @brief True if this is the default device for the direction above */ bool isDefault; /** @brief Device type (if any) */ std::string type; /** @brief Extra data provided by the platform (if any) */ std::string extra; /** @brief True if the device is currently present on the system */ bool isPresent; AudioDeviceDescriptor() { clear(); } void clear() { deviceId = 0; samplingRate = 0; channels = 0; direction = dirUnknown; boostPercentage = 0; isAdad = false; isDefault = false; name.clear(); manufacturer.clear(); model.clear(); hardwareId.clear(); serialNumber.clear(); type.clear(); extra.clear(); isPresent = false; } virtual std::string toString() { char buff[2048]; snprintf(buff, sizeof(buff), "deviceId=%d, samplingRate=%d, channels=%d, direction=%d, boostPercentage=%d, isAdad=%d, name=%s, manufacturer=%s, model=%s, hardwareId=%s, serialNumber=%s, isDefault=%d, type=%s, present=%d, extra=%s", deviceId, samplingRate, channels, (int)direction, boostPercentage, (int)isAdad, name.c_str(), manufacturer.c_str(), model.c_str(), hardwareId.c_str(), serialNumber.c_str(), (int)isDefault, type.c_str(), (int)isPresent, extra.c_str()); return std::string(buff); } }; static void to_json(nlohmann::json& j, const AudioDeviceDescriptor& p) { j = nlohmann::json{ TOJSON_IMPL(deviceId), TOJSON_IMPL(samplingRate), TOJSON_IMPL(channels), TOJSON_IMPL(direction), TOJSON_IMPL(boostPercentage), TOJSON_IMPL(isAdad), TOJSON_IMPL(name), TOJSON_IMPL(manufacturer), TOJSON_IMPL(model), TOJSON_IMPL(hardwareId), TOJSON_IMPL(serialNumber), TOJSON_IMPL(isDefault), TOJSON_IMPL(type), TOJSON_IMPL(extra), TOJSON_IMPL(isPresent) }; } static void from_json(const nlohmann::json& j, AudioDeviceDescriptor& p) { p.clear(); getOptional("deviceId", p.deviceId, j, 0); getOptional("samplingRate", p.samplingRate, j, 0); getOptional("channels", p.channels, j, 0); getOptional("direction", p.direction, j, AudioDeviceDescriptor::Direction_t::dirUnknown); getOptional("boostPercentage", p.boostPercentage, j, 0); getOptional("isAdad", p.isAdad, j, false); getOptional("name", p.name, j); getOptional("manufacturer", p.manufacturer, j); getOptional("model", p.model, j); getOptional("hardwareId", p.hardwareId, j); getOptional("serialNumber", p.serialNumber, j); getOptional("isDefault", p.isDefault, j); getOptional("type", p.type, j); getOptional("extra", p.extra, j); getOptional("isPresent", p.isPresent, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(ListOfAudioDeviceDescriptor) class ListOfAudioDeviceDescriptor : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(ListOfAudioDeviceDescriptor) public: std::vector list; ListOfAudioDeviceDescriptor() { clear(); } void clear() { list.clear(); } }; static void to_json(nlohmann::json& j, const ListOfAudioDeviceDescriptor& p) { j = nlohmann::json{ TOJSON_IMPL(list) }; } static void from_json(const nlohmann::json& j, ListOfAudioDeviceDescriptor& p) { p.clear(); getOptional>("list", p.list, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Audio) /** * @brief Used to configure the Audio properties for a group @see Group * * Helper C++ class to serialize and de-serialize Audio JSON * * Example: @include[doc] examples/Audio.json */ class Audio : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Audio) public: /** @brief [Optional, Default: true] Audio is enabled */ bool enabled; /** @brief [Optional, Default: first audio device] Id for the input audio device to use for this group. */ int inputId; /** @brief [Optional] Hardware ID of the input audio device to use for this group. If empty, inputId is used. */ std::string inputHardwareId; /** @brief [Optional, Default: 0] The percentage at which to gain the input audio. */ int inputGain; /** @brief [Optional, Default: first audio device] Id for the output audio device to use for this group. */ int outputId; /** @brief [Optional] Hardware ID of the output audio device to use for this group. If empty, outputId is used. */ std::string outputHardwareId; /** @brief [Optional, Default: 0] The percentage at which to gain the output audio. */ int outputGain; /** @brief [Optional, Default: 100] The percentage at which to set the left audio at. */ int outputLevelLeft; /** @brief [Optional, Default: 100] The percentage at which to set the right audio at. */ int outputLevelRight; /** @brief [Optional, Default: false] Mutes output audio. */ bool outputMuted; Audio() { clear(); } void clear() { enabled = true; inputId = 0; inputHardwareId.clear(); inputGain = 0; outputId = 0; outputHardwareId.clear(); outputGain = 0; outputLevelLeft = 100; outputLevelRight = 100; outputMuted = false; } }; static void to_json(nlohmann::json& j, const Audio& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(inputId), TOJSON_IMPL(inputHardwareId), TOJSON_IMPL(inputGain), TOJSON_IMPL(outputId), TOJSON_IMPL(outputHardwareId), TOJSON_IMPL(outputLevelLeft), TOJSON_IMPL(outputLevelRight), TOJSON_IMPL(outputMuted) }; } static void from_json(const nlohmann::json& j, Audio& p) { p.clear(); getOptional("enabled", p.enabled, j, true); getOptional("inputId", p.inputId, j, 0); getOptional("inputHardwareId", p.inputHardwareId, j, EMPTY_STRING); getOptional("inputGain", p.inputGain, j, 0); getOptional("outputId", p.outputId, j, 0); getOptional("outputHardwareId", p.outputHardwareId, j, EMPTY_STRING); getOptional("outputGain", p.outputGain, j, 0); getOptional("outputLevelLeft", p.outputLevelLeft, j, 100); getOptional("outputLevelRight", p.outputLevelRight, j, 100); getOptional("outputMuted", p.outputMuted, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(TalkerInformation) /** * @brief Contains talker information used in providing a list in GroupTalkers * * Helper C++ class to serialize and de-serialize TalkerInformation JSON * * Example: @include[doc] examples/TalkerInformation.json * * @see GroupTalkers */ class TalkerInformation : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(TalkerInformation) public: /** @brief Manufactured alias type * If an alias is "manufactured" then the alias is not a real user but is instead a system-generated alias. */ typedef enum { /** @brief Not manufactured */ matNone = 0, /** @brief The anonymous alias specified in the group configuration was used */ matAnonymous = 1, /** @brief The alias was manufactured using the RTP stream's SSRC value in hex - in the format "SSRCxxxxxxxx" */ matSsrcGenerated = 2 } ManufacturedAliasType_t; /** @brief The user alias to represent as a "talker". */ std::string alias; /** @brief The nodeId the talker is originating from. */ std::string nodeId; /** @brief Flags associated with a talker's transmission. */ uint16_t rxFlags; /** @brief Priority associated with a talker's transmission. */ int txPriority; /** @brief Transmission ID associated with a talker's transmission. */ uint32_t txId; /** @brief Number of duplicates detected. */ int duplicateCount; /** @brief The numeric specializer (if any) associated with the alias. */ uint16_t aliasSpecializer; /** @brief Indicates if RX is muted for this talker. */ bool rxMuted; /** @brief The RTS SSRC associated with a talker's transmission. */ uint32_t ssrc; /** @brief The method used to "manufacture" the alias */ ManufacturedAliasType_t manufacturedAliasType; TalkerInformation() { clear(); } void clear() { alias.clear(); nodeId.clear(); rxFlags = 0; txPriority = 0; txId = 0; duplicateCount = 0; aliasSpecializer = 0; rxMuted = false; manufacturedAliasType = ManufacturedAliasType_t::matNone; ssrc = 0; } }; static void to_json(nlohmann::json& j, const TalkerInformation& p) { j = nlohmann::json{ TOJSON_IMPL(alias), TOJSON_IMPL(nodeId), TOJSON_IMPL(rxFlags), TOJSON_IMPL(txPriority), TOJSON_IMPL(txId), TOJSON_IMPL(duplicateCount), TOJSON_IMPL(aliasSpecializer), TOJSON_IMPL(rxMuted), TOJSON_IMPL(manufacturedAliasType), TOJSON_IMPL(ssrc) }; } static void from_json(const nlohmann::json& j, TalkerInformation& p) { p.clear(); getOptional("alias", p.alias, j, EMPTY_STRING); getOptional("nodeId", p.nodeId, j, EMPTY_STRING); getOptional("rxFlags", p.rxFlags, j, 0); getOptional("txPriority", p.txPriority, j, 0); getOptional("txId", p.txId, j, 0); getOptional("duplicateCount", p.duplicateCount, j, 0); getOptional("aliasSpecializer", p.aliasSpecializer, j, 0); getOptional("rxMuted", p.rxMuted, j, false); getOptional("manufacturedAliasType", p.manufacturedAliasType, j, TalkerInformation::ManufacturedAliasType_t::matNone); getOptional("ssrc", p.ssrc, j, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupTalkers) /** * @brief List of @ref TalkerInformation objects. * * Helper C++ class to serialize and de-serialize GroupTalkers JSON * * This is used as the groupTalkerJson parameter in the PFN_ENGAGE_GROUP_RX_SPEAKERS_CHANGED event to represent a list of active talkers on the group. * * Example: @include[doc] examples/GroupTalkers.json * * @see PFN_ENGAGE_GROUP_RX_SPEAKERS_CHANGED */ class GroupTalkers : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupTalkers) public: /** @brief List of @ref TalkerInformation objects.*/ std::vector list; GroupTalkers() { clear(); } void clear() { list.clear(); } }; static void to_json(nlohmann::json& j, const GroupTalkers& p) { j = nlohmann::json{ TOJSON_IMPL(list) }; } static void from_json(const nlohmann::json& j, GroupTalkers& p) { p.clear(); getOptional>("list", p.list, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Presence) /** * @brief Describes how the Presence is configured for a group of type @ref Group::gtPresence in @ref Group::Type_t * * Helper C++ class to serialize and de-serialize Presence JSON * * Example: @include[doc] examples/Presence.json * * @see Group */ class Presence : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Presence) public: /** * @brief Presence format types enum. */ typedef enum { /** @brief Unknown */ pfUnknown = 0, /** @brief Engage propriety format */ pfEngage = 1, /** * @brief Cursor On Target format. * * This is a simple XML based exchange standard that is used to share information about targets. * Cursor on Target was originally developed by MITRE in 2002 in support of the U.S. Air Force Electronic Systems Center (ESC) */ pfCot = 2 } Format_t; /** @brief Format to be used to represent presence information. */ Format_t format; /** @brief [Optional, Default: 30] The interval in seconds at which to send the presence descriptor on the presence group */ int intervalSecs; /** @brief Instructs the Engage Engine to not transmit presence descriptor */ bool listenOnly; /** @brief [Optional, Default: 5] The minimum interval to send at to prevent network flooding */ int minIntervalSecs; /** @brief [Optional, Default: false] Instructs the Engage Engine reduce the immediacy of presence announcements wherever possible */ bool reduceImmediacy; Presence() { clear(); } void clear() { format = pfUnknown; intervalSecs = 30; listenOnly = false; minIntervalSecs = 5; reduceImmediacy = false; } }; static void to_json(nlohmann::json& j, const Presence& p) { j = nlohmann::json{ TOJSON_IMPL(format), TOJSON_IMPL(intervalSecs), TOJSON_IMPL(listenOnly), TOJSON_IMPL(minIntervalSecs), TOJSON_IMPL(reduceImmediacy) }; } static void from_json(const nlohmann::json& j, Presence& p) { p.clear(); getOptional("format", p.format, j, Presence::Format_t::pfEngage); getOptional("intervalSecs", p.intervalSecs, j, 30); getOptional("listenOnly", p.listenOnly, j, false); getOptional("minIntervalSecs", p.minIntervalSecs, j, 5); getOptional("reduceImmediacy", p.reduceImmediacy, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Advertising) /** * @brief Defines parameters for advertising of an entity such as a known, public, group. * * Helper C++ class to serialize and de-serialize Advertising JSON * * Example: @include[doc] examples/Advertising.json * * @see DiscoverySsdp, DiscoverySap */ class Advertising : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Advertising) public: /** @brief [Optional, Default: false] Enabled advertising */ bool enabled; /** @brief [Optional, Default: 20000] Interval at which the advertisement should be sent in milliseconds. */ int intervalMs; /** @brief [Optional, Default: false] If true, the node will advertise the item even if it detects other nodes making the same advertisement */ bool alwaysAdvertise; Advertising() { clear(); } void clear() { enabled = false; intervalMs = 20000; alwaysAdvertise = false; } }; static void to_json(nlohmann::json& j, const Advertising& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(intervalMs), TOJSON_IMPL(alwaysAdvertise) }; } static void from_json(const nlohmann::json& j, Advertising& p) { p.clear(); getOptional("enabled", p.enabled, j, false); getOptional("intervalMs", p.intervalMs, j, 20000); getOptional("alwaysAdvertise", p.alwaysAdvertise, j, false); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupPriorityTranslation) /** * @brief Details for priority transmission based on unique network addressing * * Helper C++ class to serialize and de-serialize GroupPriorityTranslation JSON * * Example: @include[doc] examples/GroupPriorityTranslation.json * * @see Group */ class GroupPriorityTranslation : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupPriorityTranslation) public: /** @brief RX addressing */ NetworkAddress rx; /** @brief TX addressing */ NetworkAddress tx; /** @brief Engage priority for RX & TX */ int priority; GroupPriorityTranslation() { clear(); } void clear() { rx.clear(); tx.clear(); priority = 0; } }; static void to_json(nlohmann::json& j, const GroupPriorityTranslation& p) { j = nlohmann::json{ TOJSON_IMPL(rx), TOJSON_IMPL(tx), TOJSON_IMPL(priority) }; } static void from_json(const nlohmann::json& j, GroupPriorityTranslation& p) { p.clear(); j.at("rx").get_to(p.rx); j.at("tx").get_to(p.tx); FROMJSON_IMPL(priority, int, 0); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupTimeline) /** * @brief Configuration for Timeline functionality for Group. * * If a GroupTimeline is not specified, then the configursation in the @ref ConfigurationObjects::EnginePolicyTimelines will used as default. * * Helper C++ class to serialize and de-serialize GroupTimeline JSON * * Example: @include[doc] examples/GroupTimeline.json * * @see ConfigurationObjects::Group, ConfigurationObjects::EnginePolicyTimeLines */ class GroupTimeline : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupTimeline) public: /** @brief [Optional, Default: true] Enables timeline feature. */ bool enabled; /** @brief [Optional, Default: 30000] Maximum audio block size to record in milliseconds. */ int maxAudioTimeMs; bool recordAudio; GroupTimeline() { clear(); } void clear() { enabled = true; maxAudioTimeMs = 30000; recordAudio = true; } }; static void to_json(nlohmann::json& j, const GroupTimeline& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(maxAudioTimeMs), TOJSON_IMPL(recordAudio) }; } static void from_json(const nlohmann::json& j, GroupTimeline& p) { p.clear(); getOptional("enabled", p.enabled, j, true); getOptional("maxAudioTimeMs", p.maxAudioTimeMs, j, 30000); getOptional("recordAudio", p.recordAudio, j, true); } /** @addtogroup groupSources Group source names * * Names assigned to entities that advertise groups/channels. * * @{ */ /** @brief Internal to Engage */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_INTERNAL = "com.rallytac.engage.internal"; /** @brief The source is a Magellan-capable entity */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_CORE = "com.rallytac.magellan.core"; /** @brief The source is CISTECH via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_CISTECH = "com.rallytac.engage.magellan.cistech"; /** @brief The source is Trellisware via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_TRELLISWARE = "com.rallytac.engage.magellan.trellisware"; /** @brief The source is Silvus via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_SILVUS = "com.rallytac.engage.magellan.silvus"; /** @brief The source is Persistent Systems via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_PERSISTENT = "com.rallytac.engage.magellan.persistent"; /** @brief The source is Domo Tactical via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_DOMO = "com.rallytac.engage.magellan.domo"; /** @brief The source is Kenwood via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_KENWOOD = "com.rallytac.engage.magellan.kenwood"; /** @brief The source is Tait via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_TAIT = "com.rallytac.engage.magellan.tait"; /** @brief The source is Vocality via Magellan discovery */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_VOCALITY = "com.rallytac.engage.magellan.vocality"; /** @} */ /** @addtogroup groupDisconnectReasons Reasons for why a group has disconnected * * These are additional reason descriptors that may accompany a onGroupDisconnected event * * @{ */ /** @brief No particular reason was provided */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_REAON = "NoReason"; /** @brief The link to the Rallypoint is down */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_LINK = "NoLink"; /** @brief The group has been gracefully unregistered from the Rallypoint **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_UNREGISTERED = "Unregistered"; /** @brief The Rallypoint is not accepting registration for the group at this time **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NOT_ALLOWED = "NotAllowed"; /** @brief The Rallypoint has denied the registration because the registration is for a security level not allowed on the RP **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_SECURITY_CLASSIFICATION_LEVEL_TOO_HIGH = "SecurityClassificationLevelTooHigh"; /** @brief The Rallypoint has denied the registration for no specific reason **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_GENERAL_DENIAL = "GeneralDenial"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an access tag for the group **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ACCESS_TAG = "NoAccessTag"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an access tag for the group **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ACCESS_TAG = "ExcludedAccessTag"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved serial number **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SERIAL = "NoSerial"; /** @brief The Rallypoint denied the registration request because the far-end's certificate serial number has been excluded **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SERIAL = "ExcludedSerial"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved fingerprint **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_FINGERPRINT = "NoFingerprint"; /** @brief The Rallypoint denied the registration request because the far-end's certificate fingerprint has been excluded **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_FINGERPRINT = "ExcludedFingerprint"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved subject **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SUBJECT = "NoSubject"; /** @brief The Rallypoint denied the registration request because the far-end's certificate subject has been excluded **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SUBJECT = "ExcludedSubject"; /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved issuer **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ISSUER = "NoIssuer"; /** @brief The Rallypoint denied the registration request because the far-end's certificate issuer has been excluded **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ISSUER = "ExcludedIssuer"; /** @brief The Rallypoint denied the registration request because the far-end does not appear in any whitelist criteria **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NOT_ON_WHITELIST = "NotOnWhitelist"; /** @brief The Rallypoint denied the registration request because the far-end does appears in blackist criteria **/ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_ON_BLACKLIST = "OnBlacklist"; /** @} */ /** @addtogroup OID IANA-type object identifiers * * Object Identifiers we commonly use * * @{ */ /** @brief Rally Tactical Systems' PEN as assigned by IANA */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_PEM = "58217"; /** @brief The link to the Rallypoint is down */ ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_CERT_SUBJ_ACCESS_TAGS = "1.3.6.1.4.1.58217.1"; /** @} */ //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupAppTransport) /** * @brief Configuration for the optional custom transport functionality for Group. * * Helper C++ class to serialize and de-serialize GroupAppTransport JSON * * Example: @include[doc] examples/GroupAppTransport.json * * @see ConfigurationObjects::Group */ class GroupAppTransport : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupAppTransport) public: /** @brief [Optional, Default: false] Enables custom feature. */ bool enabled; /** @brief The id/name of the transport. This must match the id/name supplied when registering the app transport.*/ std::string id; GroupAppTransport() { clear(); } void clear() { enabled = false; id.clear(); } }; static void to_json(nlohmann::json& j, const GroupAppTransport& p) { j = nlohmann::json{ TOJSON_IMPL(enabled), TOJSON_IMPL(id) }; } static void from_json(const nlohmann::json& j, GroupAppTransport& p) { p.clear(); getOptional("enabled", p.enabled, j, false); getOptional("id", p.id, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(RtpProfile) /** * @brief Configuration for the optional RtpProfile. * * Helper C++ class to serialize and de-serialize RtpProfile JSON * * Example: @include[doc] examples/RtpProfile.json * * @see ConfigurationObjects::Group */ class RtpProfile : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(RtpProfile) public: /** * @brief Jitter buffer mode. * * Operation mode for the jitter buffer. */ typedef enum { /** @brief Default */ jmStandard = 0, /** @brief Low latency */ jmLowLatency = 1, /** @brief The jitter buffer releases upon positive end of TX notification */ jmReleaseOnTxEnd = 2 } JitterMode_t; /** @brief [Optional, Default: jmStandard] Specifies the operation mode (see @ref JitterMode_t). */ JitterMode_t mode; /** @brief [Optional, Default: 10000] Maximum number of milliseconds allowed in the queue */ int jitterMaxMs; /** @brief [Optional, Default: 100] Low-water mark for jitter buffers that are in a buffering state. */ int jitterMinMs; /** @brief [Optional, Default: 8] The factor by which to multiply the jitter buffer's active low-water to determine the high-water mark */ int jitterMaxFactor; /** @brief [Optional, Default: 5] The delta in RTP sequence numbers in order to heuristically determine the start of a new talk spurt */ int latePacketSequenceRange; /** @brief [Optional, Default: 500] The delta in milliseconds in order to heuristically determine the start of a new talk spurt */ int latePacketTimestampRangeMs; /** @brief [Optional, Default: 10] The percentage of the overall jitter buffer sample count to trim when potential buffer overflow is encountered */ int jitterTrimPercentage; /** @brief [Optional, Default: 1500] Number of milliseconds of error-free operations in a jitter buffer before the underrun counter begins reducing */ int jitterUnderrunReductionThresholdMs; /** @brief [Optional, Default: 100] Number of jitter buffer operations after which to reduce any underrun */ int jitterUnderrunReductionAger; /** @brief [Optional, Default: 0] Forces trimming of the jitter buffer if the queue length is greater (and not zero) */ int jitterForceTrimAtMs; /** @brief [Optional, Default: 250] Maximum number of milliseconds to be trimmed from a jitter buffer at any one point */ int jitterMaxTrimMs; /** @brief [Optional, Default: 10] Percentage by which maximum number of samples in the queue exceeded computed max before large-scale clipping . */ int jitterMaxExceededClipPerc; /** @brief [Optional, Default: 1500] Number of milliseconds for which the jitter buffer may exceed max before clipping is actually applied. */ int jitterMaxExceededClipHangMs; /** @brief [Optional, Default: 500] The number of milliseconds of RTP inactivity before heuristically determining the end of talk spurt */ int inboundProcessorInactivityMs; /** @brief [Optional, Default: 45000] Timeout for RTCP presence. */ int rtcpPresenceTimeoutMs; /** @brief [Optional, Default: 15000] The number of milliseconds that a "zombified" RTP processor is kept around before being removed for good */ int zombieLifetimeMs; /** @brief [Optional, Default: inboundProcessorInactivityMs * 4] The number of milliseconds of RTP inactivity on an Engage-native/signalled (i.e. where * end-of-tx is expected) stream before heuristically determining the end of talk spurt */ int signalledInboundProcessorInactivityMs; RtpProfile() { clear(); } void clear() { mode = jmStandard; jitterMaxMs = 10000; jitterMinMs = 100; jitterMaxFactor = 8; jitterTrimPercentage = 10; jitterUnderrunReductionThresholdMs = 1500; jitterUnderrunReductionAger = 100; latePacketSequenceRange = 5; latePacketTimestampRangeMs = 2000; inboundProcessorInactivityMs = 500; jitterForceTrimAtMs = 0; rtcpPresenceTimeoutMs = 45000; jitterMaxExceededClipPerc = 10; jitterMaxExceededClipHangMs = 1500; zombieLifetimeMs = 15000; jitterMaxTrimMs = 250; signalledInboundProcessorInactivityMs = (inboundProcessorInactivityMs * 4); } }; static void to_json(nlohmann::json& j, const RtpProfile& p) { j = nlohmann::json{ TOJSON_IMPL(mode), TOJSON_IMPL(jitterMaxMs), TOJSON_IMPL(inboundProcessorInactivityMs), TOJSON_IMPL(jitterMinMs), TOJSON_IMPL(jitterMaxFactor), TOJSON_IMPL(jitterTrimPercentage), TOJSON_IMPL(jitterUnderrunReductionThresholdMs), TOJSON_IMPL(jitterUnderrunReductionAger), TOJSON_IMPL(latePacketSequenceRange), TOJSON_IMPL(latePacketTimestampRangeMs), TOJSON_IMPL(inboundProcessorInactivityMs), TOJSON_IMPL(jitterForceTrimAtMs), TOJSON_IMPL(jitterMaxExceededClipPerc), TOJSON_IMPL(jitterMaxExceededClipHangMs), TOJSON_IMPL(zombieLifetimeMs), TOJSON_IMPL(jitterMaxTrimMs), TOJSON_IMPL(signalledInboundProcessorInactivityMs) }; } static void from_json(const nlohmann::json& j, RtpProfile& p) { p.clear(); FROMJSON_IMPL(mode, RtpProfile::JitterMode_t, RtpProfile::JitterMode_t::jmStandard); FROMJSON_IMPL(jitterMaxMs, int, 10000); FROMJSON_IMPL(jitterMinMs, int, 20); FROMJSON_IMPL(jitterMaxFactor, int, 8); FROMJSON_IMPL(jitterTrimPercentage, int, 10); FROMJSON_IMPL(jitterUnderrunReductionThresholdMs, int, 1500); FROMJSON_IMPL(jitterUnderrunReductionAger, int, 100); FROMJSON_IMPL(latePacketSequenceRange, int, 5); FROMJSON_IMPL(latePacketTimestampRangeMs, int, 2000); FROMJSON_IMPL(inboundProcessorInactivityMs, int, 500); FROMJSON_IMPL(jitterForceTrimAtMs, int, 0); FROMJSON_IMPL(rtcpPresenceTimeoutMs, int, 45000); FROMJSON_IMPL(jitterMaxExceededClipPerc, int, 10); FROMJSON_IMPL(jitterMaxExceededClipHangMs, int, 1500); FROMJSON_IMPL(zombieLifetimeMs, int, 15000); FROMJSON_IMPL(jitterMaxTrimMs, int, 250); FROMJSON_IMPL(signalledInboundProcessorInactivityMs, int, (p.inboundProcessorInactivityMs * 4)); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Tls) /** * @brief TODO: Transport Security Layer (TLS) settings * * Helper C++ class to serialize and de-serialize Tls JSON * * Example: @include[doc] examples/Tls.json * * @see RallypointServer */ class Tls : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Tls) public: /** @brief [Optional, Default: true] When true, checks the far-end certificate validity and Engage-specific TLS setup procedure. */ bool verifyPeers; /** @brief [Optional, Default: false] When true, accepts far-end certificates that are self-signed. */ bool allowSelfSignedCertificates; /** @brief [Optional] Array of CA certificates (PEM or "@" file/certstore references) to be used to validate far-end certificates. */ std::vector caCertificates; /** @brief [NOT USED AT THIS TIME] */ StringRestrictionList subjectRestrictions; /** @brief [NOT USED AT THIS TIME] */ StringRestrictionList issuerRestrictions; /** @brief [Optional] Array of serial numbers certificates that have been revoked*/ std::vector crlSerials; Tls() { clear(); } void clear() { verifyPeers = true; allowSelfSignedCertificates = false; caCertificates.clear(); subjectRestrictions.clear(); issuerRestrictions.clear(); crlSerials.clear(); } }; static void to_json(nlohmann::json& j, const Tls& p) { j = nlohmann::json{ TOJSON_IMPL(verifyPeers), TOJSON_IMPL(allowSelfSignedCertificates), TOJSON_IMPL(caCertificates), TOJSON_IMPL(subjectRestrictions), TOJSON_IMPL(issuerRestrictions), TOJSON_IMPL(crlSerials) }; } static void from_json(const nlohmann::json& j, Tls& p) { p.clear(); getOptional("verifyPeers", p.verifyPeers, j, true); getOptional("allowSelfSignedCertificates", p.allowSelfSignedCertificates, j, false); getOptional>("caCertificates", p.caCertificates, j); getOptional("subjectRestrictions", p.subjectRestrictions, j); getOptional("issuerRestrictions", p.issuerRestrictions, j); getOptional>("crlSerials", p.crlSerials, j); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(RangerPackets) /** * @brief Options for Ranger packets * * Helper C++ class to serialize and de-serialize RangerPackets JSON * * TODO: Complete this Class * * Example: @include[doc] examples/RangerPackets.json * * @see Group */ class RangerPackets : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(RangerPackets) public: /** @brief [Optional, Default: -1] Number of seconds since last packet transmission before 'count' packets are sent */ int hangTimerSecs; /** @brief [Optional, Default: 5] Number of ranger packets to send when a new interval starts */ int count; RangerPackets() { clear(); } void clear() { hangTimerSecs = -1; count = 5; } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const RangerPackets& p) { j = nlohmann::json{ TOJSON_IMPL(hangTimerSecs), TOJSON_IMPL(count) }; } static void from_json(const nlohmann::json& j, RangerPackets& p) { p.clear(); getOptional("hangTimerSecs", p.hangTimerSecs, j, 11); getOptional("count", p.count, j, 5); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Source) /** * @brief Options for Source * * Helper C++ class to serialize and de-serialize Source JSON * * TODO: Complete this Class * * Example: @include[doc] examples/Source.json * * @see Group */ class Source : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Source) public: /** @brief [Optional] A node ID */ std::string nodeId; /* NOTE: Not serialized ! */ uint8_t _internal_binary_nodeId[ENGAGE_MAX_NODE_ID_SIZE]; /** @brief [Optional] An alias */ std::string alias; /* NOTE: Not serialized ! */ uint8_t _internal_binary_alias[ENGAGE_MAX_ALIAS_SIZE]; Source() { clear(); } void clear() { nodeId.clear(); memset(_internal_binary_nodeId, 0, sizeof(_internal_binary_nodeId)); alias.clear(); memset(_internal_binary_alias, 0, sizeof(_internal_binary_alias)); } virtual void initForDocumenting() { } }; static void to_json(nlohmann::json& j, const Source& p) { j = nlohmann::json{ TOJSON_IMPL(nodeId), TOJSON_IMPL(alias) }; } static void from_json(const nlohmann::json& j, Source& p) { p.clear(); FROMJSON_IMPL_SIMPLE(nodeId); FROMJSON_IMPL_SIMPLE(alias); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupBridgeTargetOutputDetail) /** * @brief Options for Source * * Helper C++ class to serialize and de-serialize GroupBridgeTargetOutputDetail JSON * * TODO: Complete this Class * * Example: @include[doc] examples/GroupBridgeTargetOutputDetail.json * * @see Group */ class GroupBridgeTargetOutputDetail : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupBridgeTargetOutputDetail) public: /** @brief Enum describing bridging operation mode types where applicable. */ typedef enum { /** @brief Raw mode (default) - packet payloads are not accessed or modified and forwarded as raw packets. The * group must have a type of @ref gtRaw. */ bomRaw = 0, /** @brief Audio payloads are transformed, headers are preserved, multiple parallel output streams are * possible/expected. The group must be gtAudio (type = 1).*/ bomMultistream = 1, /** @brief Audio payloads are mixed - output is anonymous (i.e. no metadata) if if the target group(s) * allow header extensions. The group must be gtAudio (type = 1)*/ bomMixedStream = 2, /** @brief No output will be made to the group regardless of type.*/ bomNone = 3 } BridgingOpMode_t; /** @brief [Optional] The output mode */ BridgingOpMode_t mode; /** @brief [Optional] Parameters to be applied when output is mixed (bomMixedStream) */ AdvancedTxParams mixedStreamTxParams; GroupBridgeTargetOutputDetail() { clear(); } void clear() { mode = BridgingOpMode_t::bomRaw; mixedStreamTxParams.clear(); } virtual void initForDocumenting() { clear(); } }; static void to_json(nlohmann::json& j, const GroupBridgeTargetOutputDetail& p) { j = nlohmann::json{ TOJSON_IMPL(mode), TOJSON_IMPL(mixedStreamTxParams) }; } static void from_json(const nlohmann::json& j, GroupBridgeTargetOutputDetail& p) { p.clear(); FROMJSON_IMPL_SIMPLE(mode); FROMJSON_IMPL_SIMPLE(mixedStreamTxParams); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(GroupDefaultAudioPriority) /** * @brief Options for Source * * Helper C++ class to serialize and de-serialize GroupDefaultAudioPriority JSON * * TODO: Complete this Class * * Example: @include[doc] examples/GroupDefaultAudioPriority.json * * @see Group */ class GroupDefaultAudioPriority : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(GroupDefaultAudioPriority) public: /** @brief [Optional] The default audio priority */ uint8_t tx; /** @brief [Optional] The default audio RX priority */ uint8_t rx; GroupDefaultAudioPriority() { clear(); } void clear() { tx = 0; rx = 0; } virtual void initForDocumenting() { clear(); } }; static void to_json(nlohmann::json& j, const GroupDefaultAudioPriority& p) { j = nlohmann::json{ TOJSON_IMPL(tx), TOJSON_IMPL(rx) }; } static void from_json(const nlohmann::json& j, GroupDefaultAudioPriority& p) { p.clear(); FROMJSON_IMPL_SIMPLE(tx); FROMJSON_IMPL_SIMPLE(rx); } //----------------------------------------------------------- JSON_SERIALIZED_CLASS(Group) /** * @brief Group Configuration * * This describes all the group properties for all supported group types * * Example: @include[doc] examples/Group.json * * @see engageCreateGroup * */ class Group : public ConfigurationObjectBase { IMPLEMENT_JSON_SERIALIZATION() IMPLEMENT_JSON_DOCUMENTATION(Group) public: /** @brief Enum describing the group types. */ typedef enum { /** @brief Unknown group type */ gtUnknown = 0, /** @brief Audio group type. This group is used to transmit Audio. */ gtAudio = 1, /** @brief Presence group type. This group is use to relay presence data to all nodes that are configured for the same presence group. */ gtPresence = 2, /** @brief Raw group type. No special processing is performed on raw groups - the payload is siomply seen as a binary object to be typically handled by the application logic. */ gtRaw = 3 } Type_t; /** @brief Enum describing the alias generation policy. */ typedef enum { /** @brief Use the anonymousAlias if present */ iagpAnonymousAlias = 0, /** @brief Generate hex representation of SSRC. */ iagpSsrcInHex = 1 } InboundAliasGenerationPolicy_t; /** @brief Specifies the group type (see @ref Type_t). */ Type_t type; /** @brief Output details for when the group is a target in a bridge (see @ref GroupBridgeTargetOutputDetail). */ GroupBridgeTargetOutputDetail bridgeTargetOutputDetail; /** @brief Default audio priority for the group (see @ref GroupDefaultAudioPriority). */ GroupDefaultAudioPriority defaultAudioPriority; /** * @brief Unique identity for the group. * * NOTE: Groups configured with the same multicast addresses but with different * id's will NOT be routed correctly via RallyPoints as they are considered different streams. */ std::string id; /** @brief The human readable name for the group. */ std::string name; /** @brief The group name as spoken - typically by a text-to-speech system */ std::string spokenName; /** @brief The name of the network interface to use for multicasting for this group. If not provided, the Engine's default multicast NIC is used. */ std::string interfaceName; /** @brief The network address for receiving network traffic on. */ NetworkAddress rx; /** @brief The network address for transmitting network traffic to. */ NetworkAddress tx; /** @brief Transmit options for the group (see @ref NetworkTxOptions). */ NetworkTxOptions txOptions; /** @brief Audio transmit options such as codec, framing size etc (see @ref TxAudio). */ TxAudio txAudio; /** @brief Presence configuration (see @ref Presence). */ Presence presence; /** @brief Password to be used for encryption. Note that this is not the encryption key but, rather, the hexidecimal representation of the baseline material to be used in a PBFDK2 algorithm for key derivation. */ std::string cryptoPassword; /** @brief [Optional, Default: false] Use low-bandwidth crypto */ bool lbCrypto; /** @brief [DEPRECATED] List of @ref Rallypoint (s) the Group should use to connect to a Rallypoint router. Use @ref RallypointCluster instead. */ std::vector rallypoints; /** @brief Cluster of one or more @ref Rallypoints the group may use. */ RallypointCluster rallypointCluster; /** @brief Sets audio properties like which audio device to use, audio gain etc (see @ref Audio). */ Audio audio; /** * @brief Audio timeline is configuration. * * Specifies how the Engine should record times lines. Timelines are used for instant replay and audio archival. * * @see engageQueryGroupTimeline, PFN_ENGAGE_GROUP_TIMELINE_EVENT_??? events */ GroupTimeline timeline; /** @brief User alias to transmit as part of the realtime audio stream when using the @ref engageBeginGroupTx API. */ std::string alias; /** @brief [Optional, Default: false] Set this to true if you do not want the Engine to advertise this Group on the Presence group. */ bool blockAdvertising; /** @brief [Optional, Default: null] Indicates the source of this configuration - e.g. from the application or discovered via Magellan */ std::string source; /** * @brief [Optional, Default: 0] Maximum number of seconds the Engine will receive for on this group. * * When the time limit is exceeded, the Engine will fire a PFN_ENGAGE_GROUP_MAX_RX_TIME_EXCEEDED event. */ int maxRxSecs; /** @brief [Optional, Default: false] Set this to true to enable failover to multicast operation if a Rallypoint connection cannot be established. */ bool enableMulticastFailover; /** @brief [Optional, Default: 10] Specifies the number fo seconds to wait after Rallypoint connection failure to switch to multicast operation. */ int multicastFailoverSecs; /** @brief The network address for receiving RTCP presencing packets */ NetworkAddress rtcpPresenceRx; /** @brief List of presence group IDs with which this group has an affinity */ std::vector presenceGroupAffinities; /** @brief [Optional, Default: false] Disable packet events. */ bool disablePacketEvents; /** @brief [Optional, Default: 0] The RTP payload ID by which to identify (RX and TX) payloads encoded according to RFC 4733 (RFC 2833). */ int rfc4733RtpPayloadId; /** @brief [Optional] A vector of translations from external entity RTP payload types to those used by Engage */ std::vector inboundRtpPayloadTypeTranslations; /** @brief [Optional] Describe how traffic for this group on a different addressing scheme translates to priority for the group */ GroupPriorityTranslation priorityTranslation; /** @brief [Optional, Default: 10] The number of seconds after which "sticky" transmission IDs expire. */ int stickyTidHangSecs; /** @brief [Optional] Alias to use for inbound streams that do not have an alias component */ std::string anonymousAlias; /** @brief [Optional] Settings necessary if the group is transported via an application-supplied custom transport */ GroupAppTransport appTransport; /** @brief [Optional, Default: false] Allows for processing of looped back packets - primarily meant for debugging */ bool allowLoopback; /** @brief [Optional] RTP profile the group */ RtpProfile rtpProfile; /** @brief [Optional] Ranger packet options */ RangerPackets rangerPackets; /** @brief [Internal - not serialized */ bool _wasDeserialized_rtpProfile; /** @brief [Optional] The TX impairment to apply */ TransportImpairment txImpairment; /** @brief [Optional] The RX impairment to apply */ TransportImpairment rxImpairment; /** @brief List of specializer IDs that the local node has an affinity for/member of */ std::vector specializerAffinities; /** @brief [Optional, Default: 0] The security classification level of the group. */ uint32_t securityLevel; /** @brief [Optional] List of sources to ignore for this group */ std::vector ignoreSources; /** @brief ISO 639-2 language code for the group */ std::string languageCode; /** @brief Name of the synthesis voice to use for the group */ std::string synVoice; /** @brief Details for capture of received packets */ PacketCapturer rxCapture; /** @brief Details for capture of transmitted packets */ PacketCapturer txCapture; /** @brief [Optional, Default: ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE] The RTP payload type to be used for blobs sent over RTP (see BlobInfo) */ uint16_t blobRtpPayloadType; /** @brief [Optional, Default: iagpAnonymousAlias] */ InboundAliasGenerationPolicy_t inboundAliasGenerationPolicy; /** @brief [Optional] Inbound gating of audio - only audio allowed through by the gate will be processed */ AudioGate gateIn; /** @brief [Optional, Default: false] Indicates that the group should ignore traffic that is audio-related */ bool ignoreAudioTraffic; Group() { clear(); } void clear() { type = gtUnknown; bridgeTargetOutputDetail.clear(); defaultAudioPriority.clear(); id.clear(); name.clear(); spokenName.clear(); interfaceName.clear(); rx.clear(); tx.clear(); txOptions.clear(); txAudio.clear(); presence.clear(); cryptoPassword.clear(); alias.clear(); rallypoints.clear(); rallypointCluster.clear(); audio.clear(); timeline.clear(); blockAdvertising = false; source.clear(); maxRxSecs = 0; enableMulticastFailover = false; multicastFailoverSecs = 10; rtcpPresenceRx.clear(); presenceGroupAffinities.clear(); disablePacketEvents = false; rfc4733RtpPayloadId = 0; inboundRtpPayloadTypeTranslations.clear(); priorityTranslation.clear(); stickyTidHangSecs = 10; anonymousAlias.clear(); lbCrypto = false; appTransport.clear(); allowLoopback = false; rtpProfile.clear(); rangerPackets.clear(); _wasDeserialized_rtpProfile = false; txImpairment.clear(); rxImpairment.clear(); specializerAffinities.clear(); securityLevel = 0; ignoreSources.clear(); languageCode.clear(); synVoice.clear(); rxCapture.clear(); txCapture.clear(); blobRtpPayloadType = ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE; inboundAliasGenerationPolicy = iagpAnonymousAlias; gateIn.clear(); ignoreAudioTraffic = false; } }; static void to_json(nlohmann::json& j, const Group& p) { j = nlohmann::json{ TOJSON_IMPL(type), TOJSON_IMPL(bridgeTargetOutputDetail), TOJSON_IMPL(defaultAudioPriority), TOJSON_IMPL(id), TOJSON_IMPL(name), TOJSON_IMPL(spokenName), TOJSON_IMPL(interfaceName), TOJSON_IMPL(rx), TOJSON_IMPL(tx), TOJSON_IMPL(txOptions), TOJSON_IMPL(txAudio), TOJSON_IMPL(presence), TOJSON_IMPL(cryptoPassword), TOJSON_IMPL(alias), // See below //TOJSON_IMPL(rallypoints), //TOJSON_IMPL(rallypointCluster), TOJSON_IMPL(alias), TOJSON_IMPL(audio), TOJSON_IMPL(timeline), TOJSON_IMPL(blockAdvertising), TOJSON_IMPL(source), TOJSON_IMPL(maxRxSecs), TOJSON_IMPL(enableMulticastFailover), TOJSON_IMPL(multicastFailoverSecs), TOJSON_IMPL(rtcpPresenceRx), TOJSON_IMPL(presenceGroupAffinities), TOJSON_IMPL(disablePacketEvents), TOJSON_IMPL(rfc4733RtpPayloadId), TOJSON_IMPL(inboundRtpPayloadTypeTranslations), TOJSON_IMPL(priorityTranslation), TOJSON_IMPL(stickyTidHangSecs), TOJSON_IMPL(anonymousAlias), TOJSON_IMPL(lbCrypto), TOJSON_IMPL(appTransport), TOJSON_IMPL(allowLoopback), TOJSON_IMPL(rangerPackets), TOJSON_IMPL(txImpairment), TOJSON_IMPL(rxImpairment), TOJSON_IMPL(specializerAffinities), TOJSON_IMPL(securityLevel), TOJSON_IMPL(ignoreSources), TOJSON_IMPL(languageCode), TOJSON_IMPL(synVoice), TOJSON_IMPL(rxCapture), TOJSON_IMPL(txCapture), TOJSON_IMPL(blobRtpPayloadType), TOJSON_IMPL(inboundAliasGenerationPolicy), TOJSON_IMPL(gateIn), TOJSON_IMPL(ignoreAudioTraffic) }; TOJSON_BASE_IMPL(); // TODO: need a better way to indicate whether rtpProfile is present if(p._wasDeserialized_rtpProfile || p.isDocumenting()) { j["rtpProfile"] = p.rtpProfile; } if(p.isDocumenting()) { j["rallypointCluster"] = p.rallypointCluster; j["rallypoints"] = p.rallypoints; } else { // rallypointCluster takes precedence if it has elements if(!p.rallypointCluster.rallypoints.empty()) { j["rallypointCluster"] = p.rallypointCluster; } else if(!p.rallypoints.empty()) { j["rallypoints"] = p.rallypoints; } } } static void from_json(const nlohmann::json& j, Group& p) { p.clear(); j.at("type").get_to(p.type); getOptional("bridgeTargetOutputDetail", p.bridgeTargetOutputDetail, j); j.at("id").get_to(p.id); getOptional("name", p.name, j); getOptional("spokenName", p.spokenName, j); getOptional("interfaceName", p.interfaceName, j); getOptional("rx", p.rx, j); getOptional("tx", p.tx, j); getOptional("txOptions", p.txOptions, j); getOptional("cryptoPassword", p.cryptoPassword, j); getOptional("alias", p.alias, j); getOptional("txAudio", p.txAudio, j); getOptional("presence", p.presence, j); getOptional>("rallypoints", p.rallypoints, j); getOptional("rallypointCluster", p.rallypointCluster, j); getOptional