20#ifndef ConfigurationObjects_h
21#define ConfigurationObjects_h
24#include "EngageConstants.h"
33#include <nlohmann/json.hpp>
36 #pragma GCC diagnostic push
37 #pragma GCC diagnostic ignored "-Wunused-function"
40#if !defined(ENGAGE_IGNORE_COMPILER_UNUSED_WARNING)
42 #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING __attribute__((unused))
44 #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING
50#if defined(RTS_CORE_BUILD)
51namespace ConfigurationObjects
53namespace AppConfigurationObjects
56 static const char *ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT =
"_attached";
150 } DataSeriesValueType_t;
164 bloodOxygenation = 5,
166 taskEffectiveness = 7
167 } HumanBiometricsTypes_t;
171 static FILE *_internalFileOpener(
const char *fn,
const char *mode)
176 fp = fopen(fn, mode);
178 if(fopen_s(&fp, fn, mode) != 0)
187 #define JSON_SERIALIZED_CLASS(_cn) \
189 static void to_json(nlohmann::json& j, const _cn& p); \
190 static void from_json(const nlohmann::json& j, _cn& p);
192 #define IMPLEMENT_JSON_DOCUMENTATION(_cn) \
194 static void document(const char *path = nullptr) \
197 example.initForDocumenting(); \
198 std::string theJson = example.serialize(3); \
199 std::cout << "------------------------------------------------" << std::endl \
200 << #_cn << std::endl \
201 << theJson << std::endl \
202 << "------------------------------------------------" << std::endl; \
204 if(path != nullptr && path[0] != 0) \
206 std::string fn = path; \
209 fn.append(".json"); \
211 FILE *fp = _internalFileOpener(fn.c_str(), "wt");\
215 fputs(theJson.c_str(), fp); \
220 std::cout << "ERROR: Cannot write to " << fn << std::endl; \
224 static const char *className() \
229 #define IMPLEMENT_JSON_SERIALIZATION() \
231 bool deserialize(const char *s) \
235 if(s != nullptr && s[0] != 0) \
237 from_json(nlohmann::json::parse(s), *this); \
251 std::string serialize(const int indent = -1) \
257 return j.dump(indent); \
261 return std::string("{}"); \
265 #define IMPLEMENT_WRAPPED_JSON_SERIALIZATION(_cn) \
267 std::string serializeWrapped(const int indent = -1) \
276 firstChar[0] = #_cn[0]; \
278 firstChar[0] = tolower(firstChar[0]); \
280 rc.append(firstChar); \
281 rc.append((#_cn) + 1); \
283 rc.append(j.dump(indent)); \
290 return std::string("{}"); \
294 #define TOJSON_IMPL(__var) \
297 #define FROMJSON_IMPL_SIMPLE(__var) \
298 getOptional(#__var, p.__var, j)
300 #define FROMJSON_IMPL(__var, __type, __default) \
301 getOptional<__type>(#__var, p.__var, j, __default)
303 #define TOJSON_BASE_IMPL() \
304 to_json(j, (ConfigurationObjectBase&)p)
306 #define FROMJSON_BASE_IMPL() \
307 from_json(j, (ConfigurationObjectBase&)p);
311 static std::string EMPTY_STRING;
314 static void getOptional(
const char *name, T& v,
const nlohmann::json& j, T def)
320 j.at(name).get_to(v);
334 static void getOptional(
const char *name, T& v,
const nlohmann::json& j)
340 j.at(name).get_to(v);
349 static void getOptionalWithIndicator(
const char *name, T& v,
const nlohmann::json& j, T def,
bool *wasFound)
355 j.at(name).get_to(v);
372 static void getOptionalWithIndicator(
const char *name, T& v,
const nlohmann::json& j,
bool *wasFound)
378 j.at(name).get_to(v);
397 _documenting =
false;
404 virtual void initForDocumenting()
409 virtual std::string toString()
411 return std::string(
"");
414 inline virtual bool isDocumenting()
const
419 nlohmann::json _attached;
429 if(p._attached !=
nullptr)
431 j[ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT] = p._attached;
438 static void from_json(
const nlohmann::json& j, ConfigurationObjectBase& p)
442 if(j.contains(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT))
444 p._attached = j.at(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT);
453 JSON_SERIALIZED_CLASS(TuningSettings)
456 IMPLEMENT_JSON_SERIALIZATION()
500 maxPooledRtpObjects = 0;
501 maxActiveRtpObjects = 0;
504 maxPooledBlobObjects = 0;
505 maxActiveBlobObjects = 0;
507 maxPooledBufferMb = 0;
508 maxPooledBufferObjects = 0;
509 maxActiveBufferObjects = 0;
511 maxActiveRtpProcessors = 0;
514 virtual void initForDocumenting()
520 static void to_json(nlohmann::json& j,
const TuningSettings& p)
523 TOJSON_IMPL(maxPooledRtpMb),
524 TOJSON_IMPL(maxPooledRtpObjects),
525 TOJSON_IMPL(maxActiveRtpObjects),
527 TOJSON_IMPL(maxPooledBlobMb),
528 TOJSON_IMPL(maxPooledBlobObjects),
529 TOJSON_IMPL(maxActiveBlobObjects),
531 TOJSON_IMPL(maxPooledBufferMb),
532 TOJSON_IMPL(maxPooledBufferObjects),
533 TOJSON_IMPL(maxActiveBufferObjects),
535 TOJSON_IMPL(maxActiveRtpProcessors)
538 static void from_json(
const nlohmann::json& j, TuningSettings& p)
541 FROMJSON_IMPL(maxPooledRtpMb, uint32_t, 0);
542 FROMJSON_IMPL(maxPooledRtpObjects, uint32_t, 0);
543 FROMJSON_IMPL(maxActiveRtpObjects, uint32_t, 0);
545 FROMJSON_IMPL(maxPooledBlobMb, uint32_t, 0);
546 FROMJSON_IMPL(maxPooledBlobObjects, uint32_t, 0);
547 FROMJSON_IMPL(maxActiveBlobObjects, uint32_t, 0);
549 FROMJSON_IMPL(maxPooledBufferMb, uint32_t, 0);
550 FROMJSON_IMPL(maxPooledBufferObjects, uint32_t, 0);
551 FROMJSON_IMPL(maxActiveBufferObjects, uint32_t, 0);
553 FROMJSON_IMPL(maxActiveRtpProcessors, uint32_t, 0);
558 JSON_SERIALIZED_CLASS(FipsCryptoSettings)
561 IMPLEMENT_JSON_SERIALIZATION()
594 virtual void initForDocumenting()
600 static void to_json(nlohmann::json& j,
const FipsCryptoSettings& p)
603 TOJSON_IMPL(enabled),
610 static void from_json(
const nlohmann::json& j, FipsCryptoSettings& p)
613 FROMJSON_IMPL_SIMPLE(enabled);
614 FROMJSON_IMPL_SIMPLE(path);
615 FROMJSON_IMPL_SIMPLE(debug);
616 FROMJSON_IMPL_SIMPLE(curves);
617 FROMJSON_IMPL_SIMPLE(ciphers);
622 JSON_SERIALIZED_CLASS(WatchdogSettings)
625 IMPLEMENT_JSON_SERIALIZATION()
653 hangDetectionMs = 2000;
655 slowExecutionThresholdMs = 100;
658 virtual void initForDocumenting()
664 static void to_json(nlohmann::json& j,
const WatchdogSettings& p)
667 TOJSON_IMPL(enabled),
668 TOJSON_IMPL(intervalMs),
669 TOJSON_IMPL(hangDetectionMs),
670 TOJSON_IMPL(abortOnHang),
671 TOJSON_IMPL(slowExecutionThresholdMs)
674 static void from_json(
const nlohmann::json& j, WatchdogSettings& p)
677 getOptional<bool>(
"enabled", p.enabled, j,
true);
678 getOptional<int>(
"intervalMs", p.intervalMs, j, 5000);
679 getOptional<int>(
"hangDetectionMs", p.hangDetectionMs, j, 2000);
680 getOptional<bool>(
"abortOnHang", p.abortOnHang, j,
true);
681 getOptional<int>(
"slowExecutionThresholdMs", p.slowExecutionThresholdMs, j, 100);
686 JSON_SERIALIZED_CLASS(FileRecordingRequest)
689 IMPLEMENT_JSON_SERIALIZATION()
694 std::string fileName;
709 virtual void initForDocumenting()
712 id =
"1-2-3-4-5-6-7-8-9";
713 fileName =
"/tmp/test.wav";
722 TOJSON_IMPL(fileName),
726 static void from_json(
const nlohmann::json& j, FileRecordingRequest& p)
729 j.at(
"id").get_to(p.id);
730 j.at(
"fileName").get_to(p.fileName);
731 getOptional<uint32_t>(
"maxMs", p.maxMs, j, 60000);
736 JSON_SERIALIZED_CLASS(Feature)
739 IMPLEMENT_JSON_SERIALIZATION()
740 IMPLEMENT_JSON_DOCUMENTATION(
Feature)
745 std::string description;
746 std::string comments;
765 virtual void initForDocumenting()
768 id =
"{af9540d1-3e86-4fa6-8b80-e26daecb61ab}";
769 name =
"A sample feature";
770 description =
"This is an example of a feature";
771 comments =
"These are comments for this feature";
777 static void to_json(nlohmann::json& j,
const Feature& p)
782 TOJSON_IMPL(description),
783 TOJSON_IMPL(comments),
788 static void from_json(
const nlohmann::json& j, Feature& p)
791 j.at(
"id").get_to(p.id);
792 getOptional(
"name", p.name, j);
793 getOptional(
"description", p.description, j);
794 getOptional(
"comments", p.comments, j);
795 getOptional(
"count", p.count, j, 0);
803 JSON_SERIALIZED_CLASS(Featureset)
806 IMPLEMENT_JSON_SERIALIZATION()
810 std::string signature;
812 std::vector<Feature> features;
822 lockToDeviceId =
false;
826 virtual void initForDocumenting()
829 signature =
"c39df3f36c6444e686e47e70fc45cf91e6ed2d8de62d4a1e89f507d567ff48aaabb1a70e54b44377b46fc4a1a2e319e5b77e4abffc444db98f8eb55d709aad5f";
830 lockToDeviceId =
false;
834 static void to_json(nlohmann::json& j,
const Featureset& p)
837 TOJSON_IMPL(signature),
838 TOJSON_IMPL(lockToDeviceId),
839 TOJSON_IMPL(features)
842 static void from_json(
const nlohmann::json& j, Featureset& p)
845 getOptional(
"signature", p.signature, j);
846 getOptional<bool>(
"lockToDeviceId", p.lockToDeviceId, j,
false);
847 getOptional<std::vector<Feature>>(
"features", p.features, j);
852 JSON_SERIALIZED_CLASS(Agc)
863 IMPLEMENT_JSON_SERIALIZATION()
864 IMPLEMENT_JSON_DOCUMENTATION(
Agc)
895 compressionGainDb = 25;
896 enableLimiter =
false;
901 static void to_json(nlohmann::json& j,
const Agc& p)
904 TOJSON_IMPL(enabled),
905 TOJSON_IMPL(minLevel),
906 TOJSON_IMPL(maxLevel),
907 TOJSON_IMPL(compressionGainDb),
908 TOJSON_IMPL(enableLimiter),
909 TOJSON_IMPL(targetLevelDb)
912 static void from_json(
const nlohmann::json& j, Agc& p)
915 getOptional<bool>(
"enabled", p.enabled, j,
false);
916 getOptional<int>(
"minLevel", p.minLevel, j, 0);
917 getOptional<int>(
"maxLevel", p.maxLevel, j, 255);
918 getOptional<int>(
"compressionGainDb", p.compressionGainDb, j, 25);
919 getOptional<bool>(
"enableLimiter", p.enableLimiter, j,
false);
920 getOptional<int>(
"targetLevelDb", p.targetLevelDb, j, 3);
925 JSON_SERIALIZED_CLASS(RtpPayloadTypeTranslation)
936 IMPLEMENT_JSON_SERIALIZATION()
957 bool matches(
const RtpPayloadTypeTranslation& other)
959 return ( (external == other.external) && (engage == other.engage) );
963 static void to_json(nlohmann::json& j,
const RtpPayloadTypeTranslation& p)
966 TOJSON_IMPL(external),
970 static void from_json(
const nlohmann::json& j, RtpPayloadTypeTranslation& p)
973 getOptional<uint16_t>(
"external", p.external, j);
974 getOptional<uint16_t>(
"engage", p.engage, j);
978 JSON_SERIALIZED_CLASS(NetworkInterfaceDevice)
981 IMPLEMENT_JSON_SERIALIZATION()
986 std::string friendlyName;
987 std::string description;
992 bool supportsMulticast;
993 std::string hardwareAddress;
1003 friendlyName.clear();
1004 description.clear();
1009 supportsMulticast =
false;
1010 hardwareAddress.clear();
1013 virtual void initForDocumenting()
1017 friendlyName =
"Wi-Fi";
1018 description =
"A wi-fi adapter";
1020 address =
"127.0.0.1";
1023 supportsMulticast =
false;
1024 hardwareAddress =
"DE:AD:BE:EF:01:02:03";
1032 TOJSON_IMPL(friendlyName),
1033 TOJSON_IMPL(description),
1034 TOJSON_IMPL(family),
1035 TOJSON_IMPL(address),
1036 TOJSON_IMPL(available),
1037 TOJSON_IMPL(isLoopback),
1038 TOJSON_IMPL(supportsMulticast),
1039 TOJSON_IMPL(hardwareAddress)
1042 static void from_json(
const nlohmann::json& j, NetworkInterfaceDevice& p)
1045 getOptional(
"name", p.name, j);
1046 getOptional(
"friendlyName", p.friendlyName, j);
1047 getOptional(
"description", p.description, j);
1048 getOptional(
"family", p.family, j, -1);
1049 getOptional(
"address", p.address, j);
1050 getOptional(
"available", p.available, j,
false);
1051 getOptional(
"isLoopback", p.isLoopback, j,
false);
1052 getOptional(
"supportsMulticast", p.supportsMulticast, j,
false);
1053 getOptional(
"hardwareAddress", p.hardwareAddress, j);
1057 JSON_SERIALIZED_CLASS(ListOfNetworkInterfaceDevice)
1060 IMPLEMENT_JSON_SERIALIZATION()
1064 std::vector<NetworkInterfaceDevice> list;
1083 static void from_json(
const nlohmann::json& j, ListOfNetworkInterfaceDevice& p)
1086 getOptional<std::vector<NetworkInterfaceDevice>>(
"list", p.list, j);
1091 JSON_SERIALIZED_CLASS(RtpHeader)
1102 IMPLEMENT_JSON_SERIALIZATION()
1136 virtual void initForDocumenting()
1147 static void to_json(nlohmann::json& j,
const RtpHeader& p)
1153 TOJSON_IMPL(marker),
1160 static void from_json(
const nlohmann::json& j, RtpHeader& p)
1163 getOptional<int>(
"pt", p.pt, j, -1);
1164 getOptional<bool>(
"marker", p.marker, j,
false);
1165 getOptional<uint16_t>(
"seq", p.seq, j, 0);
1166 getOptional<uint32_t>(
"ssrc", p.ssrc, j, 0);
1167 getOptional<uint32_t>(
"ts", p.ts, j, 0);
1171 JSON_SERIALIZED_CLASS(BlobInfo)
1182 IMPLEMENT_JSON_SERIALIZATION()
1183 IMPLEMENT_JSON_DOCUMENTATION(
BlobInfo)
1198 bptJsonTextUtf8 = 2,
1204 bptEngageBinaryHumanBiometrics = 4,
1207 bptAppMimeMessage = 5,
1210 bptEngageInternal = 42
1245 payloadType = PayloadType_t::bptUndefined;
1250 virtual void initForDocumenting()
1253 rtpHeader.initForDocumenting();
1257 static void to_json(nlohmann::json& j,
const BlobInfo& p)
1261 TOJSON_IMPL(source),
1262 TOJSON_IMPL(target),
1263 TOJSON_IMPL(rtpHeader),
1264 TOJSON_IMPL(payloadType),
1266 TOJSON_IMPL(txnTimeoutSecs)
1269 static void from_json(
const nlohmann::json& j, BlobInfo& p)
1272 getOptional<size_t>(
"size", p.size, j, 0);
1273 getOptional<std::string>(
"source", p.source, j, EMPTY_STRING);
1274 getOptional<std::string>(
"target", p.target, j, EMPTY_STRING);
1275 getOptional<RtpHeader>(
"rtpHeader", p.rtpHeader, j);
1276 getOptional<BlobInfo::PayloadType_t>(
"payloadType", p.payloadType, j, BlobInfo::PayloadType_t::bptUndefined);
1277 getOptional<std::string>(
"txnId", p.txnId, j, EMPTY_STRING);
1278 getOptional<int>(
"txnTimeoutSecs", p.txnTimeoutSecs, j, 0);
1283 JSON_SERIALIZED_CLASS(TxAudioUri)
1297 IMPLEMENT_JSON_SERIALIZATION()
1318 virtual void initForDocumenting()
1323 static void to_json(nlohmann::json& j,
const TxAudioUri& p)
1327 TOJSON_IMPL(repeatCount)
1330 static void from_json(
const nlohmann::json& j, TxAudioUri& p)
1333 getOptional<std::string>(
"uri", p.uri, j, EMPTY_STRING);
1334 getOptional<int>(
"repeatCount", p.repeatCount, j, 0);
1339 JSON_SERIALIZED_CLASS(AdvancedTxParams)
1353 IMPLEMENT_JSON_SERIALIZATION()
1398 includeNodeId =
false;
1403 aliasSpecializer = 0;
1404 receiverRxMuteForAliasSpecializer =
false;
1407 virtual void initForDocumenting()
1412 static void to_json(nlohmann::json& j,
const AdvancedTxParams& p)
1416 TOJSON_IMPL(priority),
1417 TOJSON_IMPL(subchannelTag),
1418 TOJSON_IMPL(includeNodeId),
1422 TOJSON_IMPL(audioUri),
1423 TOJSON_IMPL(aliasSpecializer),
1424 TOJSON_IMPL(receiverRxMuteForAliasSpecializer)
1427 static void from_json(
const nlohmann::json& j, AdvancedTxParams& p)
1430 getOptional<uint16_t>(
"flags", p.flags, j, 0);
1431 getOptional<uint8_t>(
"priority", p.priority, j, 0);
1432 getOptional<uint16_t>(
"subchannelTag", p.subchannelTag, j, 0);
1433 getOptional<bool>(
"includeNodeId", p.includeNodeId, j,
false);
1434 getOptional<std::string>(
"alias", p.alias, j, EMPTY_STRING);
1435 getOptional<bool>(
"muted", p.muted, j,
false);
1436 getOptional<uint32_t>(
"txId", p.txId, j, 0);
1437 getOptional<TxAudioUri>(
"audioUri", p.audioUri, j);
1438 getOptional<uint16_t>(
"aliasSpecializer", p.aliasSpecializer, j, 0);
1439 getOptional<bool>(
"receiverRxMuteForAliasSpecializer", p.receiverRxMuteForAliasSpecializer, j,
false);
1443 JSON_SERIALIZED_CLASS(Identity)
1457 IMPLEMENT_JSON_SERIALIZATION()
1458 IMPLEMENT_JSON_DOCUMENTATION(
Identity)
1488 displayName.clear();
1492 virtual void initForDocumenting()
1497 static void to_json(nlohmann::json& j,
const Identity& p)
1500 TOJSON_IMPL(nodeId),
1501 TOJSON_IMPL(userId),
1502 TOJSON_IMPL(displayName),
1506 static void from_json(
const nlohmann::json& j, Identity& p)
1509 getOptional<std::string>(
"nodeId", p.nodeId, j);
1510 getOptional<std::string>(
"userId", p.userId, j);
1511 getOptional<std::string>(
"displayName", p.displayName, j);
1512 getOptional<std::string>(
"avatar", p.avatar, j);
1517 JSON_SERIALIZED_CLASS(Location)
1531 IMPLEMENT_JSON_SERIALIZATION()
1532 IMPLEMENT_JSON_DOCUMENTATION(
Location)
1535 constexpr static double INVALID_LOCATION_VALUE = -999.999;
1563 latitude = INVALID_LOCATION_VALUE;
1564 longitude = INVALID_LOCATION_VALUE;
1565 altitude = INVALID_LOCATION_VALUE;
1566 direction = INVALID_LOCATION_VALUE;
1567 speed = INVALID_LOCATION_VALUE;
1570 virtual void initForDocumenting()
1576 longitude = 456.789;
1583 static void to_json(nlohmann::json& j,
const Location& p)
1585 if(p.latitude != Location::INVALID_LOCATION_VALUE && p.longitude != Location::INVALID_LOCATION_VALUE)
1588 TOJSON_IMPL(latitude),
1589 TOJSON_IMPL(longitude),
1592 if(p.ts != 0) j[
"ts"] = p.ts;
1593 if(p.altitude != Location::INVALID_LOCATION_VALUE) j[
"altitude"] = p.altitude;
1594 if(p.speed != Location::INVALID_LOCATION_VALUE) j[
"speed"] = p.speed;
1595 if(p.direction != Location::INVALID_LOCATION_VALUE) j[
"direction"] = p.direction;
1598 static void from_json(
const nlohmann::json& j, Location& p)
1601 getOptional<uint32_t>(
"ts", p.ts, j, 0);
1602 j.at(
"latitude").get_to(p.latitude);
1603 j.at(
"longitude").get_to(p.longitude);
1604 getOptional<double>(
"altitude", p.altitude, j, Location::INVALID_LOCATION_VALUE);
1605 getOptional<double>(
"direction", p.direction, j, Location::INVALID_LOCATION_VALUE);
1606 getOptional<double>(
"speed", p.speed, j, Location::INVALID_LOCATION_VALUE);
1610 JSON_SERIALIZED_CLASS(Power)
1622 IMPLEMENT_JSON_SERIALIZATION()
1623 IMPLEMENT_JSON_DOCUMENTATION(
Power)
1669 virtual void initForDocumenting()
1674 static void to_json(nlohmann::json& j,
const Power& p)
1676 if(p.source != 0 && p.state != 0 && p.level != 0)
1679 TOJSON_IMPL(source),
1685 static void from_json(
const nlohmann::json& j, Power& p)
1688 getOptional<int>(
"source", p.source, j, 0);
1689 getOptional<int>(
"state", p.state, j, 0);
1690 getOptional<int>(
"level", p.level, j, 0);
1695 JSON_SERIALIZED_CLASS(Connectivity)
1707 IMPLEMENT_JSON_SERIALIZATION()
1744 virtual void initForDocumenting()
1754 static void to_json(nlohmann::json& j,
const Connectivity& p)
1760 TOJSON_IMPL(strength),
1765 static void from_json(
const nlohmann::json& j, Connectivity& p)
1768 getOptional<int>(
"type", p.type, j, 0);
1769 getOptional<int>(
"strength", p.strength, j, 0);
1770 getOptional<int>(
"rating", p.rating, j, 0);
1775 JSON_SERIALIZED_CLASS(PresenceDescriptorGroupItem)
1787 IMPLEMENT_JSON_SERIALIZATION()
1812 virtual void initForDocumenting()
1814 groupId =
"{123-456}";
1820 static void to_json(nlohmann::json& j,
const PresenceDescriptorGroupItem& p)
1823 TOJSON_IMPL(groupId),
1828 static void from_json(
const nlohmann::json& j, PresenceDescriptorGroupItem& p)
1831 getOptional<std::string>(
"groupId", p.groupId, j);
1832 getOptional<std::string>(
"alias", p.alias, j);
1833 getOptional<uint16_t>(
"status", p.status, j);
1838 JSON_SERIALIZED_CLASS(PresenceDescriptor)
1850 IMPLEMENT_JSON_SERIALIZATION()
1928 groupAliases.clear();
1931 announceOnReceive =
false;
1932 connectivity.clear();
1936 virtual void initForDocumenting()
1943 identity.initForDocumenting();
1944 comment =
"This is a comment";
1947 PresenceDescriptorGroupItem gi;
1948 gi.initForDocumenting();
1949 groupAliases.push_back(gi);
1951 location.initForDocumenting();
1953 announceOnReceive =
true;
1954 connectivity.initForDocumenting();
1955 power.initForDocumenting();
1959 static void to_json(nlohmann::json& j,
const PresenceDescriptor& p)
1963 TOJSON_IMPL(nextUpdate),
1964 TOJSON_IMPL(identity),
1965 TOJSON_IMPL(comment),
1966 TOJSON_IMPL(disposition),
1967 TOJSON_IMPL(groupAliases),
1968 TOJSON_IMPL(location),
1969 TOJSON_IMPL(custom),
1970 TOJSON_IMPL(announceOnReceive),
1971 TOJSON_IMPL(connectivity),
1975 if(!p.comment.empty()) j[
"comment"] = p.comment;
1976 if(!p.custom.empty()) j[
"custom"] = p.custom;
1983 static void from_json(
const nlohmann::json& j, PresenceDescriptor& p)
1986 getOptional<bool>(
"self", p.self, j);
1987 getOptional<uint32_t>(
"ts", p.ts, j);
1988 getOptional<uint32_t>(
"nextUpdate", p.nextUpdate, j);
1989 getOptional<Identity>(
"identity", p.identity, j);
1990 getOptional<std::string>(
"comment", p.comment, j);
1991 getOptional<uint32_t>(
"disposition", p.disposition, j);
1992 getOptional<std::vector<PresenceDescriptorGroupItem>>(
"groupAliases", p.groupAliases, j);
1993 getOptional<Location>(
"location", p.location, j);
1994 getOptional<std::string>(
"custom", p.custom, j);
1995 getOptional<bool>(
"announceOnReceive", p.announceOnReceive, j);
1996 getOptional<Connectivity>(
"connectivity", p.connectivity, j);
1997 getOptional<Power>(
"power", p.power, j);
2038 } AddressResolutionPolicy_t;
2041 JSON_SERIALIZED_CLASS(NetworkTxOptions)
2055 IMPLEMENT_JSON_SERIALIZATION()
2080 virtual void initForDocumenting()
2085 static void to_json(nlohmann::json& j,
const NetworkTxOptions& p)
2088 TOJSON_IMPL(priority),
2092 static void from_json(
const nlohmann::json& j, NetworkTxOptions& p)
2095 getOptional<TxPriority_t>(
"priority", p.priority, j, TxPriority_t::priVoice);
2096 getOptional<int>(
"ttl", p.ttl, j, 1);
2101 JSON_SERIALIZED_CLASS(TcpNetworkTxOptions)
2111 IMPLEMENT_JSON_SERIALIZATION()
2126 virtual void initForDocumenting()
2134 TOJSON_IMPL(priority),
2138 static void from_json(
const nlohmann::json& j, TcpNetworkTxOptions& p)
2141 getOptional<TxPriority_t>(
"priority", p.priority, j, TxPriority_t::priVoice);
2142 getOptional<int>(
"ttl", p.ttl, j, -1);
2158 JSON_SERIALIZED_CLASS(NetworkAddress)
2171 IMPLEMENT_JSON_SERIALIZATION()
2192 bool matches(
const NetworkAddress& other)
2194 if(address.compare(other.address) != 0)
2199 if(port != other.port)
2208 static void to_json(nlohmann::json& j,
const NetworkAddress& p)
2211 TOJSON_IMPL(address),
2215 static void from_json(
const nlohmann::json& j, NetworkAddress& p)
2218 getOptional<std::string>(
"address", p.address, j);
2219 getOptional<int>(
"port", p.port, j);
2224 JSON_SERIALIZED_CLASS(NetworkAddressRxTx)
2237 IMPLEMENT_JSON_SERIALIZATION()
2259 static void to_json(nlohmann::json& j,
const NetworkAddressRxTx& p)
2266 static void from_json(
const nlohmann::json& j, NetworkAddressRxTx& p)
2269 getOptional<NetworkAddress>(
"rx", p.rx, j);
2270 getOptional<NetworkAddress>(
"tx", p.tx, j);
2281 } GroupRestrictionAccessPolicyType_t;
2283 static bool isValidGroupRestrictionAccessPolicyType(GroupRestrictionAccessPolicyType_t t)
2285 return (t == GroupRestrictionAccessPolicyType_t::graptPermissive ||
2286 t == GroupRestrictionAccessPolicyType_t::graptStrict );
2300 } RestrictionType_t;
2302 static bool isValidRestrictionType(RestrictionType_t t)
2304 return (t == RestrictionType_t::rtUndefined ||
2305 t == RestrictionType_t::rtWhitelist ||
2306 t == RestrictionType_t::rtBlacklist );
2332 } RestrictionElementType_t;
2334 static bool isValidRestrictionElementType(RestrictionElementType_t t)
2336 return (t == RestrictionElementType_t::retGroupId ||
2337 t == RestrictionElementType_t::retGroupIdPattern ||
2338 t == RestrictionElementType_t::retGenericAccessTagPattern ||
2339 t == RestrictionElementType_t::retCertificateSerialNumberPattern ||
2340 t == RestrictionElementType_t::retCertificateFingerprintPattern ||
2341 t == RestrictionElementType_t::retCertificateSubjectPattern ||
2342 t == RestrictionElementType_t::retCertificateIssuerPattern);
2347 JSON_SERIALIZED_CLASS(NetworkAddressRestrictionList)
2360 IMPLEMENT_JSON_SERIALIZATION()
2377 type = RestrictionType_t::rtUndefined;
2382 static void to_json(nlohmann::json& j,
const NetworkAddressRestrictionList& p)
2386 TOJSON_IMPL(elements)
2389 static void from_json(
const nlohmann::json& j, NetworkAddressRestrictionList& p)
2392 getOptional<RestrictionType_t>(
"type", p.type, j, RestrictionType_t::rtUndefined);
2393 getOptional<std::vector<NetworkAddressRxTx>>(
"elements", p.elements, j);
2397 JSON_SERIALIZED_CLASS(StringRestrictionList)
2410 IMPLEMENT_JSON_SERIALIZATION()
2425 type = RestrictionType_t::rtUndefined;
2426 elementsType = RestrictionElementType_t::retGroupId;
2436 static void to_json(nlohmann::json& j,
const StringRestrictionList& p)
2440 TOJSON_IMPL(elementsType),
2441 TOJSON_IMPL(elements)
2444 static void from_json(
const nlohmann::json& j, StringRestrictionList& p)
2447 getOptional<RestrictionType_t>(
"type", p.type, j, RestrictionType_t::rtUndefined);
2448 getOptional<RestrictionElementType_t>(
"elementsType", p.elementsType, j, RestrictionElementType_t::retGroupId);
2449 getOptional<std::vector<std::string>>(
"elements", p.elements, j);
2454 JSON_SERIALIZED_CLASS(PacketCapturer)
2465 IMPLEMENT_JSON_SERIALIZATION()
2471 std::string filePrefix;
2489 TOJSON_IMPL(enabled),
2491 TOJSON_IMPL(filePrefix)
2494 static void from_json(
const nlohmann::json& j, PacketCapturer& p)
2497 getOptional<bool>(
"enabled", p.enabled, j,
false);
2498 getOptional<uint32_t>(
"maxMb", p.maxMb, j, 10);
2499 getOptional<std::string>(
"filePrefix", p.filePrefix, j, EMPTY_STRING);
2504 JSON_SERIALIZED_CLASS(TransportImpairment)
2515 IMPLEMENT_JSON_SERIALIZATION()
2519 int applicationPercentage;
2530 applicationPercentage = 0;
2539 TOJSON_IMPL(applicationPercentage),
2540 TOJSON_IMPL(jitterMs),
2541 TOJSON_IMPL(lossPercentage)
2544 static void from_json(
const nlohmann::json& j, TransportImpairment& p)
2547 getOptional<int>(
"applicationPercentage", p.applicationPercentage, j, 0);
2548 getOptional<int>(
"jitterMs", p.jitterMs, j, 0);
2549 getOptional<int>(
"lossPercentage", p.lossPercentage, j, 0);
2553 JSON_SERIALIZED_CLASS(NsmNetworking)
2564 IMPLEMENT_JSON_SERIALIZATION()
2568 std::string interfaceName;
2575 std::string cryptoPassword;
2584 interfaceName.clear();
2589 rxImpairment.clear();
2590 txImpairment.clear();
2591 cryptoPassword.clear();
2595 static void to_json(nlohmann::json& j,
const NsmNetworking& p)
2598 TOJSON_IMPL(interfaceName),
2599 TOJSON_IMPL(address),
2602 TOJSON_IMPL(txOversend),
2603 TOJSON_IMPL(rxImpairment),
2604 TOJSON_IMPL(txImpairment),
2605 TOJSON_IMPL(cryptoPassword)
2608 static void from_json(
const nlohmann::json& j, NsmNetworking& p)
2611 getOptional(
"interfaceName", p.interfaceName, j, EMPTY_STRING);
2612 getOptional<NetworkAddress>(
"address", p.address, j);
2613 getOptional<int>(
"ttl", p.ttl, j, 1);
2614 getOptional<int>(
"tos", p.tos, j, 56);
2615 getOptional<int>(
"txOversend", p.txOversend, j, 0);
2616 getOptional<TransportImpairment>(
"rxImpairment", p.rxImpairment, j);
2617 getOptional<TransportImpairment>(
"txImpairment", p.txImpairment, j);
2618 getOptional(
"cryptoPassword", p.cryptoPassword, j, EMPTY_STRING);
2623 JSON_SERIALIZED_CLASS(NsmConfiguration)
2634 IMPLEMENT_JSON_SERIALIZATION()
2642 std::vector<std::string> resources;
2646 int transitionSecsFactor;
2656 favorUptime =
false;
2659 tokenStart = 1000000;
2662 transitionSecsFactor = 3;
2670 TOJSON_IMPL(favorUptime),
2671 TOJSON_IMPL(networking),
2672 TOJSON_IMPL(resources),
2673 TOJSON_IMPL(tokenStart),
2674 TOJSON_IMPL(tokenEnd),
2675 TOJSON_IMPL(intervalSecs),
2676 TOJSON_IMPL(transitionSecsFactor)
2679 static void from_json(
const nlohmann::json& j, NsmConfiguration& p)
2682 getOptional(
"id", p.id, j);
2683 getOptional<bool>(
"favorUptime", p.favorUptime, j,
false);
2684 getOptional<NsmNetworking>(
"networking", p.networking, j);
2685 getOptional<std::vector<std::string>>(
"resources", p.resources, j);
2686 getOptional<int>(
"tokenStart", p.tokenStart, j, 1000000);
2687 getOptional<int>(
"tokenEnd", p.tokenEnd, j, 2000000);
2688 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 1);
2689 getOptional<int>(
"transitionSecsFactor", p.transitionSecsFactor, j, 3);
2694 JSON_SERIALIZED_CLASS(Rallypoint)
2704 IMPLEMENT_JSON_SERIALIZATION()
2780 certificate.clear();
2781 certificateKey.clear();
2782 caCertificates.clear();
2784 transactionTimeoutMs = 5000;
2785 disableMessageSigning =
false;
2786 connectionTimeoutSecs = 5;
2787 tcpTxOptions.clear();
2790 bool matches(
const Rallypoint& other)
2792 if(!host.matches(other.host))
2797 if(certificate.compare(other.certificate) != 0)
2802 if(certificateKey.compare(other.certificateKey) != 0)
2807 if(verifyPeer != other.verifyPeer)
2812 if(allowSelfSignedCertificate != other.allowSelfSignedCertificate)
2817 if(caCertificates.size() != other.caCertificates.size())
2822 for(
size_t x = 0; x < caCertificates.size(); x++)
2826 for(
size_t y = 0; y < other.caCertificates.size(); y++)
2828 if(caCertificates[x].compare(other.caCertificates[y]) == 0)
2841 if(transactionTimeoutMs != other.transactionTimeoutMs)
2846 if(disableMessageSigning != other.disableMessageSigning)
2855 static void to_json(nlohmann::json& j,
const Rallypoint& p)
2859 TOJSON_IMPL(certificate),
2860 TOJSON_IMPL(certificateKey),
2861 TOJSON_IMPL(verifyPeer),
2862 TOJSON_IMPL(allowSelfSignedCertificate),
2863 TOJSON_IMPL(caCertificates),
2864 TOJSON_IMPL(transactionTimeoutMs),
2865 TOJSON_IMPL(disableMessageSigning),
2866 TOJSON_IMPL(connectionTimeoutSecs),
2867 TOJSON_IMPL(tcpTxOptions)
2871 static void from_json(
const nlohmann::json& j, Rallypoint& p)
2874 j.at(
"host").get_to(p.host);
2875 getOptional(
"certificate", p.certificate, j);
2876 getOptional(
"certificateKey", p.certificateKey, j);
2877 getOptional<bool>(
"verifyPeer", p.verifyPeer, j,
true);
2878 getOptional<bool>(
"allowSelfSignedCertificate", p.allowSelfSignedCertificate, j,
false);
2879 getOptional<std::vector<std::string>>(
"caCertificates", p.caCertificates, j);
2880 getOptional<int>(
"transactionTimeoutMs", p.transactionTimeoutMs, j, 5000);
2881 getOptional<bool>(
"disableMessageSigning", p.disableMessageSigning, j,
false);
2882 getOptional<int>(
"connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5);
2883 getOptional<TcpNetworkTxOptions>(
"tcpTxOptions", p.tcpTxOptions, j);
2887 JSON_SERIALIZED_CLASS(RallypointCluster)
2900 IMPLEMENT_JSON_SERIALIZATION()
2916 } ConnectionStrategy_t;
2937 connectionStrategy = csRoundRobin;
2938 rallypoints.clear();
2940 connectionTimeoutSecs = 5;
2944 static void to_json(nlohmann::json& j,
const RallypointCluster& p)
2947 TOJSON_IMPL(connectionStrategy),
2948 TOJSON_IMPL(rallypoints),
2949 TOJSON_IMPL(rolloverSecs),
2950 TOJSON_IMPL(connectionTimeoutSecs)
2953 static void from_json(
const nlohmann::json& j, RallypointCluster& p)
2956 getOptional<RallypointCluster::ConnectionStrategy_t>(
"connectionStrategy", p.connectionStrategy, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
2957 getOptional<std::vector<Rallypoint>>(
"rallypoints", p.rallypoints, j);
2958 getOptional<int>(
"rolloverSecs", p.rolloverSecs, j, 10);
2959 getOptional<int>(
"connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5);
2964 JSON_SERIALIZED_CLASS(NetworkDeviceDescriptor)
2976 IMPLEMENT_JSON_SERIALIZATION()
3017 manufacturer.clear();
3020 serialNumber.clear();
3025 virtual std::string toString()
3029 snprintf(buff,
sizeof(buff),
"deviceId=%d, name=%s, manufacturer=%s, model=%s, hardwareId=%s, serialNumber=%s, type=%s, extra=%s",
3032 manufacturer.c_str(),
3035 serialNumber.c_str(),
3039 return std::string(buff);
3043 static void to_json(nlohmann::json& j,
const NetworkDeviceDescriptor& p)
3046 TOJSON_IMPL(deviceId),
3048 TOJSON_IMPL(manufacturer),
3050 TOJSON_IMPL(hardwareId),
3051 TOJSON_IMPL(serialNumber),
3056 static void from_json(
const nlohmann::json& j, NetworkDeviceDescriptor& p)
3059 getOptional<int>(
"deviceId", p.deviceId, j, 0);
3060 getOptional(
"name", p.name, j);
3061 getOptional(
"manufacturer", p.manufacturer, j);
3062 getOptional(
"model", p.model, j);
3063 getOptional(
"hardwareId", p.hardwareId, j);
3064 getOptional(
"serialNumber", p.serialNumber, j);
3065 getOptional(
"type", p.type, j);
3066 getOptional(
"extra", p.extra, j);
3070 JSON_SERIALIZED_CLASS(AudioGate)
3081 IMPLEMENT_JSON_SERIALIZATION()
3120 static void to_json(nlohmann::json& j,
const AudioGate& p)
3123 TOJSON_IMPL(enabled),
3124 TOJSON_IMPL(useVad),
3125 TOJSON_IMPL(hangMs),
3126 TOJSON_IMPL(windowMin),
3127 TOJSON_IMPL(windowMax),
3128 TOJSON_IMPL(coefficient)
3131 static void from_json(
const nlohmann::json& j, AudioGate& p)
3134 getOptional<bool>(
"enabled", p.enabled, j,
false);
3135 getOptional<bool>(
"useVad", p.useVad, j,
false);
3136 getOptional<uint32_t>(
"hangMs", p.hangMs, j, 1500);
3137 getOptional<uint32_t>(
"windowMin", p.windowMin, j, 25);
3138 getOptional<uint32_t>(
"windowMax", p.windowMax, j, 125);
3139 getOptional<double>(
"coefficient", p.coefficient, j, 1.75);
3143 JSON_SERIALIZED_CLASS(TxAudio)
3158 IMPLEMENT_JSON_SERIALIZATION()
3159 IMPLEMENT_JSON_DOCUMENTATION(
TxAudio)
3395 encoder = TxAudio::TxCodec_t::ctUnknown;
3396 encoderName.clear();
3402 extensionSendInterval = 10;
3403 initialHeaderBurst = 5;
3404 trailingHeaderBurst = 5;
3405 startTxNotifications = 5;
3406 customRtpPayloadType = -1;
3408 resetRtpOnTx =
true;
3409 enableSmoothing =
true;
3411 smoothedHangTimeMs = 0;
3415 static void to_json(nlohmann::json& j,
const TxAudio& p)
3418 TOJSON_IMPL(enabled),
3419 TOJSON_IMPL(encoder),
3420 TOJSON_IMPL(encoderName),
3421 TOJSON_IMPL(framingMs),
3422 TOJSON_IMPL(blockCount),
3424 TOJSON_IMPL(noHdrExt),
3425 TOJSON_IMPL(maxTxSecs),
3426 TOJSON_IMPL(extensionSendInterval),
3427 TOJSON_IMPL(initialHeaderBurst),
3428 TOJSON_IMPL(trailingHeaderBurst),
3429 TOJSON_IMPL(startTxNotifications),
3430 TOJSON_IMPL(customRtpPayloadType),
3431 TOJSON_IMPL(resetRtpOnTx),
3432 TOJSON_IMPL(enableSmoothing),
3434 TOJSON_IMPL(smoothedHangTimeMs)
3439 static void from_json(
const nlohmann::json& j, TxAudio& p)
3442 getOptional<bool>(
"enabled", p.enabled, j,
true);
3443 getOptional<TxAudio::TxCodec_t>(
"encoder", p.encoder, j, TxAudio::TxCodec_t::ctOpus8000);
3444 getOptional<std::string>(
"encoderName", p.encoderName, j, EMPTY_STRING);
3445 getOptional(
"framingMs", p.framingMs, j, 60);
3446 getOptional(
"blockCount", p.blockCount, j, 0);
3447 getOptional(
"fdx", p.fdx, j,
false);
3448 getOptional(
"noHdrExt", p.noHdrExt, j,
false);
3449 getOptional(
"maxTxSecs", p.maxTxSecs, j, 0);
3450 getOptional(
"extensionSendInterval", p.extensionSendInterval, j, 10);
3451 getOptional(
"initialHeaderBurst", p.initialHeaderBurst, j, 5);
3452 getOptional(
"trailingHeaderBurst", p.trailingHeaderBurst, j, 5);
3453 getOptional(
"startTxNotifications", p.startTxNotifications, j, 5);
3454 getOptional(
"customRtpPayloadType", p.customRtpPayloadType, j, -1);
3455 getOptional(
"resetRtpOnTx", p.resetRtpOnTx, j,
true);
3456 getOptional(
"enableSmoothing", p.enableSmoothing, j,
true);
3457 getOptional(
"dtx", p.dtx, j,
false);
3458 getOptional(
"smoothedHangTimeMs", p.smoothedHangTimeMs, j, 0);
3464 JSON_SERIALIZED_CLASS(AudioDeviceDescriptor)
3476 IMPLEMENT_JSON_SERIALIZATION()
3570 direction = dirUnknown;
3571 boostPercentage = 0;
3576 manufacturer.clear();
3579 serialNumber.clear();
3585 virtual std::string toString()
3589 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",
3597 manufacturer.c_str(),
3600 serialNumber.c_str(),
3606 return std::string(buff);
3610 static void to_json(nlohmann::json& j,
const AudioDeviceDescriptor& p)
3613 TOJSON_IMPL(deviceId),
3614 TOJSON_IMPL(samplingRate),
3615 TOJSON_IMPL(channels),
3616 TOJSON_IMPL(direction),
3617 TOJSON_IMPL(boostPercentage),
3618 TOJSON_IMPL(isAdad),
3620 TOJSON_IMPL(manufacturer),
3622 TOJSON_IMPL(hardwareId),
3623 TOJSON_IMPL(serialNumber),
3624 TOJSON_IMPL(isDefault),
3627 TOJSON_IMPL(isPresent)
3630 static void from_json(
const nlohmann::json& j, AudioDeviceDescriptor& p)
3633 getOptional<int>(
"deviceId", p.deviceId, j, 0);
3634 getOptional<int>(
"samplingRate", p.samplingRate, j, 0);
3635 getOptional<int>(
"channels", p.channels, j, 0);
3636 getOptional<AudioDeviceDescriptor::Direction_t>(
"direction", p.direction, j,
3637 AudioDeviceDescriptor::Direction_t::dirUnknown);
3638 getOptional<int>(
"boostPercentage", p.boostPercentage, j, 0);
3640 getOptional<bool>(
"isAdad", p.isAdad, j,
false);
3641 getOptional(
"name", p.name, j);
3642 getOptional(
"manufacturer", p.manufacturer, j);
3643 getOptional(
"model", p.model, j);
3644 getOptional(
"hardwareId", p.hardwareId, j);
3645 getOptional(
"serialNumber", p.serialNumber, j);
3646 getOptional(
"isDefault", p.isDefault, j);
3647 getOptional(
"type", p.type, j);
3648 getOptional(
"extra", p.extra, j);
3649 getOptional<bool>(
"isPresent", p.isPresent, j,
false);
3653 JSON_SERIALIZED_CLASS(ListOfAudioDeviceDescriptor)
3656 IMPLEMENT_JSON_SERIALIZATION()
3660 std::vector<AudioDeviceDescriptor> list;
3679 static void from_json(
const nlohmann::json& j, ListOfAudioDeviceDescriptor& p)
3682 getOptional<std::vector<AudioDeviceDescriptor>>(
"list", p.list, j);
3686 JSON_SERIALIZED_CLASS(Audio)
3696 IMPLEMENT_JSON_SERIALIZATION()
3697 IMPLEMENT_JSON_DOCUMENTATION(
Audio)
3736 outputLevelLeft = 100;
3737 outputLevelRight = 100;
3738 outputMuted =
false;
3742 static void to_json(nlohmann::json& j,
const Audio& p)
3745 TOJSON_IMPL(enabled),
3746 TOJSON_IMPL(inputId),
3747 TOJSON_IMPL(inputGain),
3748 TOJSON_IMPL(outputId),
3749 TOJSON_IMPL(outputLevelLeft),
3750 TOJSON_IMPL(outputLevelRight),
3751 TOJSON_IMPL(outputMuted)
3754 static void from_json(
const nlohmann::json& j, Audio& p)
3757 getOptional<bool>(
"enabled", p.enabled, j,
true);
3758 getOptional<int>(
"inputId", p.inputId, j, 0);
3759 getOptional<int>(
"inputGain", p.inputGain, j, 0);
3760 getOptional<int>(
"outputId", p.outputId, j, 0);
3761 getOptional<int>(
"outputGain", p.outputGain, j, 0);
3762 getOptional<int>(
"outputLevelLeft", p.outputLevelLeft, j, 100);
3763 getOptional<int>(
"outputLevelRight", p.outputLevelRight, j, 100);
3764 getOptional<bool>(
"outputMuted", p.outputMuted, j,
false);
3768 JSON_SERIALIZED_CLASS(TalkerInformation)
3780 IMPLEMENT_JSON_SERIALIZATION()
3796 matSsrcGenerated = 2
3797 } ManufacturedAliasType_t;
3842 aliasSpecializer = 0;
3844 manufacturedAliasType = ManufacturedAliasType_t::matNone;
3849 static void to_json(nlohmann::json& j,
const TalkerInformation& p)
3853 TOJSON_IMPL(nodeId),
3854 TOJSON_IMPL(rxFlags),
3855 TOJSON_IMPL(txPriority),
3857 TOJSON_IMPL(duplicateCount),
3858 TOJSON_IMPL(aliasSpecializer),
3859 TOJSON_IMPL(rxMuted),
3860 TOJSON_IMPL(manufacturedAliasType),
3864 static void from_json(
const nlohmann::json& j, TalkerInformation& p)
3867 getOptional<std::string>(
"alias", p.alias, j, EMPTY_STRING);
3868 getOptional<std::string>(
"nodeId", p.nodeId, j, EMPTY_STRING);
3869 getOptional<uint16_t>(
"rxFlags", p.rxFlags, j, 0);
3870 getOptional<int>(
"txPriority", p.txPriority, j, 0);
3871 getOptional<uint32_t>(
"txId", p.txId, j, 0);
3872 getOptional<int>(
"duplicateCount", p.duplicateCount, j, 0);
3873 getOptional<uint16_t>(
"aliasSpecializer", p.aliasSpecializer, j, 0);
3874 getOptional<bool>(
"rxMuted", p.rxMuted, j,
false);
3875 getOptional<TalkerInformation::ManufacturedAliasType_t>(
"manufacturedAliasType", p.manufacturedAliasType, j, TalkerInformation::ManufacturedAliasType_t::matNone);
3876 getOptional<uint32_t>(
"ssrc", p.ssrc, j, 0);
3880 JSON_SERIALIZED_CLASS(GroupTalkers)
3894 IMPLEMENT_JSON_SERIALIZATION()
3899 std::vector<TalkerInformation>
list;
3912 static void to_json(nlohmann::json& j,
const GroupTalkers& p)
3918 static void from_json(
const nlohmann::json& j, GroupTalkers& p)
3921 getOptional<std::vector<TalkerInformation>>(
"list", p.list, j);
3925 JSON_SERIALIZED_CLASS(Presence)
3937 IMPLEMENT_JSON_SERIALIZATION()
3938 IMPLEMENT_JSON_DOCUMENTATION(
Presence)
3983 minIntervalSecs = 5;
3987 static void to_json(nlohmann::json& j,
const Presence& p)
3990 TOJSON_IMPL(format),
3991 TOJSON_IMPL(intervalSecs),
3992 TOJSON_IMPL(listenOnly),
3993 TOJSON_IMPL(minIntervalSecs)
3996 static void from_json(
const nlohmann::json& j, Presence& p)
3999 getOptional<Presence::Format_t>(
"format", p.format, j, Presence::Format_t::pfEngage);
4000 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 30);
4001 getOptional<bool>(
"listenOnly", p.listenOnly, j,
false);
4002 getOptional<int>(
"minIntervalSecs", p.minIntervalSecs, j, 5);
4007 JSON_SERIALIZED_CLASS(Advertising)
4019 IMPLEMENT_JSON_SERIALIZATION()
4041 alwaysAdvertise =
false;
4045 static void to_json(nlohmann::json& j,
const Advertising& p)
4048 TOJSON_IMPL(enabled),
4049 TOJSON_IMPL(intervalMs),
4050 TOJSON_IMPL(alwaysAdvertise)
4053 static void from_json(
const nlohmann::json& j, Advertising& p)
4056 getOptional(
"enabled", p.enabled, j,
false);
4057 getOptional<int>(
"intervalMs", p.intervalMs, j, 20000);
4058 getOptional<bool>(
"alwaysAdvertise", p.alwaysAdvertise, j,
false);
4062 JSON_SERIALIZED_CLASS(GroupPriorityTranslation)
4074 IMPLEMENT_JSON_SERIALIZATION()
4100 static void to_json(nlohmann::json& j,
const GroupPriorityTranslation& p)
4105 TOJSON_IMPL(priority)
4108 static void from_json(
const nlohmann::json& j, GroupPriorityTranslation& p)
4111 j.at(
"rx").get_to(p.rx);
4112 j.at(
"tx").get_to(p.tx);
4113 FROMJSON_IMPL(priority,
int, 0);
4117 JSON_SERIALIZED_CLASS(GroupTimeline)
4131 IMPLEMENT_JSON_SERIALIZATION()
4150 maxAudioTimeMs = 30000;
4155 static void to_json(nlohmann::json& j,
const GroupTimeline& p)
4158 TOJSON_IMPL(enabled),
4159 TOJSON_IMPL(maxAudioTimeMs),
4160 TOJSON_IMPL(recordAudio)
4163 static void from_json(
const nlohmann::json& j, GroupTimeline& p)
4166 getOptional(
"enabled", p.enabled, j,
true);
4167 getOptional<int>(
"maxAudioTimeMs", p.maxAudioTimeMs, j, 30000);
4168 getOptional(
"recordAudio", p.recordAudio, j,
true);
4271 IMPLEMENT_JSON_SERIALIZATION()
4293 static void to_json(nlohmann::json& j,
const GroupAppTransport& p)
4296 TOJSON_IMPL(enabled),
4300 static void from_json(
const nlohmann::json& j, GroupAppTransport& p)
4303 getOptional<bool>(
"enabled", p.enabled, j,
false);
4304 getOptional<std::string>(
"id", p.id, j);
4308 JSON_SERIALIZED_CLASS(RtpProfile)
4320 IMPLEMENT_JSON_SERIALIZATION()
4338 jmReleaseOnTxEnd = 2
4401 jitterMaxMs = 10000;
4403 jitterMaxFactor = 8;
4404 jitterTrimPercentage = 10;
4405 jitterUnderrunReductionThresholdMs = 1500;
4406 jitterUnderrunReductionAger = 100;
4407 latePacketSequenceRange = 5;
4408 latePacketTimestampRangeMs = 2000;
4409 inboundProcessorInactivityMs = 500;
4410 jitterForceTrimAtMs = 0;
4411 rtcpPresenceTimeoutMs = 45000;
4412 jitterMaxExceededClipPerc = 10;
4413 jitterMaxExceededClipHangMs = 1500;
4414 zombieLifetimeMs = 15000;
4415 jitterMaxTrimMs = 250;
4416 signalledInboundProcessorInactivityMs = (inboundProcessorInactivityMs * 4);
4420 static void to_json(nlohmann::json& j,
const RtpProfile& p)
4424 TOJSON_IMPL(jitterMaxMs),
4425 TOJSON_IMPL(inboundProcessorInactivityMs),
4426 TOJSON_IMPL(jitterMinMs),
4427 TOJSON_IMPL(jitterMaxFactor),
4428 TOJSON_IMPL(jitterTrimPercentage),
4429 TOJSON_IMPL(jitterUnderrunReductionThresholdMs),
4430 TOJSON_IMPL(jitterUnderrunReductionAger),
4431 TOJSON_IMPL(latePacketSequenceRange),
4432 TOJSON_IMPL(latePacketTimestampRangeMs),
4433 TOJSON_IMPL(inboundProcessorInactivityMs),
4434 TOJSON_IMPL(jitterForceTrimAtMs),
4435 TOJSON_IMPL(jitterMaxExceededClipPerc),
4436 TOJSON_IMPL(jitterMaxExceededClipHangMs),
4437 TOJSON_IMPL(zombieLifetimeMs),
4438 TOJSON_IMPL(jitterMaxTrimMs),
4439 TOJSON_IMPL(signalledInboundProcessorInactivityMs)
4442 static void from_json(
const nlohmann::json& j, RtpProfile& p)
4445 FROMJSON_IMPL(mode, RtpProfile::JitterMode_t, RtpProfile::JitterMode_t::jmStandard);
4446 FROMJSON_IMPL(jitterMaxMs,
int, 10000);
4447 FROMJSON_IMPL(jitterMinMs,
int, 20);
4448 FROMJSON_IMPL(jitterMaxFactor,
int, 8);
4449 FROMJSON_IMPL(jitterTrimPercentage,
int, 10);
4450 FROMJSON_IMPL(jitterUnderrunReductionThresholdMs,
int, 1500);
4451 FROMJSON_IMPL(jitterUnderrunReductionAger,
int, 100);
4452 FROMJSON_IMPL(latePacketSequenceRange,
int, 5);
4453 FROMJSON_IMPL(latePacketTimestampRangeMs,
int, 2000);
4454 FROMJSON_IMPL(inboundProcessorInactivityMs,
int, 500);
4455 FROMJSON_IMPL(jitterForceTrimAtMs,
int, 0);
4456 FROMJSON_IMPL(rtcpPresenceTimeoutMs,
int, 45000);
4457 FROMJSON_IMPL(jitterMaxExceededClipPerc,
int, 10);
4458 FROMJSON_IMPL(jitterMaxExceededClipHangMs,
int, 1500);
4459 FROMJSON_IMPL(zombieLifetimeMs,
int, 15000);
4460 FROMJSON_IMPL(jitterMaxTrimMs,
int, 250);
4461 FROMJSON_IMPL(signalledInboundProcessorInactivityMs,
int, (p.inboundProcessorInactivityMs * 4));
4465 JSON_SERIALIZED_CLASS(Tls)
4477 IMPLEMENT_JSON_SERIALIZATION()
4478 IMPLEMENT_JSON_DOCUMENTATION(
Tls)
4508 allowSelfSignedCertificates =
false;
4509 caCertificates.clear();
4510 subjectRestrictions.clear();
4511 issuerRestrictions.clear();
4516 static void to_json(nlohmann::json& j,
const Tls& p)
4519 TOJSON_IMPL(verifyPeers),
4520 TOJSON_IMPL(allowSelfSignedCertificates),
4521 TOJSON_IMPL(caCertificates),
4522 TOJSON_IMPL(subjectRestrictions),
4523 TOJSON_IMPL(issuerRestrictions),
4524 TOJSON_IMPL(crlSerials)
4527 static void from_json(
const nlohmann::json& j, Tls& p)
4530 getOptional<bool>(
"verifyPeers", p.verifyPeers, j,
true);
4531 getOptional<bool>(
"allowSelfSignedCertificates", p.allowSelfSignedCertificates, j,
false);
4532 getOptional<std::vector<std::string>>(
"caCertificates", p.caCertificates, j);
4533 getOptional<StringRestrictionList>(
"subjectRestrictions", p.subjectRestrictions, j);
4534 getOptional<StringRestrictionList>(
"issuerRestrictions", p.issuerRestrictions, j);
4535 getOptional<std::vector<std::string>>(
"crlSerials", p.crlSerials, j);
4539 JSON_SERIALIZED_CLASS(RangerPackets)
4553 IMPLEMENT_JSON_SERIALIZATION()
4574 virtual void initForDocumenting()
4579 static void to_json(nlohmann::json& j,
const RangerPackets& p)
4582 TOJSON_IMPL(hangTimerSecs),
4586 static void from_json(
const nlohmann::json& j, RangerPackets& p)
4589 getOptional<int>(
"hangTimerSecs", p.hangTimerSecs, j, 11);
4590 getOptional<int>(
"count", p.count, j, 5);
4594 JSON_SERIALIZED_CLASS(Source)
4608 IMPLEMENT_JSON_SERIALIZATION()
4609 IMPLEMENT_JSON_DOCUMENTATION(
Source)
4616 uint8_t _internal_binary_nodeId[ENGAGE_MAX_NODE_ID_SIZE];
4622 uint8_t _internal_binary_alias[ENGAGE_MAX_ALIAS_SIZE];
4632 memset(_internal_binary_nodeId, 0,
sizeof(_internal_binary_nodeId));
4635 memset(_internal_binary_alias, 0,
sizeof(_internal_binary_alias));
4638 virtual void initForDocumenting()
4643 static void to_json(nlohmann::json& j,
const Source& p)
4646 TOJSON_IMPL(nodeId),
4650 static void from_json(
const nlohmann::json& j, Source& p)
4653 FROMJSON_IMPL_SIMPLE(nodeId);
4654 FROMJSON_IMPL_SIMPLE(alias);
4658 JSON_SERIALIZED_CLASS(Group)
4671 IMPLEMENT_JSON_SERIALIZATION()
4672 IMPLEMENT_JSON_DOCUMENTATION(
Group)
4699 bomPayloadTransformation = 1,
4702 bomAnonymousMixing = 2,
4705 bomLanguageTranslation = 3
4712 iagpAnonymousAlias = 0,
4716 } InboundAliasGenerationPolicy_t;
4892 interfaceName.clear();
4898 cryptoPassword.clear();
4902 rallypoints.clear();
4903 rallypointCluster.clear();
4908 blockAdvertising =
false;
4914 enableMulticastFailover =
false;
4915 multicastFailoverSecs = 10;
4917 rtcpPresenceRx.clear();
4919 presenceGroupAffinities.clear();
4920 disablePacketEvents =
false;
4922 rfc4733RtpPayloadId = 0;
4923 inboundRtpPayloadTypeTranslations.clear();
4924 priorityTranslation.clear();
4926 stickyTidHangSecs = 10;
4927 anonymousAlias.clear();
4930 appTransport.clear();
4931 allowLoopback =
false;
4934 rangerPackets.clear();
4936 _wasDeserialized_rtpProfile =
false;
4938 txImpairment.clear();
4939 rxImpairment.clear();
4941 specializerAffinities.clear();
4945 ignoreSources.clear();
4947 languageCode.clear();
4954 inboundAliasGenerationPolicy = iagpAnonymousAlias;
4957 ignoreAudioTraffic =
false;
4961 static void to_json(nlohmann::json& j,
const Group& p)
4968 TOJSON_IMPL(spokenName),
4969 TOJSON_IMPL(interfaceName),
4972 TOJSON_IMPL(txOptions),
4973 TOJSON_IMPL(txAudio),
4974 TOJSON_IMPL(presence),
4975 TOJSON_IMPL(cryptoPassword),
4984 TOJSON_IMPL(timeline),
4985 TOJSON_IMPL(blockAdvertising),
4986 TOJSON_IMPL(source),
4987 TOJSON_IMPL(maxRxSecs),
4988 TOJSON_IMPL(enableMulticastFailover),
4989 TOJSON_IMPL(multicastFailoverSecs),
4990 TOJSON_IMPL(rtcpPresenceRx),
4991 TOJSON_IMPL(presenceGroupAffinities),
4992 TOJSON_IMPL(disablePacketEvents),
4993 TOJSON_IMPL(rfc4733RtpPayloadId),
4994 TOJSON_IMPL(inboundRtpPayloadTypeTranslations),
4995 TOJSON_IMPL(priorityTranslation),
4996 TOJSON_IMPL(stickyTidHangSecs),
4997 TOJSON_IMPL(anonymousAlias),
4998 TOJSON_IMPL(lbCrypto),
4999 TOJSON_IMPL(appTransport),
5000 TOJSON_IMPL(allowLoopback),
5001 TOJSON_IMPL(rangerPackets),
5003 TOJSON_IMPL(txImpairment),
5004 TOJSON_IMPL(rxImpairment),
5006 TOJSON_IMPL(specializerAffinities),
5008 TOJSON_IMPL(securityLevel),
5010 TOJSON_IMPL(ignoreSources),
5012 TOJSON_IMPL(languageCode),
5013 TOJSON_IMPL(synVoice),
5015 TOJSON_IMPL(rxCapture),
5016 TOJSON_IMPL(txCapture),
5018 TOJSON_IMPL(blobRtpPayloadType),
5020 TOJSON_IMPL(inboundAliasGenerationPolicy),
5022 TOJSON_IMPL(gateIn),
5024 TOJSON_IMPL(ignoreAudioTraffic)
5030 if(p._wasDeserialized_rtpProfile || p.isDocumenting())
5032 j[
"rtpProfile"] = p.rtpProfile;
5035 if(p.isDocumenting())
5037 j[
"rallypointCluster"] = p.rallypointCluster;
5038 j[
"rallypoints"] = p.rallypoints;
5043 if(!p.rallypointCluster.rallypoints.empty())
5045 j[
"rallypointCluster"] = p.rallypointCluster;
5047 else if(!p.rallypoints.empty())
5049 j[
"rallypoints"] = p.rallypoints;
5053 static void from_json(
const nlohmann::json& j, Group& p)
5056 j.at(
"type").get_to(p.type);
5057 getOptional<Group::BridgingOpMode_t>(
"bom", p.bom, j, Group::BridgingOpMode_t::bomRaw);
5058 j.at(
"id").get_to(p.id);
5059 getOptional<std::string>(
"name", p.name, j);
5060 getOptional<std::string>(
"spokenName", p.spokenName, j);
5061 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
5062 getOptional<NetworkAddress>(
"rx", p.rx, j);
5063 getOptional<NetworkAddress>(
"tx", p.tx, j);
5064 getOptional<NetworkTxOptions>(
"txOptions", p.txOptions, j);
5065 getOptional<std::string>(
"cryptoPassword", p.cryptoPassword, j);
5066 getOptional<std::string>(
"alias", p.alias, j);
5067 getOptional<TxAudio>(
"txAudio", p.txAudio, j);
5068 getOptional<Presence>(
"presence", p.presence, j);
5069 getOptional<std::vector<Rallypoint>>(
"rallypoints", p.rallypoints, j);
5070 getOptional<RallypointCluster>(
"rallypointCluster", p.rallypointCluster, j);
5071 getOptional<Audio>(
"audio", p.audio, j);
5072 getOptional<GroupTimeline>(
"timeline", p.timeline, j);
5073 getOptional<bool>(
"blockAdvertising", p.blockAdvertising, j,
false);
5074 getOptional<std::string>(
"source", p.source, j);
5075 getOptional<int>(
"maxRxSecs", p.maxRxSecs, j, 0);
5076 getOptional<bool>(
"enableMulticastFailover", p.enableMulticastFailover, j,
false);
5077 getOptional<int>(
"multicastFailoverSecs", p.multicastFailoverSecs, j, 10);
5078 getOptional<NetworkAddress>(
"rtcpPresenceRx", p.rtcpPresenceRx, j);
5079 getOptional<std::vector<std::string>>(
"presenceGroupAffinities", p.presenceGroupAffinities, j);
5080 getOptional<bool>(
"disablePacketEvents", p.disablePacketEvents, j,
false);
5081 getOptional<int>(
"rfc4733RtpPayloadId", p.rfc4733RtpPayloadId, j, 0);
5082 getOptional<std::vector<RtpPayloadTypeTranslation>>(
"inboundRtpPayloadTypeTranslations", p.inboundRtpPayloadTypeTranslations, j);
5083 getOptional<GroupPriorityTranslation>(
"priorityTranslation", p.priorityTranslation, j);
5084 getOptional<int>(
"stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
5085 getOptional<std::string>(
"anonymousAlias", p.anonymousAlias, j);
5086 getOptional<bool>(
"lbCrypto", p.lbCrypto, j,
false);
5087 getOptional<GroupAppTransport>(
"appTransport", p.appTransport, j);
5088 getOptional<bool>(
"allowLoopback", p.allowLoopback, j,
false);
5089 getOptionalWithIndicator<RtpProfile>(
"rtpProfile", p.rtpProfile, j, &p._wasDeserialized_rtpProfile);
5090 getOptional<RangerPackets>(
"rangerPackets", p.rangerPackets, j);
5091 getOptional<TransportImpairment>(
"txImpairment", p.txImpairment, j);
5092 getOptional<TransportImpairment>(
"rxImpairment", p.rxImpairment, j);
5093 getOptional<std::vector<uint16_t>>(
"specializerAffinities", p.specializerAffinities, j);
5094 getOptional<uint32_t>(
"securityLevel", p.securityLevel, j, 0);
5095 getOptional<std::vector<Source>>(
"ignoreSources", p.ignoreSources, j);
5096 getOptional<std::string>(
"languageCode", p.languageCode, j);
5097 getOptional<std::string>(
"synVoice", p.synVoice, j);
5099 getOptional<PacketCapturer>(
"rxCapture", p.rxCapture, j);
5100 getOptional<PacketCapturer>(
"txCapture", p.txCapture, j);
5104 getOptional<Group::InboundAliasGenerationPolicy_t>(
"inboundAliasGenerationPolicy", p.inboundAliasGenerationPolicy, j, Group::InboundAliasGenerationPolicy_t::iagpAnonymousAlias);
5106 getOptional<AudioGate>(
"gateIn", p.gateIn, j);
5108 getOptional<bool>(
"ignoreAudioTraffic", p.ignoreAudioTraffic, j,
false);
5110 FROMJSON_BASE_IMPL();
5115 JSON_SERIALIZED_CLASS(Mission)
5118 IMPLEMENT_JSON_SERIALIZATION()
5119 IMPLEMENT_JSON_DOCUMENTATION(
Mission)
5124 std::vector<Group> groups;
5125 std::chrono::system_clock::time_point begins;
5126 std::chrono::system_clock::time_point ends;
5127 std::string certStoreId;
5128 int multicastFailoverPolicy;
5136 certStoreId.clear();
5137 multicastFailoverPolicy = 0;
5142 static void to_json(nlohmann::json& j,
const Mission& p)
5147 TOJSON_IMPL(groups),
5148 TOJSON_IMPL(certStoreId),
5149 TOJSON_IMPL(multicastFailoverPolicy),
5150 TOJSON_IMPL(rallypoint)
5154 static void from_json(
const nlohmann::json& j, Mission& p)
5157 j.at(
"id").get_to(p.id);
5158 j.at(
"name").get_to(p.name);
5163 j.at(
"groups").get_to(p.groups);
5170 FROMJSON_IMPL(certStoreId, std::string, EMPTY_STRING);
5171 FROMJSON_IMPL(multicastFailoverPolicy,
int, 0);
5172 getOptional<Rallypoint>(
"rallypoint", p.rallypoint, j);
5176 JSON_SERIALIZED_CLASS(LicenseDescriptor)
5188 IMPLEMENT_JSON_SERIALIZATION()
5197 static const int STATUS_OK = 0;
5198 static const int ERR_NULL_ENTITLEMENT_KEY = -1;
5199 static const int ERR_NULL_LICENSE_KEY = -2;
5200 static const int ERR_INVALID_LICENSE_KEY_LEN = -3;
5201 static const int ERR_LICENSE_KEY_VERIFICATION_FAILURE = -4;
5202 static const int ERR_ACTIVATION_CODE_VERIFICATION_FAILURE = -5;
5203 static const int ERR_INVALID_EXPIRATION_DATE = -6;
5204 static const int ERR_GENERAL_FAILURE = -7;
5205 static const int ERR_NOT_INITIALIZED = -8;
5206 static const int ERR_REQUIRES_ACTIVATION = -9;
5207 static const int ERR_LICENSE_NOT_SUITED_FOR_ACTIVATION = -10;
5215 static const uint8_t LIC_CARGO_FLAG_LIMIT_TO_FEATURES = 0x01;
5279 entitlement.clear();
5281 activationCode.clear();
5284 expiresFormatted.clear();
5289 status = ERR_NOT_INITIALIZED;
5290 manufacturerId.clear();
5294 static void to_json(nlohmann::json& j,
const LicenseDescriptor& p)
5298 {
"entitlement",
"*entitlement*"},
5300 TOJSON_IMPL(activationCode),
5302 TOJSON_IMPL(expires),
5303 TOJSON_IMPL(expiresFormatted),
5305 TOJSON_IMPL(deviceId),
5306 TOJSON_IMPL(status),
5308 {
"manufacturerId",
"*manufacturerId*"},
5310 TOJSON_IMPL(cargoFlags)
5314 static void from_json(
const nlohmann::json& j, LicenseDescriptor& p)
5317 FROMJSON_IMPL(entitlement, std::string, EMPTY_STRING);
5318 FROMJSON_IMPL(key, std::string, EMPTY_STRING);
5319 FROMJSON_IMPL(activationCode, std::string, EMPTY_STRING);
5320 FROMJSON_IMPL(type,
int, 0);
5321 FROMJSON_IMPL(expires, time_t, 0);
5322 FROMJSON_IMPL(expiresFormatted, std::string, EMPTY_STRING);
5323 FROMJSON_IMPL(flags, uint32_t, 0);
5324 FROMJSON_IMPL(deviceId, std::string, EMPTY_STRING);
5325 FROMJSON_IMPL(status,
int, LicenseDescriptor::ERR_NOT_INITIALIZED);
5326 FROMJSON_IMPL(manufacturerId, std::string, EMPTY_STRING);
5327 FROMJSON_IMPL(cargo, std::string, EMPTY_STRING);
5328 FROMJSON_IMPL(cargoFlags, uint8_t, 0);
5333 JSON_SERIALIZED_CLASS(EngineNetworkingRpUdpStreaming)
5347 IMPLEMENT_JSON_SERIALIZATION()
5375 keepaliveIntervalSecs = 15;
5376 priority = TxPriority_t::priVoice;
5380 virtual void initForDocumenting()
5385 static void to_json(nlohmann::json& j,
const EngineNetworkingRpUdpStreaming& p)
5388 TOJSON_IMPL(enabled),
5390 TOJSON_IMPL(keepaliveIntervalSecs),
5391 TOJSON_IMPL(priority),
5395 static void from_json(
const nlohmann::json& j, EngineNetworkingRpUdpStreaming& p)
5398 getOptional<bool>(
"enabled", p.enabled, j,
false);
5399 getOptional<int>(
"port", p.port, j, 0);
5400 getOptional<int>(
"keepaliveIntervalSecs", p.keepaliveIntervalSecs, j, 15);
5401 getOptional<TxPriority_t>(
"priority", p.priority, j, TxPriority_t::priVoice);
5402 getOptional<int>(
"ttl", p.ttl, j, 64);
5406 JSON_SERIALIZED_CLASS(EnginePolicyNetworking)
5417 IMPLEMENT_JSON_SERIALIZATION()
5453 multicastRejoinSecs = 8;
5454 rallypointRtTestIntervalMs = 60000;
5455 logRtpJitterBufferStats =
false;
5456 preventMulticastFailover =
false;
5457 addressResolutionPolicy = AddressResolutionPolicy_t::arpIpv6ThenIpv4;
5459 rpUdpStreaming.clear();
5464 static void to_json(nlohmann::json& j,
const EnginePolicyNetworking& p)
5467 TOJSON_IMPL(defaultNic),
5468 TOJSON_IMPL(multicastRejoinSecs),
5470 TOJSON_IMPL(rallypointRtTestIntervalMs),
5471 TOJSON_IMPL(logRtpJitterBufferStats),
5472 TOJSON_IMPL(preventMulticastFailover),
5474 TOJSON_IMPL(rpUdpStreaming),
5475 TOJSON_IMPL(rtpProfile),
5476 TOJSON_IMPL(addressResolutionPolicy)
5479 static void from_json(
const nlohmann::json& j, EnginePolicyNetworking& p)
5482 FROMJSON_IMPL(defaultNic, std::string, EMPTY_STRING);
5483 FROMJSON_IMPL(multicastRejoinSecs,
int, 8);
5484 FROMJSON_IMPL(rallypointRtTestIntervalMs,
int, 60000);
5485 FROMJSON_IMPL(logRtpJitterBufferStats,
bool,
false);
5486 FROMJSON_IMPL(preventMulticastFailover,
bool,
false);
5488 getOptional<EngineNetworkingRpUdpStreaming>(
"rpUdpStreaming", p.rpUdpStreaming, j);
5489 getOptional<RtpProfile>(
"rtpProfile", p.rtpProfile, j);
5490 getOptional<AddressResolutionPolicy_t>(
"addressResolutionPolicy", p.addressResolutionPolicy, j, AddressResolutionPolicy_t::arpIpv6ThenIpv4);
5494 JSON_SERIALIZED_CLASS(Aec)
5506 IMPLEMENT_JSON_SERIALIZATION()
5507 IMPLEMENT_JSON_DOCUMENTATION(
Aec)
5562 static void to_json(nlohmann::json& j,
const Aec& p)
5565 TOJSON_IMPL(enabled),
5567 TOJSON_IMPL(speakerTailMs),
5571 static void from_json(
const nlohmann::json& j, Aec& p)
5574 FROMJSON_IMPL(enabled,
bool,
false);
5575 FROMJSON_IMPL(mode, Aec::Mode_t, Aec::Mode_t::aecmDefault);
5576 FROMJSON_IMPL(speakerTailMs,
int, 60);
5577 FROMJSON_IMPL(cng,
bool,
true);
5581 JSON_SERIALIZED_CLASS(Vad)
5593 IMPLEMENT_JSON_SERIALIZATION()
5594 IMPLEMENT_JSON_DOCUMENTATION(
Vad)
5614 vamVeryAggressive = 3
5635 static void to_json(nlohmann::json& j,
const Vad& p)
5638 TOJSON_IMPL(enabled),
5642 static void from_json(
const nlohmann::json& j, Vad& p)
5645 FROMJSON_IMPL(enabled,
bool,
false);
5646 FROMJSON_IMPL(mode, Vad::Mode_t, Vad::Mode_t::vamDefault);
5650 JSON_SERIALIZED_CLASS(Bridge)
5662 IMPLEMENT_JSON_SERIALIZATION()
5663 IMPLEMENT_JSON_DOCUMENTATION(
Bridge)
5692 static void to_json(nlohmann::json& j,
const Bridge& p)
5697 TOJSON_IMPL(groups),
5698 TOJSON_IMPL(enabled)
5701 static void from_json(
const nlohmann::json& j, Bridge& p)
5704 FROMJSON_IMPL(
id, std::string, EMPTY_STRING);
5705 FROMJSON_IMPL(name, std::string, EMPTY_STRING);
5706 getOptional<std::vector<std::string>>(
"groups", p.groups, j);
5707 FROMJSON_IMPL(enabled,
bool,
true);
5711 JSON_SERIALIZED_CLASS(AndroidAudio)
5723 IMPLEMENT_JSON_SERIALIZATION()
5727 constexpr static int INVALID_SESSION_ID = -9999;
5788 performanceMode = 12;
5792 sessionId = AndroidAudio::INVALID_SESSION_ID;
5797 static void to_json(nlohmann::json& j,
const AndroidAudio& p)
5801 TOJSON_IMPL(sharingMode),
5802 TOJSON_IMPL(performanceMode),
5804 TOJSON_IMPL(contentType),
5805 TOJSON_IMPL(inputPreset),
5806 TOJSON_IMPL(sessionId),
5807 TOJSON_IMPL(engineMode)
5810 static void from_json(
const nlohmann::json& j, AndroidAudio& p)
5813 FROMJSON_IMPL(api,
int, 0);
5814 FROMJSON_IMPL(sharingMode,
int, 0);
5815 FROMJSON_IMPL(performanceMode,
int, 12);
5816 FROMJSON_IMPL(usage,
int, 2);
5817 FROMJSON_IMPL(contentType,
int, 1);
5818 FROMJSON_IMPL(inputPreset,
int, 7);
5819 FROMJSON_IMPL(sessionId,
int, AndroidAudio::INVALID_SESSION_ID);
5820 FROMJSON_IMPL(engineMode,
int, 0);
5824 JSON_SERIALIZED_CLASS(EnginePolicyAudio)
5836 IMPLEMENT_JSON_SERIALIZATION()
5891 hardwareEnabled =
true;
5892 internalRate = 16000;
5893 internalChannels = 2;
5900 denoiseInput =
false;
5901 denoiseOutput =
false;
5902 saveInputPcm =
false;
5903 saveOutputPcm =
false;
5907 static void to_json(nlohmann::json& j,
const EnginePolicyAudio& p)
5910 TOJSON_IMPL(enabled),
5911 TOJSON_IMPL(hardwareEnabled),
5912 TOJSON_IMPL(internalRate),
5913 TOJSON_IMPL(internalChannels),
5914 TOJSON_IMPL(muteTxOnTx),
5917 TOJSON_IMPL(android),
5918 TOJSON_IMPL(inputAgc),
5919 TOJSON_IMPL(outputAgc),
5920 TOJSON_IMPL(denoiseInput),
5921 TOJSON_IMPL(denoiseOutput),
5922 TOJSON_IMPL(saveInputPcm),
5923 TOJSON_IMPL(saveOutputPcm)
5926 static void from_json(
const nlohmann::json& j, EnginePolicyAudio& p)
5929 getOptional<bool>(
"enabled", p.enabled, j,
true);
5930 getOptional<bool>(
"hardwareEnabled", p.hardwareEnabled, j,
true);
5931 FROMJSON_IMPL(internalRate,
int, 16000);
5932 FROMJSON_IMPL(internalChannels,
int, 2);
5934 FROMJSON_IMPL(muteTxOnTx,
bool,
false);
5935 getOptional<Aec>(
"aec", p.aec, j);
5936 getOptional<Vad>(
"vad", p.vad, j);
5937 getOptional<AndroidAudio>(
"android", p.android, j);
5938 getOptional<Agc>(
"inputAgc", p.inputAgc, j);
5939 getOptional<Agc>(
"outputAgc", p.outputAgc, j);
5940 FROMJSON_IMPL(denoiseInput,
bool,
false);
5941 FROMJSON_IMPL(denoiseOutput,
bool,
false);
5942 FROMJSON_IMPL(saveInputPcm,
bool,
false);
5943 FROMJSON_IMPL(saveOutputPcm,
bool,
false);
5947 JSON_SERIALIZED_CLASS(SecurityCertificate)
5959 IMPLEMENT_JSON_SERIALIZATION()
5981 certificate.clear();
5986 static void to_json(nlohmann::json& j,
const SecurityCertificate& p)
5989 TOJSON_IMPL(certificate),
5993 static void from_json(
const nlohmann::json& j, SecurityCertificate& p)
5996 FROMJSON_IMPL(certificate, std::string, EMPTY_STRING);
5997 FROMJSON_IMPL(key, std::string, EMPTY_STRING);
6002 JSON_SERIALIZED_CLASS(EnginePolicySecurity)
6015 IMPLEMENT_JSON_SERIALIZATION()
6048 certificate.clear();
6049 caCertificates.clear();
6053 static void to_json(nlohmann::json& j,
const EnginePolicySecurity& p)
6056 TOJSON_IMPL(certificate),
6057 TOJSON_IMPL(caCertificates)
6060 static void from_json(
const nlohmann::json& j, EnginePolicySecurity& p)
6063 getOptional(
"certificate", p.certificate, j);
6064 getOptional<std::vector<std::string>>(
"caCertificates", p.caCertificates, j);
6068 JSON_SERIALIZED_CLASS(EnginePolicyLogging)
6080 IMPLEMENT_JSON_SERIALIZATION()
6113 enableSyslog =
false;
6117 static void to_json(nlohmann::json& j,
const EnginePolicyLogging& p)
6120 TOJSON_IMPL(maxLevel),
6121 TOJSON_IMPL(enableSyslog)
6124 static void from_json(
const nlohmann::json& j, EnginePolicyLogging& p)
6127 getOptional(
"maxLevel", p.maxLevel, j, 4);
6128 getOptional(
"enableSyslog", p.enableSyslog, j);
6133 JSON_SERIALIZED_CLASS(EnginePolicyDatabase)
6136 IMPLEMENT_JSON_SERIALIZATION()
6147 DatabaseType_t type;
6148 std::string fixedFileName;
6149 bool forceMaintenance;
6159 type = DatabaseType_t::dbtFixedMemory;
6160 fixedFileName.clear();
6161 forceMaintenance =
false;
6162 reclaimSpace =
false;
6170 TOJSON_IMPL(fixedFileName),
6171 TOJSON_IMPL(forceMaintenance),
6172 TOJSON_IMPL(reclaimSpace)
6175 static void from_json(
const nlohmann::json& j, EnginePolicyDatabase& p)
6178 FROMJSON_IMPL(type, EnginePolicyDatabase::DatabaseType_t, EnginePolicyDatabase::DatabaseType_t::dbtFixedMemory);
6179 FROMJSON_IMPL(fixedFileName, std::string, EMPTY_STRING);
6180 FROMJSON_IMPL(forceMaintenance,
bool,
false);
6181 FROMJSON_IMPL(reclaimSpace,
bool,
false);
6186 JSON_SERIALIZED_CLASS(SecureSignature)
6196 IMPLEMENT_JSON_SERIALIZATION()
6217 certificate.clear();
6223 static void to_json(nlohmann::json& j,
const SecureSignature& p)
6226 TOJSON_IMPL(certificate),
6228 TOJSON_IMPL(signature)
6231 static void from_json(
const nlohmann::json& j, SecureSignature& p)
6234 FROMJSON_IMPL(certificate, std::string, EMPTY_STRING);
6236 FROMJSON_IMPL(signature, std::string, EMPTY_STRING);
6240 JSON_SERIALIZED_CLASS(NamedAudioDevice)
6243 IMPLEMENT_JSON_SERIALIZATION()
6248 std::string manufacturer;
6251 std::string serialNumber;
6264 manufacturer.clear();
6267 serialNumber.clear();
6278 TOJSON_IMPL(manufacturer),
6281 TOJSON_IMPL(serialNumber),
6284 TOJSON_IMPL(isDefault),
6287 static void from_json(
const nlohmann::json& j, NamedAudioDevice& p)
6290 getOptional<std::string>(
"name", p.name, j, EMPTY_STRING);
6291 getOptional<std::string>(
"manufacturer", p.manufacturer, j, EMPTY_STRING);
6292 getOptional<std::string>(
"model", p.model, j, EMPTY_STRING);
6293 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
6294 getOptional<std::string>(
"serialNumber", p.serialNumber, j, EMPTY_STRING);
6295 getOptional<std::string>(
"type", p.type, j, EMPTY_STRING);
6296 getOptional<std::string>(
"extra", p.extra, j, EMPTY_STRING);
6297 getOptional<bool>(
"isDefault", p.isDefault, j,
false);
6302 JSON_SERIALIZED_CLASS(EnginePolicyNamedAudioDevices)
6305 IMPLEMENT_JSON_SERIALIZATION()
6309 std::vector<NamedAudioDevice> inputs;
6310 std::vector<NamedAudioDevice> outputs;
6327 TOJSON_IMPL(inputs),
6328 TOJSON_IMPL(outputs)
6331 static void from_json(
const nlohmann::json& j, EnginePolicyNamedAudioDevices& p)
6334 getOptional<std::vector<NamedAudioDevice>>(
"inputs", p.inputs, j);
6335 getOptional<std::vector<NamedAudioDevice>>(
"outputs", p.outputs, j);
6339 JSON_SERIALIZED_CLASS(Licensing)
6353 IMPLEMENT_JSON_SERIALIZATION()
6380 entitlement.clear();
6382 activationCode.clear();
6384 manufacturerId.clear();
6388 static void to_json(nlohmann::json& j,
const Licensing& p)
6391 TOJSON_IMPL(entitlement),
6393 TOJSON_IMPL(activationCode),
6394 TOJSON_IMPL(deviceId),
6395 TOJSON_IMPL(manufacturerId)
6398 static void from_json(
const nlohmann::json& j, Licensing& p)
6401 FROMJSON_IMPL(entitlement, std::string, EMPTY_STRING);
6402 FROMJSON_IMPL(key, std::string, EMPTY_STRING);
6403 FROMJSON_IMPL(activationCode, std::string, EMPTY_STRING);
6404 FROMJSON_IMPL(deviceId, std::string, EMPTY_STRING);
6405 FROMJSON_IMPL(manufacturerId, std::string, EMPTY_STRING);
6409 JSON_SERIALIZED_CLASS(DiscoveryMagellan)
6421 IMPLEMENT_JSON_SERIALIZATION()
6446 interfaceName.clear();
6452 static void to_json(nlohmann::json& j,
const DiscoveryMagellan& p)
6455 TOJSON_IMPL(enabled),
6456 TOJSON_IMPL(interfaceName),
6457 TOJSON_IMPL(security),
6461 static void from_json(
const nlohmann::json& j, DiscoveryMagellan& p)
6464 getOptional(
"enabled", p.enabled, j,
false);
6465 getOptional<Tls>(
"tls", p.tls, j);
6466 getOptional<SecurityCertificate>(
"security", p.security, j);
6467 FROMJSON_IMPL(interfaceName, std::string, EMPTY_STRING);
6471 JSON_SERIALIZED_CLASS(DiscoverySsdp)
6483 IMPLEMENT_JSON_SERIALIZATION()
6514 interfaceName.clear();
6516 searchTerms.clear();
6517 ageTimeoutMs = 30000;
6518 advertising.clear();
6522 static void to_json(nlohmann::json& j,
const DiscoverySsdp& p)
6525 TOJSON_IMPL(enabled),
6526 TOJSON_IMPL(interfaceName),
6527 TOJSON_IMPL(address),
6528 TOJSON_IMPL(searchTerms),
6529 TOJSON_IMPL(ageTimeoutMs),
6530 TOJSON_IMPL(advertising)
6533 static void from_json(
const nlohmann::json& j, DiscoverySsdp& p)
6536 getOptional(
"enabled", p.enabled, j,
false);
6537 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
6539 getOptional<NetworkAddress>(
"address", p.address, j);
6540 if(p.address.address.empty())
6542 p.address.address =
"255.255.255.255";
6544 if(p.address.port <= 0)
6546 p.address.port = 1900;
6549 getOptional<std::vector<std::string>>(
"searchTerms", p.searchTerms, j);
6550 getOptional<int>(
"ageTimeoutMs", p.ageTimeoutMs, j, 30000);
6551 getOptional<Advertising>(
"advertising", p.advertising, j);
6555 JSON_SERIALIZED_CLASS(DiscoverySap)
6567 IMPLEMENT_JSON_SERIALIZATION()
6594 interfaceName.clear();
6596 ageTimeoutMs = 30000;
6597 advertising.clear();
6601 static void to_json(nlohmann::json& j,
const DiscoverySap& p)
6604 TOJSON_IMPL(enabled),
6605 TOJSON_IMPL(interfaceName),
6606 TOJSON_IMPL(address),
6607 TOJSON_IMPL(ageTimeoutMs),
6608 TOJSON_IMPL(advertising)
6611 static void from_json(
const nlohmann::json& j, DiscoverySap& p)
6614 getOptional(
"enabled", p.enabled, j,
false);
6615 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
6616 getOptional<NetworkAddress>(
"address", p.address, j);
6617 if(p.address.address.empty())
6619 p.address.address =
"224.2.127.254";
6621 if(p.address.port <= 0)
6623 p.address.port = 9875;
6626 getOptional<int>(
"ageTimeoutMs", p.ageTimeoutMs, j, 30000);
6627 getOptional<Advertising>(
"advertising", p.advertising, j);
6631 JSON_SERIALIZED_CLASS(DiscoveryCistech)
6645 IMPLEMENT_JSON_SERIALIZATION()
6650 std::string interfaceName;
6662 interfaceName.clear();
6664 ageTimeoutMs = 30000;
6671 TOJSON_IMPL(enabled),
6672 TOJSON_IMPL(interfaceName),
6673 TOJSON_IMPL(address),
6674 TOJSON_IMPL(ageTimeoutMs)
6677 static void from_json(
const nlohmann::json& j, DiscoveryCistech& p)
6680 getOptional(
"enabled", p.enabled, j,
false);
6681 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
6682 getOptional<NetworkAddress>(
"address", p.address, j);
6683 getOptional<int>(
"ageTimeoutMs", p.ageTimeoutMs, j, 30000);
6688 JSON_SERIALIZED_CLASS(DiscoveryTrellisware)
6700 IMPLEMENT_JSON_SERIALIZATION()
6723 static void to_json(nlohmann::json& j,
const DiscoveryTrellisware& p)
6726 TOJSON_IMPL(enabled),
6727 TOJSON_IMPL(security)
6730 static void from_json(
const nlohmann::json& j, DiscoveryTrellisware& p)
6733 getOptional(
"enabled", p.enabled, j,
false);
6734 getOptional<SecurityCertificate>(
"security", p.security, j);
6738 JSON_SERIALIZED_CLASS(DiscoveryConfiguration)
6750 IMPLEMENT_JSON_SERIALIZATION()
6783 static void to_json(nlohmann::json& j,
const DiscoveryConfiguration& p)
6786 TOJSON_IMPL(magellan),
6789 TOJSON_IMPL(cistech),
6790 TOJSON_IMPL(trellisware)
6793 static void from_json(
const nlohmann::json& j, DiscoveryConfiguration& p)
6796 getOptional<DiscoveryMagellan>(
"magellan", p.magellan, j);
6797 getOptional<DiscoverySsdp>(
"ssdp", p.ssdp, j);
6798 getOptional<DiscoverySap>(
"sap", p.sap, j);
6799 getOptional<DiscoveryCistech>(
"cistech", p.cistech, j);
6800 getOptional<DiscoveryTrellisware>(
"trellisware", p.trellisware, j);
6805 JSON_SERIALIZED_CLASS(EnginePolicyInternals)
6819 IMPLEMENT_JSON_SERIALIZATION()
6834 int logTaskQueueStatsIntervalMs;
6836 bool enableLazySpeakerClosure;
6870 housekeeperIntervalMs = 1000;
6871 logTaskQueueStatsIntervalMs = 0;
6874 enableLazySpeakerClosure =
false;
6875 rpClusterStrategy = RallypointCluster::ConnectionStrategy_t::csRoundRobin;
6876 rpClusterRolloverSecs = 10;
6877 rtpExpirationCheckIntervalMs = 250;
6878 rpConnectionTimeoutSecs = 5;
6879 stickyTidHangSecs = 10;
6880 uriStreamingIntervalMs = 60;
6881 delayedMicrophoneClosureSecs = 15;
6886 static void to_json(nlohmann::json& j,
const EnginePolicyInternals& p)
6889 TOJSON_IMPL(watchdog),
6890 TOJSON_IMPL(housekeeperIntervalMs),
6891 TOJSON_IMPL(logTaskQueueStatsIntervalMs),
6892 TOJSON_IMPL(maxTxSecs),
6893 TOJSON_IMPL(maxRxSecs),
6894 TOJSON_IMPL(enableLazySpeakerClosure),
6895 TOJSON_IMPL(rpClusterStrategy),
6896 TOJSON_IMPL(rpClusterRolloverSecs),
6897 TOJSON_IMPL(rtpExpirationCheckIntervalMs),
6898 TOJSON_IMPL(rpConnectionTimeoutSecs),
6899 TOJSON_IMPL(stickyTidHangSecs),
6900 TOJSON_IMPL(uriStreamingIntervalMs),
6901 TOJSON_IMPL(delayedMicrophoneClosureSecs),
6905 static void from_json(
const nlohmann::json& j, EnginePolicyInternals& p)
6908 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
6909 getOptional<int>(
"housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
6910 getOptional<int>(
"logTaskQueueStatsIntervalMs", p.logTaskQueueStatsIntervalMs, j, 0);
6911 getOptional<int>(
"maxTxSecs", p.maxTxSecs, j, 30);
6912 getOptional<int>(
"maxRxSecs", p.maxRxSecs, j, 0);
6913 getOptional<bool>(
"enableLazySpeakerClosure", p.enableLazySpeakerClosure, j,
false);
6914 getOptional<RallypointCluster::ConnectionStrategy_t>(
"rpClusterStrategy", p.rpClusterStrategy, j, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
6915 getOptional<int>(
"rpClusterRolloverSecs", p.rpClusterRolloverSecs, j, 10);
6916 getOptional<int>(
"rtpExpirationCheckIntervalMs", p.rtpExpirationCheckIntervalMs, j, 250);
6917 getOptional<int>(
"rpConnectionTimeoutSecs", p.rpConnectionTimeoutSecs, j, 5);
6918 getOptional<int>(
"stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
6919 getOptional<int>(
"uriStreamingIntervalMs", p.uriStreamingIntervalMs, j, 60);
6920 getOptional<int>(
"delayedMicrophoneClosureSecs", p.delayedMicrophoneClosureSecs, j, 15);
6921 getOptional<TuningSettings>(
"tuning", p.tuning, j);
6925 JSON_SERIALIZED_CLASS(EnginePolicyTimelines)
6939 IMPLEMENT_JSON_SERIALIZATION()
7001 storageRoot.clear();
7002 maxStorageMb = 1024;
7003 maxMemMb = maxStorageMb;
7004 maxAudioEventMemMb = maxMemMb;
7005 maxDiskMb = maxStorageMb;
7006 maxEventAgeSecs = (86400 * 30);
7007 groomingIntervalSecs = (60 * 30);
7009 autosaveIntervalSecs = 5;
7011 disableSigningAndVerification =
false;
7016 static void to_json(nlohmann::json& j,
const EnginePolicyTimelines& p)
7019 TOJSON_IMPL(enabled),
7020 TOJSON_IMPL(storageRoot),
7021 TOJSON_IMPL(maxMemMb),
7022 TOJSON_IMPL(maxAudioEventMemMb),
7023 TOJSON_IMPL(maxDiskMb),
7024 TOJSON_IMPL(maxEventAgeSecs),
7025 TOJSON_IMPL(maxEvents),
7026 TOJSON_IMPL(groomingIntervalSecs),
7027 TOJSON_IMPL(autosaveIntervalSecs),
7028 TOJSON_IMPL(security),
7029 TOJSON_IMPL(disableSigningAndVerification),
7030 TOJSON_IMPL(ephemeral)
7033 static void from_json(
const nlohmann::json& j, EnginePolicyTimelines& p)
7036 getOptional<bool>(
"enabled", p.enabled, j,
true);
7037 getOptional<std::string>(
"storageRoot", p.storageRoot, j, EMPTY_STRING);
7039 getOptional<int>(
"maxStorageMb", p.maxStorageMb, j, 1024);
7040 getOptional<int>(
"maxMemMb", p.maxMemMb, j, p.maxStorageMb);
7041 getOptional<int>(
"maxAudioEventMemMb", p.maxAudioEventMemMb, j, p.maxMemMb);
7042 getOptional<int>(
"maxDiskMb", p.maxDiskMb, j, p.maxStorageMb);
7043 getOptional<long>(
"maxEventAgeSecs", p.maxEventAgeSecs, j, (86400 * 30));
7044 getOptional<long>(
"groomingIntervalSecs", p.groomingIntervalSecs, j, (60 * 30));
7045 getOptional<long>(
"autosaveIntervalSecs", p.autosaveIntervalSecs, j, 5);
7046 getOptional<int>(
"maxEvents", p.maxEvents, j, 1000);
7047 getOptional<SecurityCertificate>(
"security", p.security, j);
7048 getOptional<bool>(
"disableSigningAndVerification", p.disableSigningAndVerification, j,
false);
7049 getOptional<bool>(
"ephemeral", p.ephemeral, j,
false);
7054 JSON_SERIALIZED_CLASS(RtpMapEntry)
7066 IMPLEMENT_JSON_SERIALIZATION()
7088 rtpPayloadType = -1;
7092 static void to_json(nlohmann::json& j,
const RtpMapEntry& p)
7096 TOJSON_IMPL(engageType),
7097 TOJSON_IMPL(rtpPayloadType)
7100 static void from_json(
const nlohmann::json& j, RtpMapEntry& p)
7103 getOptional<std::string>(
"name", p.name, j, EMPTY_STRING);
7104 getOptional<int>(
"engageType", p.engageType, j, -1);
7105 getOptional<int>(
"rtpPayloadType", p.rtpPayloadType, j, -1);
7109 JSON_SERIALIZED_CLASS(ExternalModule)
7121 IMPLEMENT_JSON_SERIALIZATION()
7143 configuration.clear();
7147 static void to_json(nlohmann::json& j,
const ExternalModule& p)
7154 if(!p.configuration.empty())
7156 j[
"configuration"] = p.configuration;
7159 static void from_json(
const nlohmann::json& j, ExternalModule& p)
7162 getOptional<std::string>(
"name", p.name, j, EMPTY_STRING);
7163 getOptional<std::string>(
"file", p.file, j, EMPTY_STRING);
7167 p.configuration = j.at(
"configuration");
7171 p.configuration.clear();
7177 JSON_SERIALIZED_CLASS(ExternalCodecDescriptor)
7189 IMPLEMENT_JSON_SERIALIZATION()
7212 rtpPayloadType = -1;
7215 rtpTsMultiplier = 0;
7219 static void to_json(nlohmann::json& j,
const ExternalCodecDescriptor& p)
7222 TOJSON_IMPL(rtpPayloadType),
7223 TOJSON_IMPL(samplingRate),
7224 TOJSON_IMPL(channels),
7225 TOJSON_IMPL(rtpTsMultiplier)
7228 static void from_json(
const nlohmann::json& j, ExternalCodecDescriptor& p)
7232 getOptional<int>(
"rtpPayloadType", p.rtpPayloadType, j, -1);
7233 getOptional<int>(
"samplingRate", p.samplingRate, j, -1);
7234 getOptional<int>(
"channels", p.channels, j, -1);
7235 getOptional<int>(
"rtpTsMultiplier", p.rtpTsMultiplier, j, -1);
7239 JSON_SERIALIZED_CLASS(EngineStatusReportConfiguration)
7251 IMPLEMENT_JSON_SERIALIZATION()
7283 includeMemoryDetail =
false;
7284 includeTaskQueueDetail =
false;
7289 static void to_json(nlohmann::json& j,
const EngineStatusReportConfiguration& p)
7292 TOJSON_IMPL(fileName),
7293 TOJSON_IMPL(intervalSecs),
7294 TOJSON_IMPL(enabled),
7295 TOJSON_IMPL(includeMemoryDetail),
7296 TOJSON_IMPL(includeTaskQueueDetail),
7300 static void from_json(
const nlohmann::json& j, EngineStatusReportConfiguration& p)
7303 getOptional<std::string>(
"fileName", p.fileName, j);
7304 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
7305 getOptional<bool>(
"enabled", p.enabled, j,
false);
7306 getOptional<std::string>(
"runCmd", p.runCmd, j);
7307 getOptional<bool>(
"includeMemoryDetail", p.includeMemoryDetail, j,
false);
7308 getOptional<bool>(
"includeTaskQueueDetail", p.includeTaskQueueDetail, j,
false);
7312 JSON_SERIALIZED_CLASS(EnginePolicy)
7326 IMPLEMENT_JSON_SERIALIZATION()
7383 dataDirectory.clear();
7394 namedAudioDevices.clear();
7395 externalCodecs.clear();
7397 statusReport.clear();
7401 static void to_json(nlohmann::json& j,
const EnginePolicy& p)
7404 TOJSON_IMPL(dataDirectory),
7405 TOJSON_IMPL(licensing),
7406 TOJSON_IMPL(security),
7407 TOJSON_IMPL(networking),
7409 TOJSON_IMPL(discovery),
7410 TOJSON_IMPL(logging),
7411 TOJSON_IMPL(internals),
7412 TOJSON_IMPL(timelines),
7413 TOJSON_IMPL(database),
7414 TOJSON_IMPL(featureset),
7415 TOJSON_IMPL(namedAudioDevices),
7416 TOJSON_IMPL(externalCodecs),
7417 TOJSON_IMPL(rtpMap),
7418 TOJSON_IMPL(statusReport)
7421 static void from_json(
const nlohmann::json& j, EnginePolicy& p)
7424 FROMJSON_IMPL_SIMPLE(dataDirectory);
7425 FROMJSON_IMPL_SIMPLE(licensing);
7426 FROMJSON_IMPL_SIMPLE(security);
7427 FROMJSON_IMPL_SIMPLE(networking);
7428 FROMJSON_IMPL_SIMPLE(audio);
7429 FROMJSON_IMPL_SIMPLE(discovery);
7430 FROMJSON_IMPL_SIMPLE(logging);
7431 FROMJSON_IMPL_SIMPLE(internals);
7432 FROMJSON_IMPL_SIMPLE(timelines);
7433 FROMJSON_IMPL_SIMPLE(database);
7434 FROMJSON_IMPL_SIMPLE(featureset);
7435 FROMJSON_IMPL_SIMPLE(namedAudioDevices);
7436 FROMJSON_IMPL_SIMPLE(externalCodecs);
7437 FROMJSON_IMPL_SIMPLE(rtpMap);
7438 FROMJSON_IMPL_SIMPLE(statusReport);
7443 JSON_SERIALIZED_CLASS(TalkgroupAsset)
7455 IMPLEMENT_JSON_SERIALIZATION()
7478 static void to_json(nlohmann::json& j,
const TalkgroupAsset& p)
7481 TOJSON_IMPL(nodeId),
7485 static void from_json(
const nlohmann::json& j, TalkgroupAsset& p)
7488 getOptional<std::string>(
"nodeId", p.nodeId, j);
7489 getOptional<Group>(
"group", p.group, j);
7493 JSON_SERIALIZED_CLASS(EngageDiscoveredGroup)
7503 IMPLEMENT_JSON_SERIALIZATION()
7533 static void to_json(nlohmann::json& j,
const EngageDiscoveredGroup& p)
7542 static void from_json(
const nlohmann::json& j, EngageDiscoveredGroup& p)
7545 getOptional<std::string>(
"id", p.id, j);
7546 getOptional<int>(
"type", p.type, j, 0);
7547 getOptional<NetworkAddress>(
"rx", p.rx, j);
7548 getOptional<NetworkAddress>(
"tx", p.tx, j);
7552 JSON_SERIALIZED_CLASS(RallypointPeer)
7564 IMPLEMENT_JSON_SERIALIZATION()
7596 certificate.clear();
7597 connectionTimeoutSecs = 0;
7598 forceIsMeshLeaf =
false;
7602 static void to_json(nlohmann::json& j,
const RallypointPeer& p)
7606 TOJSON_IMPL(enabled),
7608 TOJSON_IMPL(certificate),
7609 TOJSON_IMPL(connectionTimeoutSecs),
7610 TOJSON_IMPL(forceIsMeshLeaf)
7613 static void from_json(
const nlohmann::json& j, RallypointPeer& p)
7616 j.at(
"id").get_to(p.id);
7617 getOptional<bool>(
"enabled", p.enabled, j,
true);
7618 getOptional<NetworkAddress>(
"host", p.host, j);
7619 getOptional<SecurityCertificate>(
"certificate", p.certificate, j);
7620 getOptional<int>(
"connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
7621 getOptional<bool>(
"forceIsMeshLeaf", p.forceIsMeshLeaf, j,
false);
7625 JSON_SERIALIZED_CLASS(RallypointServerLimits)
7637 IMPLEMENT_JSON_SERIALIZATION()
7695 maxMulticastReflectors = 0;
7696 maxRegisteredStreams = 0;
7698 maxRxPacketsPerSec = 0;
7699 maxTxPacketsPerSec = 0;
7700 maxRxBytesPerSec = 0;
7701 maxTxBytesPerSec = 0;
7703 maxInboundBacklog = 64;
7704 lowPriorityQueueThreshold = 64;
7705 normalPriorityQueueThreshold = 256;
7706 denyNewConnectionCpuThreshold = 75;
7707 warnAtCpuThreshold = 65;
7711 static void to_json(nlohmann::json& j,
const RallypointServerLimits& p)
7714 TOJSON_IMPL(maxClients),
7715 TOJSON_IMPL(maxPeers),
7716 TOJSON_IMPL(maxMulticastReflectors),
7717 TOJSON_IMPL(maxRegisteredStreams),
7718 TOJSON_IMPL(maxStreamPaths),
7719 TOJSON_IMPL(maxRxPacketsPerSec),
7720 TOJSON_IMPL(maxTxPacketsPerSec),
7721 TOJSON_IMPL(maxRxBytesPerSec),
7722 TOJSON_IMPL(maxTxBytesPerSec),
7723 TOJSON_IMPL(maxQOpsPerSec),
7724 TOJSON_IMPL(maxInboundBacklog),
7725 TOJSON_IMPL(lowPriorityQueueThreshold),
7726 TOJSON_IMPL(normalPriorityQueueThreshold),
7727 TOJSON_IMPL(denyNewConnectionCpuThreshold),
7728 TOJSON_IMPL(warnAtCpuThreshold)
7731 static void from_json(
const nlohmann::json& j, RallypointServerLimits& p)
7734 getOptional<uint32_t>(
"maxClients", p.maxClients, j, 0);
7735 getOptional<uint32_t>(
"maxPeers", p.maxPeers, j, 0);
7736 getOptional<uint32_t>(
"maxMulticastReflectors", p.maxMulticastReflectors, j, 0);
7737 getOptional<uint32_t>(
"maxRegisteredStreams", p.maxRegisteredStreams, j, 0);
7738 getOptional<uint32_t>(
"maxStreamPaths", p.maxStreamPaths, j, 0);
7739 getOptional<uint32_t>(
"maxRxPacketsPerSec", p.maxRxPacketsPerSec, j, 0);
7740 getOptional<uint32_t>(
"maxTxPacketsPerSec", p.maxTxPacketsPerSec, j, 0);
7741 getOptional<uint32_t>(
"maxRxBytesPerSec", p.maxRxBytesPerSec, j, 0);
7742 getOptional<uint32_t>(
"maxTxBytesPerSec", p.maxTxBytesPerSec, j, 0);
7743 getOptional<uint32_t>(
"maxQOpsPerSec", p.maxQOpsPerSec, j, 0);
7744 getOptional<uint32_t>(
"maxInboundBacklog", p.maxInboundBacklog, j, 64);
7745 getOptional<uint32_t>(
"lowPriorityQueueThreshold", p.lowPriorityQueueThreshold, j, 64);
7746 getOptional<uint32_t>(
"normalPriorityQueueThreshold", p.normalPriorityQueueThreshold, j, 256);
7747 getOptional<uint32_t>(
"denyNewConnectionCpuThreshold", p.denyNewConnectionCpuThreshold, j, 75);
7748 getOptional<uint32_t>(
"warnAtCpuThreshold", p.warnAtCpuThreshold, j, 65);
7752 JSON_SERIALIZED_CLASS(RallypointServerStatusReportConfiguration)
7764 IMPLEMENT_JSON_SERIALIZATION()
7799 includeLinks =
false;
7800 includePeerLinkDetails =
false;
7801 includeClientLinkDetails =
false;
7806 static void to_json(nlohmann::json& j,
const RallypointServerStatusReportConfiguration& p)
7809 TOJSON_IMPL(fileName),
7810 TOJSON_IMPL(intervalSecs),
7811 TOJSON_IMPL(enabled),
7812 TOJSON_IMPL(includeLinks),
7813 TOJSON_IMPL(includePeerLinkDetails),
7814 TOJSON_IMPL(includeClientLinkDetails),
7818 static void from_json(
const nlohmann::json& j, RallypointServerStatusReportConfiguration& p)
7821 getOptional<std::string>(
"fileName", p.fileName, j);
7822 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
7823 getOptional<bool>(
"enabled", p.enabled, j,
false);
7824 getOptional<bool>(
"includeLinks", p.includeLinks, j,
false);
7825 getOptional<bool>(
"includePeerLinkDetails", p.includePeerLinkDetails, j,
false);
7826 getOptional<bool>(
"includeClientLinkDetails", p.includeClientLinkDetails, j,
false);
7827 getOptional<std::string>(
"runCmd", p.runCmd, j);
7831 JSON_SERIALIZED_CLASS(RallypointServerLinkGraph)
7834 IMPLEMENT_JSON_SERIALIZATION()
7877 includeDigraphEnclosure =
true;
7878 includeClients =
false;
7879 coreRpStyling =
"[shape=hexagon color=firebrick style=filled]";
7880 leafRpStyling =
"[shape=box color=gray style=filled]";
7881 clientStyling.clear();
7886 static void to_json(nlohmann::json& j,
const RallypointServerLinkGraph& p)
7889 TOJSON_IMPL(fileName),
7890 TOJSON_IMPL(minRefreshSecs),
7891 TOJSON_IMPL(enabled),
7892 TOJSON_IMPL(includeDigraphEnclosure),
7893 TOJSON_IMPL(includeClients),
7894 TOJSON_IMPL(coreRpStyling),
7895 TOJSON_IMPL(leafRpStyling),
7896 TOJSON_IMPL(clientStyling),
7900 static void from_json(
const nlohmann::json& j, RallypointServerLinkGraph& p)
7903 getOptional<std::string>(
"fileName", p.fileName, j);
7904 getOptional<int>(
"minRefreshSecs", p.minRefreshSecs, j, 5);
7905 getOptional<bool>(
"enabled", p.enabled, j,
false);
7906 getOptional<bool>(
"includeDigraphEnclosure", p.includeDigraphEnclosure, j,
true);
7907 getOptional<bool>(
"includeClients", p.includeClients, j,
false);
7908 getOptional<std::string>(
"coreRpStyling", p.coreRpStyling, j,
"[shape=hexagon color=firebrick style=filled]");
7909 getOptional<std::string>(
"leafRpStyling", p.leafRpStyling, j,
"[shape=box color=gray style=filled]");
7910 getOptional<std::string>(
"clientStyling", p.clientStyling, j);
7911 getOptional<std::string>(
"runCmd", p.runCmd, j);
7916 JSON_SERIALIZED_CLASS(RallypointServerRouteMap)
7919 IMPLEMENT_JSON_SERIALIZATION()
7948 static void to_json(nlohmann::json& j,
const RallypointServerRouteMap& p)
7951 TOJSON_IMPL(fileName),
7952 TOJSON_IMPL(minRefreshSecs),
7953 TOJSON_IMPL(enabled),
7957 static void from_json(
const nlohmann::json& j, RallypointServerRouteMap& p)
7960 getOptional<std::string>(
"fileName", p.fileName, j);
7961 getOptional<int>(
"minRefreshSecs", p.minRefreshSecs, j, 5);
7962 getOptional<bool>(
"enabled", p.enabled, j,
false);
7963 getOptional<std::string>(
"runCmd", p.runCmd, j);
7968 JSON_SERIALIZED_CLASS(ExternalHealthCheckResponder)
7980 IMPLEMENT_JSON_SERIALIZATION()
7999 immediateClose =
true;
8003 static void to_json(nlohmann::json& j,
const ExternalHealthCheckResponder& p)
8006 TOJSON_IMPL(listenPort),
8007 TOJSON_IMPL(immediateClose)
8010 static void from_json(
const nlohmann::json& j, ExternalHealthCheckResponder& p)
8013 getOptional<int>(
"listenPort", p.listenPort, j, 0);
8014 getOptional<bool>(
"immediateClose", p.immediateClose, j,
true);
8019 JSON_SERIALIZED_CLASS(PeeringConfiguration)
8029 IMPLEMENT_JSON_SERIALIZATION()
8059 static void to_json(nlohmann::json& j,
const PeeringConfiguration& p)
8063 TOJSON_IMPL(version),
8064 TOJSON_IMPL(comments),
8068 static void from_json(
const nlohmann::json& j, PeeringConfiguration& p)
8071 getOptional<std::string>(
"id", p.id, j);
8072 getOptional<int>(
"version", p.version, j, 0);
8073 getOptional<std::string>(
"comments", p.comments, j);
8074 getOptional<std::vector<RallypointPeer>>(
"peers", p.peers, j);
8078 JSON_SERIALIZED_CLASS(IgmpSnooping)
8088 IMPLEMENT_JSON_SERIALIZATION()
8111 queryIntervalMs = 125000;
8112 subscriptionTimeoutMs = 0;
8116 static void to_json(nlohmann::json& j,
const IgmpSnooping& p)
8119 TOJSON_IMPL(enabled),
8120 TOJSON_IMPL(queryIntervalMs),
8121 TOJSON_IMPL(subscriptionTimeoutMs)
8124 static void from_json(
const nlohmann::json& j, IgmpSnooping& p)
8127 getOptional<bool>(
"enabled", p.enabled, j);
8128 getOptional<int>(
"queryIntervalMs", p.queryIntervalMs, j, 125000);
8129 getOptional<int>(
"subscriptionTimeoutMs", p.subscriptionTimeoutMs, j, 0);
8134 JSON_SERIALIZED_CLASS(RallypointReflector)
8143 IMPLEMENT_JSON_SERIALIZATION()
8158 } DirectionRestriction_t;
8190 multicastInterfaceName.clear();
8191 additionalTx.clear();
8192 directionRestriction = drNone;
8196 static void to_json(nlohmann::json& j,
const RallypointReflector& p)
8202 TOJSON_IMPL(multicastInterfaceName),
8203 TOJSON_IMPL(additionalTx),
8204 TOJSON_IMPL(directionRestriction)
8207 static void from_json(
const nlohmann::json& j, RallypointReflector& p)
8210 j.at(
"id").get_to(p.id);
8211 j.at(
"rx").get_to(p.rx);
8212 j.at(
"tx").get_to(p.tx);
8213 getOptional<std::string>(
"multicastInterfaceName", p.multicastInterfaceName, j);
8214 getOptional<std::vector<NetworkAddress>>(
"additionalTx", p.additionalTx, j);
8215 getOptional<RallypointReflector::DirectionRestriction_t>(
"directionRestriction", p.directionRestriction, j, RallypointReflector::DirectionRestriction_t::drNone);
8220 JSON_SERIALIZED_CLASS(RallypointUdpStreamingIpvX)
8229 IMPLEMENT_JSON_SERIALIZATION()
8251 static void to_json(nlohmann::json& j,
const RallypointUdpStreamingIpvX& p)
8254 TOJSON_IMPL(enabled),
8255 TOJSON_IMPL(external)
8258 static void from_json(
const nlohmann::json& j, RallypointUdpStreamingIpvX& p)
8261 getOptional<bool>(
"enabled", p.enabled, j,
true);
8262 getOptional<NetworkAddress>(
"external", p.external, j);
8266 JSON_SERIALIZED_CLASS(RallypointUdpStreaming)
8275 IMPLEMENT_JSON_SERIALIZATION()
8286 ctSharedKeyAes256FullIv = 1,
8289 ctSharedKeyAes256IdxIv = 2,
8292 ctSharedKeyChaCha20FullIv = 3,
8295 ctSharedKeyChaCha20IdxIv = 4
8331 cryptoType = CryptoType_t::ctSharedKeyAes256FullIv;
8335 keepaliveIntervalSecs = 15;
8336 priority = TxPriority_t::priVoice;
8341 static void to_json(nlohmann::json& j,
const RallypointUdpStreaming& p)
8344 TOJSON_IMPL(enabled),
8345 TOJSON_IMPL(cryptoType),
8346 TOJSON_IMPL(listenPort),
8347 TOJSON_IMPL(keepaliveIntervalSecs),
8350 TOJSON_IMPL(priority),
8354 static void from_json(
const nlohmann::json& j, RallypointUdpStreaming& p)
8357 getOptional<bool>(
"enabled", p.enabled, j,
true);
8358 getOptional<RallypointUdpStreaming::CryptoType_t>(
"cryptoType", p.cryptoType, j, RallypointUdpStreaming::CryptoType_t::ctSharedKeyAes256FullIv);
8359 getOptional<int>(
"listenPort", p.listenPort, j, 7444);
8360 getOptional<int>(
"keepaliveIntervalSecs", p.keepaliveIntervalSecs, j, 15);
8361 getOptional<RallypointUdpStreamingIpvX>(
"ipv4", p.ipv4, j);
8362 getOptional<RallypointUdpStreamingIpvX>(
"ipv6", p.ipv6, j);
8363 getOptional<TxPriority_t>(
"priority", p.priority, j, TxPriority_t::priVoice);
8364 getOptional<int>(
"ttl", p.ttl, j, 64);
8368 JSON_SERIALIZED_CLASS(RallypointRpRtTimingBehavior)
8377 IMPLEMENT_JSON_SERIALIZATION()
8422 static void to_json(nlohmann::json& j,
const RallypointRpRtTimingBehavior& p)
8425 TOJSON_IMPL(behavior),
8426 TOJSON_IMPL(atOrAboveMs),
8430 static void from_json(
const nlohmann::json& j, RallypointRpRtTimingBehavior& p)
8433 getOptional<RallypointRpRtTimingBehavior::BehaviorType_t>(
"behavior", p.behavior, j, RallypointRpRtTimingBehavior::BehaviorType_t::btNone);
8434 getOptional<uint32_t>(
"atOrAboveMs", p.atOrAboveMs, j, 0);
8435 getOptional<std::string>(
"runCmd", p.runCmd, j);
8440 JSON_SERIALIZED_CLASS(RallypointWebsocketSettings)
8449 IMPLEMENT_JSON_SERIALIZATION()
8471 certificate.clear();
8475 static void to_json(nlohmann::json& j,
const RallypointWebsocketSettings& p)
8478 TOJSON_IMPL(enabled),
8479 TOJSON_IMPL(listenPort),
8480 TOJSON_IMPL(certificate)
8483 static void from_json(
const nlohmann::json& j, RallypointWebsocketSettings& p)
8486 getOptional<bool>(
"enabled", p.enabled, j,
false);
8487 getOptional<int>(
"listenPort", p.listenPort, j, 8443);
8488 getOptional<SecurityCertificate>(
"certificate", p.certificate, j);
8494 JSON_SERIALIZED_CLASS(RallypointAdvertisingSettings)
8503 IMPLEMENT_JSON_SERIALIZATION()
8534 serviceName =
"_rallypoint._tcp.local.";
8535 interfaceName.clear();
8541 static void to_json(nlohmann::json& j,
const RallypointAdvertisingSettings& p)
8544 TOJSON_IMPL(enabled),
8545 TOJSON_IMPL(hostName),
8546 TOJSON_IMPL(serviceName),
8547 TOJSON_IMPL(interfaceName),
8552 static void from_json(
const nlohmann::json& j, RallypointAdvertisingSettings& p)
8555 getOptional<bool>(
"enabled", p.enabled, j,
false);
8556 getOptional<std::string>(
"hostName", p.hostName, j);
8557 getOptional<std::string>(
"serviceName", p.serviceName, j,
"_rallypoint._tcp.local.");
8558 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
8560 getOptional<int>(
"port", p.port, j, 0);
8561 getOptional<int>(
"ttl", p.ttl, j, 60);
8566 JSON_SERIALIZED_CLASS(RallypointExtendedGroupRestriction)
8575 IMPLEMENT_JSON_SERIALIZATION()
8593 restrictions.clear();
8597 static void to_json(nlohmann::json& j,
const RallypointExtendedGroupRestriction& p)
8601 TOJSON_IMPL(restrictions)
8604 static void from_json(
const nlohmann::json& j, RallypointExtendedGroupRestriction& p)
8607 getOptional<std::string>(
"id", p.id, j);
8608 getOptional<std::vector<StringRestrictionList>>(
"restrictions", p.restrictions, j);
8613 JSON_SERIALIZED_CLASS(RallypointServer)
8624 IMPLEMENT_JSON_SERIALIZATION()
8807 interfaceName.clear();
8808 certificate.clear();
8809 allowMulticastForwarding =
false;
8810 peeringConfiguration.clear();
8811 peeringConfigurationFileName.clear();
8812 peeringConfigurationFileCommand.clear();
8813 peeringConfigurationFileCheckSecs = 60;
8815 statusReport.clear();
8818 externalHealthCheckResponder.clear();
8819 allowPeerForwarding =
false;
8820 multicastInterfaceName.clear();
8823 forwardDiscoveredGroups =
false;
8824 forwardMulticastAddressing =
false;
8826 disableMessageSigning =
false;
8827 multicastRestrictions.clear();
8828 igmpSnooping.clear();
8829 staticReflectors.clear();
8830 tcpTxOptions.clear();
8831 multicastTxOptions.clear();
8832 certStoreFileName.clear();
8833 certStorePasswordHex.clear();
8834 groupRestrictions.clear();
8835 configurationCheckSignalName =
"rts.7b392d1.${id}";
8838 udpStreaming.clear();
8840 normalTaskQueueBias = 0;
8841 enableLeafReflectionReverseSubscription =
false;
8842 disableLoopDetection =
false;
8843 maxSecurityLevel = 0;
8845 maxOutboundPeerConnectionIntervalDeltaSecs = 15;
8846 peerRtTestIntervalMs = 60000;
8847 peerRtBehaviors.clear();
8850 advertising.clear();
8851 extendedGroupRestrictions.clear();
8852 groupRestrictionAccessPolicyType = GroupRestrictionAccessPolicyType_t::graptPermissive;
8853 ipFamily = IpFamilyType_t::ifIpUnspec;
8857 extraMeshes.clear();
8862 static void to_json(nlohmann::json& j,
const RallypointServer& p)
8865 TOJSON_IMPL(fipsCrypto),
8866 TOJSON_IMPL(watchdog),
8868 TOJSON_IMPL(listenPort),
8869 TOJSON_IMPL(interfaceName),
8870 TOJSON_IMPL(certificate),
8871 TOJSON_IMPL(allowMulticastForwarding),
8873 TOJSON_IMPL(peeringConfigurationFileName),
8874 TOJSON_IMPL(peeringConfigurationFileCommand),
8875 TOJSON_IMPL(peeringConfigurationFileCheckSecs),
8876 TOJSON_IMPL(ioPools),
8877 TOJSON_IMPL(statusReport),
8878 TOJSON_IMPL(limits),
8879 TOJSON_IMPL(linkGraph),
8880 TOJSON_IMPL(externalHealthCheckResponder),
8881 TOJSON_IMPL(allowPeerForwarding),
8882 TOJSON_IMPL(multicastInterfaceName),
8884 TOJSON_IMPL(discovery),
8885 TOJSON_IMPL(forwardDiscoveredGroups),
8886 TOJSON_IMPL(forwardMulticastAddressing),
8887 TOJSON_IMPL(isMeshLeaf),
8888 TOJSON_IMPL(disableMessageSigning),
8889 TOJSON_IMPL(multicastRestrictions),
8890 TOJSON_IMPL(igmpSnooping),
8891 TOJSON_IMPL(staticReflectors),
8892 TOJSON_IMPL(tcpTxOptions),
8893 TOJSON_IMPL(multicastTxOptions),
8894 TOJSON_IMPL(certStoreFileName),
8895 TOJSON_IMPL(certStorePasswordHex),
8896 TOJSON_IMPL(groupRestrictions),
8897 TOJSON_IMPL(configurationCheckSignalName),
8898 TOJSON_IMPL(featureset),
8899 TOJSON_IMPL(licensing),
8900 TOJSON_IMPL(udpStreaming),
8901 TOJSON_IMPL(sysFlags),
8902 TOJSON_IMPL(normalTaskQueueBias),
8903 TOJSON_IMPL(enableLeafReflectionReverseSubscription),
8904 TOJSON_IMPL(disableLoopDetection),
8905 TOJSON_IMPL(maxSecurityLevel),
8906 TOJSON_IMPL(routeMap),
8907 TOJSON_IMPL(maxOutboundPeerConnectionIntervalDeltaSecs),
8908 TOJSON_IMPL(peerRtTestIntervalMs),
8909 TOJSON_IMPL(peerRtBehaviors),
8910 TOJSON_IMPL(websocket),
8912 TOJSON_IMPL(advertising),
8913 TOJSON_IMPL(extendedGroupRestrictions),
8914 TOJSON_IMPL(groupRestrictionAccessPolicyType),
8915 TOJSON_IMPL(ipFamily),
8916 TOJSON_IMPL(rxCapture),
8917 TOJSON_IMPL(txCapture),
8918 TOJSON_IMPL(meshName),
8919 TOJSON_IMPL(extraMeshes),
8923 static void from_json(
const nlohmann::json& j, RallypointServer& p)
8926 getOptional<FipsCryptoSettings>(
"fipsCrypto", p.fipsCrypto, j);
8927 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
8928 getOptional<std::string>(
"id", p.id, j);
8929 getOptional<SecurityCertificate>(
"certificate", p.certificate, j);
8930 getOptional<std::string>(
"interfaceName", p.interfaceName, j);
8931 getOptional<int>(
"listenPort", p.listenPort, j, 7443);
8932 getOptional<bool>(
"allowMulticastForwarding", p.allowMulticastForwarding, j,
false);
8934 getOptional<std::string>(
"peeringConfigurationFileName", p.peeringConfigurationFileName, j);
8935 getOptional<std::string>(
"peeringConfigurationFileCommand", p.peeringConfigurationFileCommand, j);
8936 getOptional<int>(
"peeringConfigurationFileCheckSecs", p.peeringConfigurationFileCheckSecs, j, 60);
8937 getOptional<int>(
"ioPools", p.ioPools, j, -1);
8938 getOptional<RallypointServerStatusReportConfiguration>(
"statusReport", p.statusReport, j);
8939 getOptional<RallypointServerLimits>(
"limits", p.limits, j);
8940 getOptional<RallypointServerLinkGraph>(
"linkGraph", p.linkGraph, j);
8941 getOptional<ExternalHealthCheckResponder>(
"externalHealthCheckResponder", p.externalHealthCheckResponder, j);
8942 getOptional<bool>(
"allowPeerForwarding", p.allowPeerForwarding, j,
false);
8943 getOptional<std::string>(
"multicastInterfaceName", p.multicastInterfaceName, j);
8944 getOptional<Tls>(
"tls", p.tls, j);
8945 getOptional<DiscoveryConfiguration>(
"discovery", p.discovery, j);
8946 getOptional<bool>(
"forwardDiscoveredGroups", p.forwardDiscoveredGroups, j,
false);
8947 getOptional<bool>(
"forwardMulticastAddressing", p.forwardMulticastAddressing, j,
false);
8948 getOptional<bool>(
"isMeshLeaf", p.isMeshLeaf, j,
false);
8949 getOptional<bool>(
"disableMessageSigning", p.disableMessageSigning, j,
false);
8950 getOptional<NetworkAddressRestrictionList>(
"multicastRestrictions", p.multicastRestrictions, j);
8951 getOptional<IgmpSnooping>(
"igmpSnooping", p.igmpSnooping, j);
8952 getOptional<std::vector<RallypointReflector>>(
"staticReflectors", p.staticReflectors, j);
8953 getOptional<TcpNetworkTxOptions>(
"tcpTxOptions", p.tcpTxOptions, j);
8954 getOptional<NetworkTxOptions>(
"multicastTxOptions", p.multicastTxOptions, j);
8955 getOptional<std::string>(
"certStoreFileName", p.certStoreFileName, j);
8956 getOptional<std::string>(
"certStorePasswordHex", p.certStorePasswordHex, j);
8957 getOptional<StringRestrictionList>(
"groupRestrictions", p.groupRestrictions, j);
8958 getOptional<std::string>(
"configurationCheckSignalName", p.configurationCheckSignalName, j,
"rts.7b392d1.${id}");
8959 getOptional<Licensing>(
"licensing", p.licensing, j);
8960 getOptional<Featureset>(
"featureset", p.featureset, j);
8961 getOptional<RallypointUdpStreaming>(
"udpStreaming", p.udpStreaming, j);
8962 getOptional<uint32_t>(
"sysFlags", p.sysFlags, j, 0);
8963 getOptional<uint32_t>(
"normalTaskQueueBias", p.normalTaskQueueBias, j, 0);
8964 getOptional<bool>(
"enableLeafReflectionReverseSubscription", p.enableLeafReflectionReverseSubscription, j,
false);
8965 getOptional<bool>(
"disableLoopDetection", p.disableLoopDetection, j,
false);
8966 getOptional<uint32_t>(
"maxSecurityLevel", p.maxSecurityLevel, j, 0);
8967 getOptional<RallypointServerRouteMap>(
"routeMap", p.routeMap, j);
8968 getOptional<uint32_t>(
"maxOutboundPeerConnectionIntervalDeltaSecs", p.maxOutboundPeerConnectionIntervalDeltaSecs, j, 15);
8969 getOptional<int>(
"peerRtTestIntervalMs", p.peerRtTestIntervalMs, j, 60000);
8970 getOptional<std::vector<RallypointRpRtTimingBehavior>>(
"peerRtBehaviors", p.peerRtBehaviors, j);
8971 getOptional<RallypointWebsocketSettings>(
"websocket", p.websocket, j);
8972 getOptional<NsmConfiguration>(
"nsm", p.nsm, j);
8973 getOptional<RallypointAdvertisingSettings>(
"advertising", p.advertising, j);
8974 getOptional<std::vector<RallypointExtendedGroupRestriction>>(
"extendedGroupRestrictions", p.extendedGroupRestrictions, j);
8975 getOptional<GroupRestrictionAccessPolicyType_t>(
"groupRestrictionAccessPolicyType", p.groupRestrictionAccessPolicyType, j, GroupRestrictionAccessPolicyType_t::graptPermissive);
8976 getOptional<IpFamilyType_t>(
"ipFamily", p.ipFamily, j, IpFamilyType_t::ifIpUnspec);
8977 getOptional<PacketCapturer>(
"rxCapture", p.rxCapture, j);
8978 getOptional<PacketCapturer>(
"txCapture", p.txCapture, j);
8979 getOptional<std::string>(
"meshName", p.meshName, j);
8980 getOptional<std::vector<std::string>>(
"extraMeshes", p.extraMeshes, j);
8981 getOptional<TuningSettings>(
"tuning", p.tuning, j);
8985 JSON_SERIALIZED_CLASS(PlatformDiscoveredService)
8997 IMPLEMENT_JSON_SERIALIZATION()
9032 configurationVersion = 0;
9036 static void to_json(nlohmann::json& j,
const PlatformDiscoveredService& p)
9042 TOJSON_IMPL(address),
9044 TOJSON_IMPL(configurationVersion)
9047 static void from_json(
const nlohmann::json& j, PlatformDiscoveredService& p)
9050 getOptional<std::string>(
"id", p.id, j);
9051 getOptional<std::string>(
"type", p.type, j);
9052 getOptional<std::string>(
"name", p.name, j);
9053 getOptional<NetworkAddress>(
"address", p.address, j);
9054 getOptional<std::string>(
"uri", p.uri, j);
9055 getOptional<uint32_t>(
"configurationVersion", p.configurationVersion, j, 0);
9095 IMPLEMENT_JSON_SERIALIZATION()
9141 mostRecentFirst =
true;
9142 startedOnOrAfter = 0;
9143 endedOnOrBefore = 0;
9146 onlyCommitted =
true;
9154 static void to_json(nlohmann::json& j,
const TimelineQueryParameters& p)
9157 TOJSON_IMPL(maxCount),
9158 TOJSON_IMPL(mostRecentFirst),
9159 TOJSON_IMPL(startedOnOrAfter),
9160 TOJSON_IMPL(endedOnOrBefore),
9161 TOJSON_IMPL(onlyDirection),
9162 TOJSON_IMPL(onlyType),
9163 TOJSON_IMPL(onlyCommitted),
9164 TOJSON_IMPL(onlyAlias),
9165 TOJSON_IMPL(onlyNodeId),
9166 TOJSON_IMPL(onlyTxId),
9170 static void from_json(
const nlohmann::json& j, TimelineQueryParameters& p)
9173 getOptional<long>(
"maxCount", p.maxCount, j, 50);
9174 getOptional<bool>(
"mostRecentFirst", p.mostRecentFirst, j,
false);
9175 getOptional<uint64_t>(
"startedOnOrAfter", p.startedOnOrAfter, j, 0);
9176 getOptional<uint64_t>(
"endedOnOrBefore", p.endedOnOrBefore, j, 0);
9177 getOptional<int>(
"onlyDirection", p.onlyDirection, j, 0);
9178 getOptional<int>(
"onlyType", p.onlyType, j, 0);
9179 getOptional<bool>(
"onlyCommitted", p.onlyCommitted, j,
true);
9180 getOptional<std::string>(
"onlyAlias", p.onlyAlias, j, EMPTY_STRING);
9181 getOptional<std::string>(
"onlyNodeId", p.onlyNodeId, j, EMPTY_STRING);
9182 getOptional<int>(
"onlyTxId", p.onlyTxId, j, 0);
9183 getOptional<std::string>(
"sql", p.sql, j, EMPTY_STRING);
9187 JSON_SERIALIZED_CLASS(CertStoreCertificate)
9196 IMPLEMENT_JSON_SERIALIZATION()
9223 certificatePem.clear();
9224 privateKeyPem.clear();
9225 internalData =
nullptr;
9230 static void to_json(nlohmann::json& j,
const CertStoreCertificate& p)
9234 TOJSON_IMPL(certificatePem),
9235 TOJSON_IMPL(privateKeyPem),
9239 static void from_json(
const nlohmann::json& j, CertStoreCertificate& p)
9242 j.at(
"id").get_to(p.id);
9243 j.at(
"certificatePem").get_to(p.certificatePem);
9244 getOptional<std::string>(
"privateKeyPem", p.privateKeyPem, j, EMPTY_STRING);
9245 getOptional<std::string>(
"tags", p.tags, j, EMPTY_STRING);
9249 JSON_SERIALIZED_CLASS(CertStore)
9258 IMPLEMENT_JSON_SERIALIZATION()
9276 certificates.clear();
9280 static void to_json(nlohmann::json& j,
const CertStore& p)
9284 TOJSON_IMPL(certificates)
9287 static void from_json(
const nlohmann::json& j, CertStore& p)
9290 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9291 getOptional<std::vector<CertStoreCertificate>>(
"certificates", p.certificates, j);
9295 JSON_SERIALIZED_CLASS(CertStoreCertificateElement)
9304 IMPLEMENT_JSON_SERIALIZATION()
9328 hasPrivateKey =
false;
9333 static void to_json(nlohmann::json& j,
const CertStoreCertificateElement& p)
9337 TOJSON_IMPL(hasPrivateKey),
9341 if(!p.certificatePem.empty())
9343 j[
"certificatePem"] = p.certificatePem;
9346 static void from_json(
const nlohmann::json& j, CertStoreCertificateElement& p)
9349 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9350 getOptional<bool>(
"hasPrivateKey", p.hasPrivateKey, j,
false);
9351 getOptional<std::string>(
"certificatePem", p.certificatePem, j, EMPTY_STRING);
9352 getOptional<std::string>(
"tags", p.tags, j, EMPTY_STRING);
9356 JSON_SERIALIZED_CLASS(CertStoreDescriptor)
9365 IMPLEMENT_JSON_SERIALIZATION()
9395 certificates.clear();
9399 static void to_json(nlohmann::json& j,
const CertStoreDescriptor& p)
9403 TOJSON_IMPL(fileName),
9404 TOJSON_IMPL(version),
9406 TOJSON_IMPL(certificates)
9409 static void from_json(
const nlohmann::json& j, CertStoreDescriptor& p)
9412 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9413 getOptional<std::string>(
"fileName", p.fileName, j, EMPTY_STRING);
9414 getOptional<int>(
"version", p.version, j, 0);
9415 getOptional<int>(
"flags", p.flags, j, 0);
9416 getOptional<std::vector<CertStoreCertificateElement>>(
"certificates", p.certificates, j);
9420 JSON_SERIALIZED_CLASS(CertificateSubjectElement)
9429 IMPLEMENT_JSON_SERIALIZATION()
9451 static void to_json(nlohmann::json& j,
const CertificateSubjectElement& p)
9458 static void from_json(
const nlohmann::json& j, CertificateSubjectElement& p)
9461 getOptional<std::string>(
"name", p.name, j, EMPTY_STRING);
9462 getOptional<std::string>(
"value", p.value, j, EMPTY_STRING);
9467 JSON_SERIALIZED_CLASS(CertificateDescriptor)
9476 IMPLEMENT_JSON_SERIALIZATION()
9527 fingerprint.clear();
9528 subjectElements.clear();
9529 certificatePem.clear();
9530 publicKeyPem.clear();
9534 static void to_json(nlohmann::json& j,
const CertificateDescriptor& p)
9537 TOJSON_IMPL(subject),
9538 TOJSON_IMPL(issuer),
9539 TOJSON_IMPL(selfSigned),
9540 TOJSON_IMPL(version),
9541 TOJSON_IMPL(notBefore),
9542 TOJSON_IMPL(notAfter),
9543 TOJSON_IMPL(serial),
9544 TOJSON_IMPL(fingerprint),
9545 TOJSON_IMPL(subjectElements),
9546 TOJSON_IMPL(certificatePem),
9547 TOJSON_IMPL(publicKeyPem)
9550 static void from_json(
const nlohmann::json& j, CertificateDescriptor& p)
9553 getOptional<std::string>(
"subject", p.subject, j, EMPTY_STRING);
9554 getOptional<std::string>(
"issuer", p.issuer, j, EMPTY_STRING);
9555 getOptional<bool>(
"selfSigned", p.selfSigned, j,
false);
9556 getOptional<int>(
"version", p.version, j, 0);
9557 getOptional<std::string>(
"notBefore", p.notBefore, j, EMPTY_STRING);
9558 getOptional<std::string>(
"notAfter", p.notAfter, j, EMPTY_STRING);
9559 getOptional<std::string>(
"serial", p.serial, j, EMPTY_STRING);
9560 getOptional<std::string>(
"fingerprint", p.fingerprint, j, EMPTY_STRING);
9561 getOptional<std::string>(
"certificatePem", p.certificatePem, j, EMPTY_STRING);
9562 getOptional<std::string>(
"publicKeyPem", p.publicKeyPem, j, EMPTY_STRING);
9563 getOptional<std::vector<CertificateSubjectElement>>(
"subjectElements", p.subjectElements, j);
9568 JSON_SERIALIZED_CLASS(RiffDescriptor)
9580 IMPLEMENT_JSON_SERIALIZATION()
9621 certDescriptor.clear();
9626 static void to_json(nlohmann::json& j,
const RiffDescriptor& p)
9630 TOJSON_IMPL(verified),
9631 TOJSON_IMPL(channels),
9632 TOJSON_IMPL(sampleCount),
9634 TOJSON_IMPL(certPem),
9635 TOJSON_IMPL(certDescriptor),
9636 TOJSON_IMPL(signature)
9640 static void from_json(
const nlohmann::json& j, RiffDescriptor& p)
9643 FROMJSON_IMPL(file, std::string, EMPTY_STRING);
9644 FROMJSON_IMPL(verified,
bool,
false);
9645 FROMJSON_IMPL(channels,
int, 0);
9646 FROMJSON_IMPL(sampleCount,
int, 0);
9647 FROMJSON_IMPL(meta, std::string, EMPTY_STRING);
9648 FROMJSON_IMPL(certPem, std::string, EMPTY_STRING);
9649 getOptional<CertificateDescriptor>(
"certDescriptor", p.certDescriptor, j);
9650 FROMJSON_IMPL(signature, std::string, EMPTY_STRING);
9655 JSON_SERIALIZED_CLASS(BridgeCreationDetail)
9664 IMPLEMENT_JSON_SERIALIZATION()
9682 csAlreadyExists = -3,
9685 csInvalidConfiguration = -4,
9691 csInsufficientGroups = -6,
9694 csTooManyGroups = -7,
9697 csDuplicateGroup = -8,
9700 csLocalLoopDetected = -9,
9717 status = csUndefined;
9721 static void to_json(nlohmann::json& j,
const BridgeCreationDetail& p)
9728 static void from_json(
const nlohmann::json& j, BridgeCreationDetail& p)
9731 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9732 getOptional<BridgeCreationDetail::CreationStatus_t>(
"status", p.status, j, BridgeCreationDetail::CreationStatus_t::csUndefined);
9735 JSON_SERIALIZED_CLASS(GroupConnectionDetail)
9744 IMPLEMENT_JSON_SERIALIZATION()
9756 ctDirectDatagram = 1,
9785 connectionType = ctUndefined;
9792 static void to_json(nlohmann::json& j,
const GroupConnectionDetail& p)
9796 TOJSON_IMPL(connectionType),
9798 TOJSON_IMPL(asFailover),
9804 j[
"asFailover"] = p.asFailover;
9807 static void from_json(
const nlohmann::json& j, GroupConnectionDetail& p)
9810 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9811 getOptional<GroupConnectionDetail::ConnectionType_t>(
"connectionType", p.connectionType, j, GroupConnectionDetail::ConnectionType_t::ctUndefined);
9812 getOptional<std::string>(
"peer", p.peer, j, EMPTY_STRING);
9813 getOptional<bool>(
"asFailover", p.asFailover, j,
false);
9814 getOptional<std::string>(
"reason", p.reason, j, EMPTY_STRING);
9818 JSON_SERIALIZED_CLASS(GroupTxDetail)
9827 IMPLEMENT_JSON_SERIALIZATION()
9845 txsNotAnAudioGroup = -1,
9851 txsNotConnected = -3,
9854 txsAlreadyTransmitting = -4,
9857 txsInvalidParams = -5,
9860 txsPriorityTooLow = -6,
9863 txsRxActiveOnNonFdx = -7,
9866 txsCannotSubscribeToInput = -8,
9872 txsTxEndedWithFailure = -10,
9901 status = txsUndefined;
9904 nonFdxMsHangRemaining = 0;
9909 static void to_json(nlohmann::json& j,
const GroupTxDetail& p)
9913 TOJSON_IMPL(status),
9914 TOJSON_IMPL(localPriority),
9919 if(p.status == GroupTxDetail::TxStatus_t::txsPriorityTooLow)
9921 j[
"remotePriority"] = p.remotePriority;
9923 else if(p.status == GroupTxDetail::TxStatus_t::txsRxActiveOnNonFdx)
9925 j[
"nonFdxMsHangRemaining"] = p.nonFdxMsHangRemaining;
9928 static void from_json(
const nlohmann::json& j, GroupTxDetail& p)
9931 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
9932 getOptional<GroupTxDetail::TxStatus_t>(
"status", p.status, j, GroupTxDetail::TxStatus_t::txsUndefined);
9933 getOptional<int>(
"localPriority", p.localPriority, j, 0);
9934 getOptional<int>(
"remotePriority", p.remotePriority, j, 0);
9935 getOptional<long>(
"nonFdxMsHangRemaining", p.nonFdxMsHangRemaining, j, 0);
9936 getOptional<uint32_t>(
"txId", p.txId, j, 0);
9940 JSON_SERIALIZED_CLASS(GroupCreationDetail)
9949 IMPLEMENT_JSON_SERIALIZATION()
9967 csConflictingRpListAndCluster = -2,
9970 csAlreadyExists = -3,
9973 csInvalidConfiguration = -4,
9979 csCryptoFailure = -6,
9982 csAudioInputFailure = -7,
9985 csAudioOutputFailure = -8,
9988 csUnsupportedAudioEncoder = -9,
9994 csInvalidTransport = -11,
10011 status = csUndefined;
10015 static void to_json(nlohmann::json& j,
const GroupCreationDetail& p)
10017 j = nlohmann::json{
10019 TOJSON_IMPL(status)
10022 static void from_json(
const nlohmann::json& j, GroupCreationDetail& p)
10025 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
10026 getOptional<GroupCreationDetail::CreationStatus_t>(
"status", p.status, j, GroupCreationDetail::CreationStatus_t::csUndefined);
10031 JSON_SERIALIZED_CLASS(GroupReconfigurationDetail)
10040 IMPLEMENT_JSON_SERIALIZATION()
10058 rsInvalidConfiguration = -2,
10061 rsInvalidJson = -3,
10064 rsAudioInputFailure = -4,
10067 rsAudioOutputFailure = -5,
10070 rsDoesNotExist = -6,
10073 rsAudioInputInUse = -7,
10076 rsAudioDisabledForGroup = -8,
10079 rsGroupIsNotAudio = -9
10080 } ReconfigurationStatus_t;
10096 status = rsUndefined;
10100 static void to_json(nlohmann::json& j,
const GroupReconfigurationDetail& p)
10102 j = nlohmann::json{
10104 TOJSON_IMPL(status)
10107 static void from_json(
const nlohmann::json& j, GroupReconfigurationDetail& p)
10110 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
10111 getOptional<GroupReconfigurationDetail::ReconfigurationStatus_t>(
"status", p.status, j, GroupReconfigurationDetail::ReconfigurationStatus_t::rsUndefined);
10116 JSON_SERIALIZED_CLASS(GroupHealthReport)
10125 IMPLEMENT_JSON_SERIALIZATION()
10131 uint64_t lastErrorTs;
10132 uint64_t decryptionErrors;
10133 uint64_t encryptionErrors;
10134 uint64_t unsupportDecoderErrors;
10135 uint64_t decoderFailures;
10136 uint64_t decoderStartFailures;
10137 uint64_t inboundRtpPacketAllocationFailures;
10138 uint64_t inboundRtpPacketLoadFailures;
10139 uint64_t latePacketsDiscarded;
10140 uint64_t jitterBufferInsertionFailures;
10141 uint64_t presenceDeserializationFailures;
10142 uint64_t notRtpErrors;
10143 uint64_t generalErrors;
10144 uint64_t inboundRtpProcessorAllocationFailures;
10155 decryptionErrors = 0;
10156 encryptionErrors = 0;
10157 unsupportDecoderErrors = 0;
10158 decoderFailures = 0;
10159 decoderStartFailures = 0;
10160 inboundRtpPacketAllocationFailures = 0;
10161 inboundRtpPacketLoadFailures = 0;
10162 latePacketsDiscarded = 0;
10163 jitterBufferInsertionFailures = 0;
10164 presenceDeserializationFailures = 0;
10167 inboundRtpProcessorAllocationFailures = 0;
10173 j = nlohmann::json{
10175 TOJSON_IMPL(lastErrorTs),
10176 TOJSON_IMPL(decryptionErrors),
10177 TOJSON_IMPL(encryptionErrors),
10178 TOJSON_IMPL(unsupportDecoderErrors),
10179 TOJSON_IMPL(decoderFailures),
10180 TOJSON_IMPL(decoderStartFailures),
10181 TOJSON_IMPL(inboundRtpPacketAllocationFailures),
10182 TOJSON_IMPL(inboundRtpPacketLoadFailures),
10183 TOJSON_IMPL(latePacketsDiscarded),
10184 TOJSON_IMPL(jitterBufferInsertionFailures),
10185 TOJSON_IMPL(presenceDeserializationFailures),
10186 TOJSON_IMPL(notRtpErrors),
10187 TOJSON_IMPL(generalErrors),
10188 TOJSON_IMPL(inboundRtpProcessorAllocationFailures)
10191 static void from_json(
const nlohmann::json& j, GroupHealthReport& p)
10194 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
10195 getOptional<uint64_t>(
"lastErrorTs", p.lastErrorTs, j, 0);
10196 getOptional<uint64_t>(
"decryptionErrors", p.decryptionErrors, j, 0);
10197 getOptional<uint64_t>(
"encryptionErrors", p.encryptionErrors, j, 0);
10198 getOptional<uint64_t>(
"unsupportDecoderErrors", p.unsupportDecoderErrors, j, 0);
10199 getOptional<uint64_t>(
"decoderFailures", p.decoderFailures, j, 0);
10200 getOptional<uint64_t>(
"decoderStartFailures", p.decoderStartFailures, j, 0);
10201 getOptional<uint64_t>(
"inboundRtpPacketAllocationFailures", p.inboundRtpPacketAllocationFailures, j, 0);
10202 getOptional<uint64_t>(
"inboundRtpPacketLoadFailures", p.inboundRtpPacketLoadFailures, j, 0);
10203 getOptional<uint64_t>(
"latePacketsDiscarded", p.latePacketsDiscarded, j, 0);
10204 getOptional<uint64_t>(
"jitterBufferInsertionFailures", p.jitterBufferInsertionFailures, j, 0);
10205 getOptional<uint64_t>(
"presenceDeserializationFailures", p.presenceDeserializationFailures, j, 0);
10206 getOptional<uint64_t>(
"notRtpErrors", p.notRtpErrors, j, 0);
10207 getOptional<uint64_t>(
"generalErrors", p.generalErrors, j, 0);
10208 getOptional<uint64_t>(
"inboundRtpProcessorAllocationFailures", p.inboundRtpProcessorAllocationFailures, j, 0);
10212 JSON_SERIALIZED_CLASS(InboundProcessorStats)
10221 IMPLEMENT_JSON_SERIALIZATION()
10228 uint64_t minRtpSamplesInQueue;
10229 uint64_t maxRtpSamplesInQueue;
10230 uint64_t totalSamplesTrimmed;
10231 uint64_t underruns;
10233 uint64_t samplesInQueue;
10234 uint64_t totalPacketsReceived;
10235 uint64_t totalPacketsLost;
10236 uint64_t totalPacketsDiscarded;
10247 minRtpSamplesInQueue = 0;
10248 maxRtpSamplesInQueue = 0;
10249 totalSamplesTrimmed = 0;
10252 samplesInQueue = 0;
10253 totalPacketsReceived = 0;
10254 totalPacketsLost = 0;
10255 totalPacketsDiscarded = 0;
10261 j = nlohmann::json{
10263 TOJSON_IMPL(jitter),
10264 TOJSON_IMPL(minRtpSamplesInQueue),
10265 TOJSON_IMPL(maxRtpSamplesInQueue),
10266 TOJSON_IMPL(totalSamplesTrimmed),
10267 TOJSON_IMPL(underruns),
10268 TOJSON_IMPL(overruns),
10269 TOJSON_IMPL(samplesInQueue),
10270 TOJSON_IMPL(totalPacketsReceived),
10271 TOJSON_IMPL(totalPacketsLost),
10272 TOJSON_IMPL(totalPacketsDiscarded)
10275 static void from_json(
const nlohmann::json& j, InboundProcessorStats& p)
10278 getOptional<uint32_t>(
"ssrc", p.ssrc, j, 0);
10279 getOptional<double>(
"jitter", p.jitter, j, 0.0);
10280 getOptional<uint64_t>(
"minRtpSamplesInQueue", p.minRtpSamplesInQueue, j, 0);
10281 getOptional<uint64_t>(
"maxRtpSamplesInQueue", p.maxRtpSamplesInQueue, j, 0);
10282 getOptional<uint64_t>(
"totalSamplesTrimmed", p.totalSamplesTrimmed, j, 0);
10283 getOptional<uint64_t>(
"underruns", p.underruns, j, 0);
10284 getOptional<uint64_t>(
"overruns", p.overruns, j, 0);
10285 getOptional<uint64_t>(
"samplesInQueue", p.samplesInQueue, j, 0);
10286 getOptional<uint64_t>(
"totalPacketsReceived", p.totalPacketsReceived, j, 0);
10287 getOptional<uint64_t>(
"totalPacketsLost", p.totalPacketsLost, j, 0);
10288 getOptional<uint64_t>(
"totalPacketsDiscarded", p.totalPacketsDiscarded, j, 0);
10292 JSON_SERIALIZED_CLASS(TrafficCounter)
10301 IMPLEMENT_JSON_SERIALIZATION()
10325 j = nlohmann::json{
10326 TOJSON_IMPL(packets),
10327 TOJSON_IMPL(bytes),
10328 TOJSON_IMPL(errors)
10331 static void from_json(
const nlohmann::json& j, TrafficCounter& p)
10334 getOptional<uint64_t>(
"packets", p.packets, j, 0);
10335 getOptional<uint64_t>(
"bytes", p.bytes, j, 0);
10336 getOptional<uint64_t>(
"errors", p.errors, j, 0);
10340 JSON_SERIALIZED_CLASS(GroupStats)
10349 IMPLEMENT_JSON_SERIALIZATION()
10350 IMPLEMENT_WRAPPED_JSON_SERIALIZATION(
GroupStats)
10373 static void to_json(nlohmann::json& j,
const GroupStats& p)
10375 j = nlohmann::json{
10378 TOJSON_IMPL(rxTraffic),
10379 TOJSON_IMPL(txTraffic)
10382 static void from_json(
const nlohmann::json& j, GroupStats& p)
10385 getOptional<std::string>(
"id", p.id, j, EMPTY_STRING);
10387 getOptional<TrafficCounter>(
"rxTraffic", p.rxTraffic, j);
10388 getOptional<TrafficCounter>(
"txTraffic", p.txTraffic, j);
10392 JSON_SERIALIZED_CLASS(RallypointConnectionDetail)
10401 IMPLEMENT_JSON_SERIALIZATION()
10428 internalId.clear();
10431 msToNextConnectionAttempt = 0;
10432 serverProcessingMs = -1.0f;
10436 static void to_json(nlohmann::json& j,
const RallypointConnectionDetail& p)
10438 j = nlohmann::json{
10439 TOJSON_IMPL(internalId),
10444 if(p.msToNextConnectionAttempt > 0)
10446 j[
"msToNextConnectionAttempt"] = p.msToNextConnectionAttempt;
10449 if(p.serverProcessingMs >= 0.0)
10451 j[
"serverProcessingMs"] = p.serverProcessingMs;
10454 static void from_json(
const nlohmann::json& j, RallypointConnectionDetail& p)
10457 getOptional<std::string>(
"internalId", p.internalId, j, EMPTY_STRING);
10458 getOptional<std::string>(
"host", p.host, j, EMPTY_STRING);
10459 getOptional<int>(
"port", p.port, j, 0);
10460 getOptional<uint64_t>(
"msToNextConnectionAttempt", p.msToNextConnectionAttempt, j, 0);
10461 getOptional<float>(
"serverProcessingMs", p.serverProcessingMs, j, -1.0);
10465 JSON_SERIALIZED_CLASS(TranslationSession)
10477 IMPLEMENT_JSON_SERIALIZATION()
10507 static void to_json(nlohmann::json& j,
const TranslationSession& p)
10509 j = nlohmann::json{
10512 TOJSON_IMPL(groups),
10513 TOJSON_IMPL(enabled)
10516 static void from_json(
const nlohmann::json& j, TranslationSession& p)
10519 FROMJSON_IMPL(
id, std::string, EMPTY_STRING);
10520 FROMJSON_IMPL(name, std::string, EMPTY_STRING);
10521 getOptional<std::vector<std::string>>(
"groups", p.groups, j);
10522 FROMJSON_IMPL(enabled,
bool,
true);
10526 JSON_SERIALIZED_CLASS(TranslationConfiguration)
10538 IMPLEMENT_JSON_SERIALIZATION()
10560 static void to_json(nlohmann::json& j,
const TranslationConfiguration& p)
10562 j = nlohmann::json{
10563 TOJSON_IMPL(sessions),
10564 TOJSON_IMPL(groups)
10567 static void from_json(
const nlohmann::json& j, TranslationConfiguration& p)
10570 getOptional<std::vector<TranslationSession>>(
"sessions", p.sessions, j);
10571 getOptional<std::vector<Group>>(
"groups", p.groups, j);
10575 JSON_SERIALIZED_CLASS(LingoServerStatusReportConfiguration)
10587 IMPLEMENT_JSON_SERIALIZATION()
10622 includeGroupDetail =
false;
10623 includeSessionDetail =
false;
10624 includeSessionGroupDetail =
false;
10629 static void to_json(nlohmann::json& j,
const LingoServerStatusReportConfiguration& p)
10631 j = nlohmann::json{
10632 TOJSON_IMPL(fileName),
10633 TOJSON_IMPL(intervalSecs),
10634 TOJSON_IMPL(enabled),
10635 TOJSON_IMPL(includeGroupDetail),
10636 TOJSON_IMPL(includeSessionDetail),
10637 TOJSON_IMPL(includeSessionGroupDetail),
10638 TOJSON_IMPL(runCmd)
10641 static void from_json(
const nlohmann::json& j, LingoServerStatusReportConfiguration& p)
10644 getOptional<std::string>(
"fileName", p.fileName, j);
10645 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
10646 getOptional<bool>(
"enabled", p.enabled, j,
false);
10647 getOptional<std::string>(
"runCmd", p.runCmd, j);
10648 getOptional<bool>(
"includeGroupDetail", p.includeGroupDetail, j,
false);
10649 getOptional<bool>(
"includeSessionDetail", p.includeSessionDetail, j,
false);
10650 getOptional<bool>(
"includeSessionGroupDetail", p.includeSessionGroupDetail, j,
false);
10654 JSON_SERIALIZED_CLASS(LingoServerInternals)
10668 IMPLEMENT_JSON_SERIALIZATION()
10690 housekeeperIntervalMs = 1000;
10694 static void to_json(nlohmann::json& j,
const LingoServerInternals& p)
10696 j = nlohmann::json{
10697 TOJSON_IMPL(watchdog),
10698 TOJSON_IMPL(housekeeperIntervalMs),
10699 TOJSON_IMPL(tuning)
10702 static void from_json(
const nlohmann::json& j, LingoServerInternals& p)
10705 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
10706 getOptional<int>(
"housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
10707 getOptional<TuningSettings>(
"tuning", p.tuning, j);
10711 JSON_SERIALIZED_CLASS(LingoServerConfiguration)
10722 IMPLEMENT_JSON_SERIALIZATION()
10779 serviceConfigurationFileCheckSecs = 60;
10780 lingoConfigurationFileName.clear();
10781 lingoConfigurationFileCommand.clear();
10782 lingoConfigurationFileCheckSecs = 60;
10783 statusReport.clear();
10784 externalHealthCheckResponder.clear();
10786 certStoreFileName.clear();
10787 certStorePasswordHex.clear();
10788 enginePolicy.clear();
10789 configurationCheckSignalName =
"rts.22f4ec3.${id}";
10790 fipsCrypto.clear();
10796 static void to_json(nlohmann::json& j,
const LingoServerConfiguration& p)
10798 j = nlohmann::json{
10800 TOJSON_IMPL(serviceConfigurationFileCheckSecs),
10801 TOJSON_IMPL(lingoConfigurationFileName),
10802 TOJSON_IMPL(lingoConfigurationFileCommand),
10803 TOJSON_IMPL(lingoConfigurationFileCheckSecs),
10804 TOJSON_IMPL(statusReport),
10805 TOJSON_IMPL(externalHealthCheckResponder),
10806 TOJSON_IMPL(internals),
10807 TOJSON_IMPL(certStoreFileName),
10808 TOJSON_IMPL(certStorePasswordHex),
10809 TOJSON_IMPL(enginePolicy),
10810 TOJSON_IMPL(configurationCheckSignalName),
10811 TOJSON_IMPL(fipsCrypto),
10812 TOJSON_IMPL(proxy),
10816 static void from_json(
const nlohmann::json& j, LingoServerConfiguration& p)
10819 getOptional<std::string>(
"id", p.id, j);
10820 getOptional<int>(
"serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
10821 getOptional<std::string>(
"lingoConfigurationFileName", p.lingoConfigurationFileName, j);
10822 getOptional<std::string>(
"lingoConfigurationFileCommand", p.lingoConfigurationFileCommand, j);
10823 getOptional<int>(
"lingoConfigurationFileCheckSecs", p.lingoConfigurationFileCheckSecs, j, 60);
10824 getOptional<LingoServerStatusReportConfiguration>(
"statusReport", p.statusReport, j);
10825 getOptional<ExternalHealthCheckResponder>(
"externalHealthCheckResponder", p.externalHealthCheckResponder, j);
10826 getOptional<LingoServerInternals>(
"internals", p.internals, j);
10827 getOptional<std::string>(
"certStoreFileName", p.certStoreFileName, j);
10828 getOptional<std::string>(
"certStorePasswordHex", p.certStorePasswordHex, j);
10829 j.at(
"enginePolicy").get_to(p.enginePolicy);
10830 getOptional<std::string>(
"configurationCheckSignalName", p.configurationCheckSignalName, j,
"rts.22f4ec3.${id}");
10831 getOptional<FipsCryptoSettings>(
"fipsCrypo", p.fipsCrypto, j);
10832 getOptional<NetworkAddress>(
"proxy", p.proxy, j);
10833 getOptional<NsmConfiguration>(
"nsm", p.nsm, j);
10838 JSON_SERIALIZED_CLASS(VoiceToVoiceSession)
10850 IMPLEMENT_JSON_SERIALIZATION()
10880 static void to_json(nlohmann::json& j,
const VoiceToVoiceSession& p)
10882 j = nlohmann::json{
10885 TOJSON_IMPL(groups),
10886 TOJSON_IMPL(enabled)
10889 static void from_json(
const nlohmann::json& j, VoiceToVoiceSession& p)
10892 FROMJSON_IMPL(
id, std::string, EMPTY_STRING);
10893 FROMJSON_IMPL(name, std::string, EMPTY_STRING);
10894 getOptional<std::vector<std::string>>(
"groups", p.groups, j);
10895 FROMJSON_IMPL(enabled,
bool,
true);
10899 JSON_SERIALIZED_CLASS(LingoConfiguration)
10911 IMPLEMENT_JSON_SERIALIZATION()
10928 voiceToVoiceSessions.clear();
10933 static void to_json(nlohmann::json& j,
const LingoConfiguration& p)
10935 j = nlohmann::json{
10936 TOJSON_IMPL(voiceToVoiceSessions),
10937 TOJSON_IMPL(groups)
10940 static void from_json(
const nlohmann::json& j, LingoConfiguration& p)
10943 getOptional<std::vector<VoiceToVoiceSession>>(
"voiceToVoiceSessions", p.voiceToVoiceSessions, j);
10944 getOptional<std::vector<Group>>(
"groups", p.groups, j);
10948 JSON_SERIALIZED_CLASS(BridgingConfiguration)
10960 IMPLEMENT_JSON_SERIALIZATION()
10982 static void to_json(nlohmann::json& j,
const BridgingConfiguration& p)
10984 j = nlohmann::json{
10985 TOJSON_IMPL(bridges),
10986 TOJSON_IMPL(groups)
10989 static void from_json(
const nlohmann::json& j, BridgingConfiguration& p)
10992 getOptional<std::vector<Bridge>>(
"bridges", p.bridges, j);
10993 getOptional<std::vector<Group>>(
"groups", p.groups, j);
10997 JSON_SERIALIZED_CLASS(BridgingServerStatusReportConfiguration)
11009 IMPLEMENT_JSON_SERIALIZATION()
11044 includeGroupDetail =
false;
11045 includeBridgeDetail =
false;
11046 includeBridgeGroupDetail =
false;
11051 static void to_json(nlohmann::json& j,
const BridgingServerStatusReportConfiguration& p)
11053 j = nlohmann::json{
11054 TOJSON_IMPL(fileName),
11055 TOJSON_IMPL(intervalSecs),
11056 TOJSON_IMPL(enabled),
11057 TOJSON_IMPL(includeGroupDetail),
11058 TOJSON_IMPL(includeBridgeDetail),
11059 TOJSON_IMPL(includeBridgeGroupDetail),
11060 TOJSON_IMPL(runCmd)
11063 static void from_json(
const nlohmann::json& j, BridgingServerStatusReportConfiguration& p)
11066 getOptional<std::string>(
"fileName", p.fileName, j);
11067 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
11068 getOptional<bool>(
"enabled", p.enabled, j,
false);
11069 getOptional<std::string>(
"runCmd", p.runCmd, j);
11070 getOptional<bool>(
"includeGroupDetail", p.includeGroupDetail, j,
false);
11071 getOptional<bool>(
"includeBridgeDetail", p.includeBridgeDetail, j,
false);
11072 getOptional<bool>(
"includeBridgeGroupDetail", p.includeBridgeGroupDetail, j,
false);
11076 JSON_SERIALIZED_CLASS(BridgingServerInternals)
11090 IMPLEMENT_JSON_SERIALIZATION()
11112 housekeeperIntervalMs = 1000;
11116 static void to_json(nlohmann::json& j,
const BridgingServerInternals& p)
11118 j = nlohmann::json{
11119 TOJSON_IMPL(watchdog),
11120 TOJSON_IMPL(housekeeperIntervalMs),
11121 TOJSON_IMPL(tuning)
11124 static void from_json(
const nlohmann::json& j, BridgingServerInternals& p)
11127 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
11128 getOptional<int>(
"housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
11129 getOptional<TuningSettings>(
"tuning", p.tuning, j);
11133 JSON_SERIALIZED_CLASS(BridgingServerConfiguration)
11144 IMPLEMENT_JSON_SERIALIZATION()
11155 omPayloadTransformation = 1,
11158 omAnonymousMixing = 2,
11161 omLanguageTranslation = 3
11218 serviceConfigurationFileCheckSecs = 60;
11219 bridgingConfigurationFileName.clear();
11220 bridgingConfigurationFileCommand.clear();
11221 bridgingConfigurationFileCheckSecs = 60;
11222 statusReport.clear();
11223 externalHealthCheckResponder.clear();
11225 certStoreFileName.clear();
11226 certStorePasswordHex.clear();
11227 enginePolicy.clear();
11228 configurationCheckSignalName =
"rts.6cc0651.${id}";
11229 fipsCrypto.clear();
11234 static void to_json(nlohmann::json& j,
const BridgingServerConfiguration& p)
11236 j = nlohmann::json{
11239 TOJSON_IMPL(serviceConfigurationFileCheckSecs),
11240 TOJSON_IMPL(bridgingConfigurationFileName),
11241 TOJSON_IMPL(bridgingConfigurationFileCommand),
11242 TOJSON_IMPL(bridgingConfigurationFileCheckSecs),
11243 TOJSON_IMPL(statusReport),
11244 TOJSON_IMPL(externalHealthCheckResponder),
11245 TOJSON_IMPL(internals),
11246 TOJSON_IMPL(certStoreFileName),
11247 TOJSON_IMPL(certStorePasswordHex),
11248 TOJSON_IMPL(enginePolicy),
11249 TOJSON_IMPL(configurationCheckSignalName),
11250 TOJSON_IMPL(fipsCrypto),
11254 static void from_json(
const nlohmann::json& j, BridgingServerConfiguration& p)
11257 getOptional<std::string>(
"id", p.id, j);
11258 getOptional<BridgingServerConfiguration::OpMode_t>(
"mode", p.mode, j, BridgingServerConfiguration::OpMode_t::omRaw);
11259 getOptional<int>(
"serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
11260 getOptional<std::string>(
"bridgingConfigurationFileName", p.bridgingConfigurationFileName, j);
11261 getOptional<std::string>(
"bridgingConfigurationFileCommand", p.bridgingConfigurationFileCommand, j);
11262 getOptional<int>(
"bridgingConfigurationFileCheckSecs", p.bridgingConfigurationFileCheckSecs, j, 60);
11263 getOptional<BridgingServerStatusReportConfiguration>(
"statusReport", p.statusReport, j);
11264 getOptional<ExternalHealthCheckResponder>(
"externalHealthCheckResponder", p.externalHealthCheckResponder, j);
11265 getOptional<BridgingServerInternals>(
"internals", p.internals, j);
11266 getOptional<std::string>(
"certStoreFileName", p.certStoreFileName, j);
11267 getOptional<std::string>(
"certStorePasswordHex", p.certStorePasswordHex, j);
11268 j.at(
"enginePolicy").get_to(p.enginePolicy);
11269 getOptional<std::string>(
"configurationCheckSignalName", p.configurationCheckSignalName, j,
"rts.6cc0651.${id}");
11270 getOptional<FipsCryptoSettings>(
"fipsCrypto", p.fipsCrypto, j);
11271 getOptional<NsmConfiguration>(
"nsm", p.nsm, j);
11276 JSON_SERIALIZED_CLASS(EarGroupsConfiguration)
11288 IMPLEMENT_JSON_SERIALIZATION()
11306 static void to_json(nlohmann::json& j,
const EarGroupsConfiguration& p)
11308 j = nlohmann::json{
11309 TOJSON_IMPL(groups)
11312 static void from_json(
const nlohmann::json& j, EarGroupsConfiguration& p)
11315 getOptional<std::vector<Group>>(
"groups", p.groups, j);
11319 JSON_SERIALIZED_CLASS(EarServerStatusReportConfiguration)
11331 IMPLEMENT_JSON_SERIALIZATION()
11360 includeGroupDetail =
false;
11365 static void to_json(nlohmann::json& j,
const EarServerStatusReportConfiguration& p)
11367 j = nlohmann::json{
11368 TOJSON_IMPL(fileName),
11369 TOJSON_IMPL(intervalSecs),
11370 TOJSON_IMPL(enabled),
11371 TOJSON_IMPL(includeGroupDetail),
11372 TOJSON_IMPL(runCmd)
11375 static void from_json(
const nlohmann::json& j, EarServerStatusReportConfiguration& p)
11378 getOptional<std::string>(
"fileName", p.fileName, j);
11379 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
11380 getOptional<bool>(
"enabled", p.enabled, j,
false);
11381 getOptional<std::string>(
"runCmd", p.runCmd, j);
11382 getOptional<bool>(
"includeGroupDetail", p.includeGroupDetail, j,
false);
11386 JSON_SERIALIZED_CLASS(EarServerInternals)
11400 IMPLEMENT_JSON_SERIALIZATION()
11422 housekeeperIntervalMs = 1000;
11426 static void to_json(nlohmann::json& j,
const EarServerInternals& p)
11428 j = nlohmann::json{
11429 TOJSON_IMPL(watchdog),
11430 TOJSON_IMPL(housekeeperIntervalMs),
11431 TOJSON_IMPL(tuning)
11434 static void from_json(
const nlohmann::json& j, EarServerInternals& p)
11437 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
11438 getOptional<int>(
"housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
11439 getOptional<TuningSettings>(
"tuning", p.tuning, j);
11443 JSON_SERIALIZED_CLASS(EarServerConfiguration)
11454 IMPLEMENT_JSON_SERIALIZATION()
11509 serviceConfigurationFileCheckSecs = 60;
11510 groupsConfigurationFileName.clear();
11511 groupsConfigurationFileCommand.clear();
11512 groupsConfigurationFileCheckSecs = 60;
11513 statusReport.clear();
11514 externalHealthCheckResponder.clear();
11516 certStoreFileName.clear();
11517 certStorePasswordHex.clear();
11518 enginePolicy.clear();
11519 configurationCheckSignalName =
"rts.9a164fa.${id}";
11520 fipsCrypto.clear();
11525 static void to_json(nlohmann::json& j,
const EarServerConfiguration& p)
11527 j = nlohmann::json{
11529 TOJSON_IMPL(serviceConfigurationFileCheckSecs),
11530 TOJSON_IMPL(groupsConfigurationFileName),
11531 TOJSON_IMPL(groupsConfigurationFileCommand),
11532 TOJSON_IMPL(groupsConfigurationFileCheckSecs),
11533 TOJSON_IMPL(statusReport),
11534 TOJSON_IMPL(externalHealthCheckResponder),
11535 TOJSON_IMPL(internals),
11536 TOJSON_IMPL(certStoreFileName),
11537 TOJSON_IMPL(certStorePasswordHex),
11538 TOJSON_IMPL(enginePolicy),
11539 TOJSON_IMPL(configurationCheckSignalName),
11540 TOJSON_IMPL(fipsCrypto),
11544 static void from_json(
const nlohmann::json& j, EarServerConfiguration& p)
11547 getOptional<std::string>(
"id", p.id, j);
11548 getOptional<int>(
"serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
11549 getOptional<std::string>(
"groupsConfigurationFileName", p.groupsConfigurationFileName, j);
11550 getOptional<std::string>(
"groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
11551 getOptional<int>(
"groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
11552 getOptional<EarServerStatusReportConfiguration>(
"statusReport", p.statusReport, j);
11553 getOptional<ExternalHealthCheckResponder>(
"externalHealthCheckResponder", p.externalHealthCheckResponder, j);
11554 getOptional<EarServerInternals>(
"internals", p.internals, j);
11555 getOptional<std::string>(
"certStoreFileName", p.certStoreFileName, j);
11556 getOptional<std::string>(
"certStorePasswordHex", p.certStorePasswordHex, j);
11557 j.at(
"enginePolicy").get_to(p.enginePolicy);
11558 getOptional<std::string>(
"configurationCheckSignalName", p.configurationCheckSignalName, j,
"rts.9a164fa.${id}");
11559 getOptional<FipsCryptoSettings>(
"fipsCrypto", p.fipsCrypto, j);
11560 getOptional<NsmConfiguration>(
"nsm", p.nsm, j);
11564 JSON_SERIALIZED_CLASS(EngageSemGroupsConfiguration)
11576 IMPLEMENT_JSON_SERIALIZATION()
11594 static void to_json(nlohmann::json& j,
const EngageSemGroupsConfiguration& p)
11596 j = nlohmann::json{
11597 TOJSON_IMPL(groups)
11600 static void from_json(
const nlohmann::json& j, EngageSemGroupsConfiguration& p)
11603 getOptional<std::vector<Group>>(
"groups", p.groups, j);
11607 JSON_SERIALIZED_CLASS(EngageSemServerStatusReportConfiguration)
11619 IMPLEMENT_JSON_SERIALIZATION()
11648 includeGroupDetail =
false;
11653 static void to_json(nlohmann::json& j,
const EngageSemServerStatusReportConfiguration& p)
11655 j = nlohmann::json{
11656 TOJSON_IMPL(fileName),
11657 TOJSON_IMPL(intervalSecs),
11658 TOJSON_IMPL(enabled),
11659 TOJSON_IMPL(includeGroupDetail),
11660 TOJSON_IMPL(runCmd)
11663 static void from_json(
const nlohmann::json& j, EngageSemServerStatusReportConfiguration& p)
11666 getOptional<std::string>(
"fileName", p.fileName, j);
11667 getOptional<int>(
"intervalSecs", p.intervalSecs, j, 60);
11668 getOptional<bool>(
"enabled", p.enabled, j,
false);
11669 getOptional<std::string>(
"runCmd", p.runCmd, j);
11670 getOptional<bool>(
"includeGroupDetail", p.includeGroupDetail, j,
false);
11674 JSON_SERIALIZED_CLASS(EngageSemServerInternals)
11688 IMPLEMENT_JSON_SERIALIZATION()
11710 housekeeperIntervalMs = 1000;
11714 static void to_json(nlohmann::json& j,
const EngageSemServerInternals& p)
11716 j = nlohmann::json{
11717 TOJSON_IMPL(watchdog),
11718 TOJSON_IMPL(housekeeperIntervalMs),
11719 TOJSON_IMPL(tuning)
11722 static void from_json(
const nlohmann::json& j, EngageSemServerInternals& p)
11725 getOptional<WatchdogSettings>(
"watchdog", p.watchdog, j);
11726 getOptional<int>(
"housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
11727 getOptional<TuningSettings>(
"tuning", p.tuning, j);
11731 JSON_SERIALIZED_CLASS(EngageSemServerConfiguration)
11742 IMPLEMENT_JSON_SERIALIZATION()
11803 serviceConfigurationFileCheckSecs = 60;
11804 groupsConfigurationFileName.clear();
11805 groupsConfigurationFileCommand.clear();
11806 groupsConfigurationFileCheckSecs = 60;
11807 statusReport.clear();
11808 externalHealthCheckResponder.clear();
11810 certStoreFileName.clear();
11811 certStorePasswordHex.clear();
11812 enginePolicy.clear();
11813 configurationCheckSignalName =
"rts.9a164fa.${id}";
11814 fipsCrypto.clear();
11819 maxQueuingMs = 15000;
11825 static void to_json(nlohmann::json& j,
const EngageSemServerConfiguration& p)
11827 j = nlohmann::json{
11829 TOJSON_IMPL(serviceConfigurationFileCheckSecs),
11830 TOJSON_IMPL(groupsConfigurationFileName),
11831 TOJSON_IMPL(groupsConfigurationFileCommand),
11832 TOJSON_IMPL(groupsConfigurationFileCheckSecs),
11833 TOJSON_IMPL(statusReport),
11834 TOJSON_IMPL(externalHealthCheckResponder),
11835 TOJSON_IMPL(internals),
11836 TOJSON_IMPL(certStoreFileName),
11837 TOJSON_IMPL(certStorePasswordHex),
11838 TOJSON_IMPL(enginePolicy),
11839 TOJSON_IMPL(configurationCheckSignalName),
11840 TOJSON_IMPL(fipsCrypto),
11842 TOJSON_IMPL(maxQueueLen),
11843 TOJSON_IMPL(minQueuingMs),
11844 TOJSON_IMPL(maxQueuingMs),
11845 TOJSON_IMPL(minPriority),
11846 TOJSON_IMPL(maxPriority)
11849 static void from_json(
const nlohmann::json& j, EngageSemServerConfiguration& p)
11852 getOptional<std::string>(
"id", p.id, j);
11853 getOptional<int>(
"serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
11854 getOptional<std::string>(
"groupsConfigurationFileName", p.groupsConfigurationFileName, j);
11855 getOptional<std::string>(
"groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
11856 getOptional<int>(
"groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
11857 getOptional<EngageSemServerStatusReportConfiguration>(
"statusReport", p.statusReport, j);
11858 getOptional<ExternalHealthCheckResponder>(
"externalHealthCheckResponder", p.externalHealthCheckResponder, j);
11859 getOptional<EngageSemServerInternals>(
"internals", p.internals, j);
11860 getOptional<std::string>(
"certStoreFileName", p.certStoreFileName, j);
11861 getOptional<std::string>(
"certStorePasswordHex", p.certStorePasswordHex, j);
11862 j.at(
"enginePolicy").get_to(p.enginePolicy);
11863 getOptional<std::string>(
"configurationCheckSignalName", p.configurationCheckSignalName, j,
"rts.9a164fa.${id}");
11864 getOptional<FipsCryptoSettings>(
"fipsCrypto", p.fipsCrypto, j);
11865 getOptional<NsmConfiguration>(
"nsm", p.nsm, j);
11866 getOptional<int>(
"maxQueueLen", p.maxQueueLen, j, 64);
11867 getOptional<int>(
"minQueuingMs", p.minQueuingMs, j, 0);
11868 getOptional<int>(
"maxQueuingMs", p.maxQueuingMs, j, 15000);
11869 getOptional<int>(
"minPriority", p.minPriority, j, 0);
11870 getOptional<int>(
"maxPriority", p.maxPriority, j, 255);
11874 static inline void dumpExampleConfigurations(
const char *path)
11876 WatchdogSettings::document();
11877 FileRecordingRequest::document();
11878 Feature::document();
11879 Featureset::document();
11881 RtpPayloadTypeTranslation::document();
11882 NetworkInterfaceDevice::document();
11883 ListOfNetworkInterfaceDevice::document();
11884 RtpHeader::document();
11885 BlobInfo::document();
11886 TxAudioUri::document();
11887 AdvancedTxParams::document();
11888 Identity::document();
11889 Location::document();
11891 Connectivity::document();
11892 PresenceDescriptorGroupItem::document();
11893 PresenceDescriptor::document();
11894 NetworkTxOptions::document();
11895 TcpNetworkTxOptions::document();
11896 NetworkAddress::document();
11897 NetworkAddressRxTx::document();
11898 NetworkAddressRestrictionList::document();
11899 StringRestrictionList::document();
11900 Rallypoint::document();
11901 RallypointCluster::document();
11902 NetworkDeviceDescriptor::document();
11903 TxAudio::document();
11904 AudioDeviceDescriptor::document();
11905 ListOfAudioDeviceDescriptor::document();
11907 TalkerInformation::document();
11908 GroupTalkers::document();
11909 Presence::document();
11910 Advertising::document();
11911 GroupPriorityTranslation::document();
11912 GroupTimeline::document();
11913 GroupAppTransport::document();
11914 RtpProfile::document();
11916 Mission::document();
11917 LicenseDescriptor::document();
11918 EngineNetworkingRpUdpStreaming::document();
11919 EnginePolicyNetworking::document();
11922 Bridge::document();
11923 AndroidAudio::document();
11924 EnginePolicyAudio::document();
11925 SecurityCertificate::document();
11926 EnginePolicySecurity::document();
11927 EnginePolicyLogging::document();
11928 EnginePolicyDatabase::document();
11929 NamedAudioDevice::document();
11930 EnginePolicyNamedAudioDevices::document();
11931 Licensing::document();
11932 DiscoveryMagellan::document();
11933 DiscoverySsdp::document();
11934 DiscoverySap::document();
11935 DiscoveryCistech::document();
11936 DiscoveryTrellisware::document();
11937 DiscoveryConfiguration::document();
11938 EnginePolicyInternals::document();
11939 EnginePolicyTimelines::document();
11940 RtpMapEntry::document();
11941 ExternalModule::document();
11942 ExternalCodecDescriptor::document();
11943 EnginePolicy::document();
11944 TalkgroupAsset::document();
11945 EngageDiscoveredGroup::document();
11946 RallypointPeer::document();
11947 RallypointServerLimits::document();
11948 RallypointServerStatusReportConfiguration::document();
11949 RallypointServerLinkGraph::document();
11950 ExternalHealthCheckResponder::document();
11952 PeeringConfiguration::document();
11953 IgmpSnooping::document();
11954 RallypointReflector::document();
11955 RallypointUdpStreaming::document();
11956 RallypointServer::document();
11957 PlatformDiscoveredService::document();
11958 TimelineQueryParameters::document();
11959 CertStoreCertificate::document();
11960 CertStore::document();
11961 CertStoreCertificateElement::document();
11962 CertStoreDescriptor::document();
11963 CertificateDescriptor::document();
11964 BridgeCreationDetail::document();
11965 GroupConnectionDetail::document();
11966 GroupTxDetail::document();
11967 GroupCreationDetail::document();
11968 GroupReconfigurationDetail::document();
11969 GroupHealthReport::document();
11970 InboundProcessorStats::document();
11971 TrafficCounter::document();
11972 GroupStats::document();
11973 RallypointConnectionDetail::document();
11974 BridgingConfiguration::document();
11975 BridgingServerStatusReportConfiguration::document();
11976 BridgingServerInternals::document();
11977 BridgingServerConfiguration::document();
11978 EarGroupsConfiguration::document();
11979 EarServerStatusReportConfiguration::document();
11980 EarServerInternals::document();
11981 EarServerConfiguration::document();
11982 RangerPackets::document();
11983 TransportImpairment::document();
11985 EngageSemGroupsConfiguration::document();
11986 EngageSemServerStatusReportConfiguration::document();
11987 EngageSemServerInternals::document();
11988 EngageSemServerConfiguration::document();
11993 #pragma GCC diagnostic pop
TxPriority_t
Network Transmission Priority.
@ priBestEffort
best effort
AddressResolutionPolicy_t
Address family resolution policy.
@ arpIpv6ThenIpv4
IPv6 then IPv4.
@ arpIpv4ThenIpv6
IPv4 then IPv6.
#define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING
RestrictionElementType_t
Enum describing restriction element types.
@ retGenericAccessTagPattern
Elements are generic access tags regex patterns.
@ retGroupIdPattern
Elements are group ID regex patterns.
@ retGroupId
A literal group ID.
@ retCertificateIssuerPattern
Elements are X.509 certificate issuer regex patterns.
@ retCertificateSubjectPattern
Elements are X.509 certificate subject regex patterns.
@ retCertificateFingerprintPattern
Elements are X.509 certificate fingerprint regex patterns.
@ retCertificateSerialNumberPattern
Elements are X.509 certificate serial number regex patterns.
GroupRestrictionAccessPolicyType_t
Enum describing restriction types.
@ graptStrict
Registration for groups is NOT allowed by default - requires definitive access through something like...
@ graptPermissive
Registration for groups is allowed by default.
RestrictionType_t
Enum describing restriction types.
@ rtWhitelist
Elements are whitelisted.
@ rtBlacklist
Elements are blacklisted.
Configuration when using the engageBeginGroupTxAdvanced API.
TxAudioUri audioUri
[Optional] A URI to stream from instead of the audio input device
uint8_t priority
[Optional, Default: 0] Transmit priority between 0 (lowest) and 255 (highest).
bool receiverRxMuteForAliasSpecializer
[Optional, Default: false] Indicates that the aliasSpecializer must cause receivers to mute this tran...
uint16_t subchannelTag
[Optional, Default: 0] Defines a sub channel within a group. Audio will be opaque to all other client...
uint16_t aliasSpecializer
[Optional, Default: 0] Defines a numeric affinity value to be included in the transmission....
uint16_t flags
[Optional, Default: 0] Combination of the ENGAGE_TXFLAG_xxx flags
std::string alias
[Optional, Default: empty string] The Engage Engine should transmit the user's alias as part of the h...
bool includeNodeId
[Optional, Default: false] The Engage Engine should transmit the NodeId as part of the header extensi...
uint32_t txId
[Optional, Default: 0] Transmission ID
bool muted
[Optional, Default: false] While the microphone should be opened, captured audio should be ignored un...
Defines parameters for advertising of an entity such as a known, public, group.
int intervalMs
[Optional, Default: 20000] Interval at which the advertisement should be sent in milliseconds.
bool enabled
[Optional, Default: false] Enabled advertising
bool alwaysAdvertise
[Optional, Default: false] If true, the node will advertise the item even if it detects other nodes m...
Acoustic Echo Cancellation settings.
int speakerTailMs
[Optional, Default: 60] Milliseconds of speaker tail
bool cng
[Optional, Default: true] Enable comfort noise generation
bool enabled
[Optional, Default: false] Enable acoustic echo cancellation
Mode_t
Acoustic echo cancellation mode enum.
Mode_t mode
[Optional, Default: aecmDefault] Specifies AEC mode. See Mode_t for all modes
bool enabled
[Optional, Default: false] Enables automatic gain control.
int compressionGainDb
[Optional, Default: 25, Minimum = 0, Maximum = 125] Gain in db.
bool enableLimiter
[Optional, Default: false] Enables limiter to prevent overdrive.
int maxLevel
[Optional, Default: 255] Maximum level.
int minLevel
[Optional, Default: 0] Minimum level.
int targetLevelDb
[Optional, Default: 9] Target gain level if there is no compression gain.
Default audio settings for AndroidAudio.
int api
[Optional, Default 0] Android audio API version: 0=Unspecified, 1=AAudio, 2=OpenGLES
int sessionId
[Optional, Default INVALID_SESSION_ID] A session ID from the Android AudioManager
int contentType
[Optional, Default 1] Usage type: 1=Speech 2=Music 3=Movie 4=Sonification
int sharingMode
[Optional, Default 0] Sharing mode: 0=Exclusive, 1=Shared
int performanceMode
[Optional, Default 12] Performance mode: 10=None/Default, 11=PowerSaving, 12=LowLatency
int inputPreset
[Optional, Default 7] Input preset: 1=Generic 5=Camcorder 6=VoiceRecognition 7=VoiceCommunication 9=U...
int usage
[Optional, Default 2] Usage type: 1=Media 2=VoiceCommunication 3=VoiceCommunicationSignalling 4=Alarm...
int engineMode
[Optional, Default 0] 0=use legacy low-level APIs, 1=use high-level Android APIs
Custom Audio Device Configuration.
std::string type
Device type (if any)
int samplingRate
This is the rate that the device will process the PCM audio data at.
std::string name
Name of the device assigned by the platform.
bool isDefault
True if this is the default device for the direction above.
std::string serialNumber
Device serial number (if any)
int channels
Indicates the number of audio channels to process.
std::string hardwareId
Device hardware ID (if any)
std::string manufacturer
Device manufacturer (if any)
Direction_t
Audio Device Direction Enum.
@ dirOutput
This is an output only device.
@ dirInput
This is an input only device.
std::string model
Device mode (if any)
Direction_t direction
Audio direction the device supports.
std::string extra
Extra data provided by the platform (if any)
bool isPresent
True if the device is currently present on the system.
int boostPercentage
A percentage at which to gain/attenuate the audio.
bool isAdad
True if the device is an Application-Defined Audio Device.
int deviceId
[Read Only] Unique device identifier assigned by Engage Engine at time of device creation.
Description of an audio gate.
double coefficient
[Optional. Default: 1.75] Coefficient by which to multiply the current history average to determine t...
uint32_t hangMs
[Optional. Default: 1500] Hang timer in milliseconds
bool enabled
[Optional. Default: false] Enables the audio gate if true
uint32_t windowMin
[Optional. Default: 25] Number of 10ms history samples to gather before calculating the noise floor -...
bool useVad
[Optional. Default: false] Use voice activity detection rather than audio energy
uint32_t windowMax
[Optional. Default: 125] Maximum number of 10ms history samples - ignored if useVad is true
Used to configure the Audio properties for a group.
int outputLevelRight
[Optional, Default: 100] The percentage at which to set the right audio at.
bool outputMuted
[Optional, Default: false] Mutes output audio.
bool enabled
[Optional, Default: true] Audio is enabled
int inputId
[Optional, Default: first audio device] Id for the input audio device to use for this group.
int outputGain
[Optional, Default: 0] The percentage at which to gain the output audio.
int outputId
[Optional, Default: first audio device] Id for the output audio device to use for this group.
int inputGain
[Optional, Default: 0] The percentage at which to gain the input audio.
int outputLevelLeft
[Optional, Default: 100] The percentage at which to set the left audio at.
Describes the Blob data being sent used in the engageSendGroupBlob API.
size_t size
[Optional, Default : 0] Size of the payload
RtpHeader rtpHeader
Custom RTP header.
PayloadType_t payloadType
[Optional, Default: bptUndefined] The payload type to send in the blob
std::string target
[Optional, Default: empty string] The nodeId to which this message is targeted. If this is empty,...
std::string source
[Optional, Default: empty string] The nodeId of Engage Engine that sent the message....
int txnTimeoutSecs
[Optional, Default: 0] Number of seconds after which to time out delivery to the target node
PayloadType_t
Payload type. BlobInfo RTP supported Payload types.
std::string txnId
[Optional but required if txnTimeoutSecs is > 0]
Detailed information for a bridge creation.
CreationStatus_t
Creation status.
CreationStatus_t status
The creation status.
std::string id
ID of the bridge.
Bridging session settings.
std::vector< std::string > groups
List of group IDs to be included in the session.
bool enabled
[Optional, Default: true] Enable the bridge
std::vector< Group > groups
Array of bridges in the configuration.
std::vector< Bridge > bridges
Array of bridges in the configuration.
Configuration for the bridging server.
std::string certStoreFileName
Path to the certificate store.
FipsCryptoSettings fipsCrypto
[Optional] Settings for the FIPS crypto.
std::string configurationCheckSignalName
Name to use for signalling a configuration check.
ExternalHealthCheckResponder externalHealthCheckResponder
Details concerning the server's interaction with an external health-checker such as a load-balancer.
OpMode_t mode
Specifies the operation mode (see OpMode_t).
EnginePolicy enginePolicy
The policy to be used for the underlying Engage Engine.
BridgingServerStatusReportConfiguration statusReport
Details for producing a status report.
std::string bridgingConfigurationFileCommand
Command-line to execute that returns a bridging configuration.
std::string bridgingConfigurationFileName
Name of a file containing the bridging configuration.
std::string certStorePasswordHex
Hex password for the certificate store (if any)
OpMode_t
Enum describing the modes the briging service runs in.
BridgingServerInternals internals
Internal settings.
int bridgingConfigurationFileCheckSecs
Number of seconds between checks to see if the bridging configuration has been updated....
int serviceConfigurationFileCheckSecs
Number of seconds between checks to see if the service configuration has been updated....
std::string id
A unqiue identifier for the bridge server.
NsmConfiguration nsm
[Optional] Settings for NSM.
Internal bridging server settings.
int housekeeperIntervalMs
[Optional, Default: 1000] Interval at which to run the housekeeper thread.
TuningSettings tuning
[Optional] Low-level tuning
WatchdogSettings watchdog
[Optional] Settings for the watchdog.
TODO: Configuration for the bridging server status report file.
bool includeBridgeGroupDetail
Description of a certstore certificate element.
std::string tags
Additional attributes.
bool hasPrivateKey
True if the certificate has a private key associated with it.
std::string certificatePem
PEM of the certificate.
Holds a certificate and (optionally) a private key in a certstore.
std::string tags
Additional tags.
std::string id
Id of the certificate.
std::string certificatePem
Certificate in PEM format.
void * internalData
Unserialized internal data.
std::string privateKeyPem
Private key in PEM format.
Description of a certstore.
std::string id
Certstore ID.
std::vector< CertStoreCertificateElement > certificates
Array of certificate elements.
std::string fileName
Name of the file the certstore resides in.
int flags
Flags set for the certstore.
int version
Version of the certstore.
std::vector< CertStoreCertificate > certificates
Array of certificates in this store.
std::string id
The ID of the certstore.
Description of a certificate.
std::vector< CertificateSubjectElement > subjectElements
Array of subject elements.
std::string serial
Serial #.
std::string publicKeyPem
PEM version of the public key.
bool selfSigned
Indicates whether the certificqte is self-signed.
std::string fingerprint
Fingerprint.
std::string notAfter
Validity date notAfter.
std::string subject
Subject.
std::string notBefore
Validity date notBefore.
std::string issuer
Issuer.
std::string certificatePem
PEM version of the certificate.
Description of a certificate subject element.
Connectivity Information used as part of the PresenceDescriptor.
int type
Is the type of connectivity the device has to the network.
int strength
Is the strength of the connection connection as reported by the OS - usually in dbm.
int rating
Is the quality of the network connection as reported by the OS - OS dependent.
Cistech Discovery settings.
Configuration for the Discovery features.
DiscoveryMagellan magellan
DiscoveryTrellisware trellisware
DiscoveryMagellan Discovery settings.
SecurityCertificate security
Tls tls
[Optional] Details concerning Transport Layer Security.
std::string interfaceName
[Optional, Default: default system interface] The network interface to bind to for discovery packets.
Session Announcement Discovery settings settings.
int ageTimeoutMs
[Optional, Default 30000] Number of milliseconds of no SAP announcment before the advertised entity i...
Advertising advertising
Parameters for advertising.
NetworkAddress address
[Optional, Default 224.2.127.254:9875] IP address and port.
bool enabled
[Optional, Default: false] Enables the Engage Engine to use SAP for asset discovery.
std::string interfaceName
[Optional, Default: default system interface] The network interface to bind to for discovery packets.
Simple Service Discovery Protocol settings.
bool enabled
[Optional, Default: false] Enables the Engage Engine to use SSDP for asset discovery.
std::vector< std::string > searchTerms
[Optional] An array of regex strings to be used to filter SSDP requests and responses.
int ageTimeoutMs
[Optional, Default 30000] Number of milliseconds of no SSDP announcment before the advertised entity ...
Advertising advertising
Parameters for advertising.
std::string interfaceName
[Optional, Default: default system interface] The network interface to bind to for discovery packets.
NetworkAddress address
[Optional, Default 255.255.255.255:1900] IP address and port.
Trellisware Discovery settings.
SecurityCertificate security
std::vector< Group > groups
Array of groups in the configuration.
Configuration for the ear server.
std::string id
A unqiue identifier for the EAR server.
std::string configurationCheckSignalName
Name to use for signalling a configuration check.
std::string certStorePasswordHex
Hex password for the certificate store (if any)
ExternalHealthCheckResponder externalHealthCheckResponder
Details concerning the server's interaction with an external health-checker such as a load-balancer.
FipsCryptoSettings fipsCrypto
[Optional] Settings for the FIPS crypto.
NsmConfiguration nsm
[Optional] Settings for NSM.
EarServerInternals internals
Internal settings.
int groupsConfigurationFileCheckSecs
Number of seconds between checks to see if the configuration has been updated. Default is 60.
EarServerStatusReportConfiguration statusReport
Details for producing a status report.
std::string certStoreFileName
Path to the certificate store.
std::string groupsConfigurationFileName
Name of a file containing the ear configuration.
int serviceConfigurationFileCheckSecs
Number of seconds between checks to see if the service configuration has been updated....
std::string groupsConfigurationFileCommand
Command-line to execute that returns a configuration.
EnginePolicy enginePolicy
The policy to be used for the underlying Engage Engine.
Internal ear server settings.
int housekeeperIntervalMs
[Optional, Default: 1000] Interval at which to run the housekeeper thread.
WatchdogSettings watchdog
[Optional] Settings for the EAR's watchdog.
TuningSettings tuning
[Optional] Low-level tuning
TODO: Configuration for the ear server status report file.
NetworkAddress rx
Internal RX detail.
NetworkAddress tx
Internal TX detail.
std::string id
Internal ID.
Engage Semaphore configuration.
std::vector< Group > groups
Array of groups in the configuration.
Configuration for the EFC server.
FipsCryptoSettings fipsCrypto
[Optional] Settings for the FIPS crypto.
EnginePolicy enginePolicy
The policy to be used for the underlying Engage Engine.
std::string configurationCheckSignalName
Name to use for signalling a configuration check.
EngageSemServerStatusReportConfiguration statusReport
Details for producing a status report.
std::string id
A unqiue identifier for the EFC server.
std::string certStoreFileName
Path to the certificate store.
std::string groupsConfigurationFileName
Name of a file containing the EFC configuration.
int serviceConfigurationFileCheckSecs
Number of seconds between checks to see if the service configuration has been updated....
NsmConfiguration nsm
[Optional] Settings for NSM.
std::string groupsConfigurationFileCommand
Command-line to execute that returns a configuration.
ExternalHealthCheckResponder externalHealthCheckResponder
Details concerning the server's interaction with an external health-checker such as a load-balancer.
EngageSemServerInternals internals
Internal settings.
std::string certStorePasswordHex
Hex password for the certificate store (if any)
int groupsConfigurationFileCheckSecs
Number of seconds between checks to see if the configuration has been updated. Default is 60.
Internal EFC server settings.
WatchdogSettings watchdog
[Optional] Settings for the EFC's watchdog.
TuningSettings tuning
[Optional] Low-level tuning
int housekeeperIntervalMs
[Optional, Default: 1000] Interval at which to run the housekeeper thread.
TODO: Configuration for the EFC server status report file.
Configuration for RP UDP streaming.
TxPriority_t priority
[Optional, Default: priVoice] Transmission priority. This has meaning on some operating systems based...
int keepaliveIntervalSecs
Optional, Default: 15] Seconds interval at which to send UDP keepalives to Rallypoints....
int ttl
[Optional, Default: 64] Time to live or hop limit is a mechanism that limits the lifespan or lifetime...
int port
[Optional, 0] The port to be used for Rallypoint UDP streaming. A value of 0 will result in an epheme...
bool enabled
[Optional, false] Enables UDP streaming if the RP supports it
Default audio settings for Engage Engine policy.
Vad vad
[Optional] Voice activity detection settings
Agc outputAgc
[Optional] Automatic Gain Control for audio outputs
bool saveOutputPcm
[Optional, Default: false] If true, input audio is written to a PCM file in the data directory
bool enabled
[Optional, Default: true] Enables audio processing
AndroidAudio android
[Optional] Android-specific audio settings
int internalRate
[Optional, Default: 16000] Internal sampling rate - 8000 or 16000
bool muteTxOnTx
[Optional, Default: false] Automatically mute TX when TX begins
Agc inputAgc
[Optional] Automatic Gain Control for audio inputs
bool hardwareEnabled
[Optional, Default: true] Enables local machine hardware audio
Aec aec
[Optional] Acoustic echo cancellation settings
bool denoiseInput
[Optional, Default: false] Denoise input
bool saveInputPcm
[Optional, Default: false] If true, input audio is written to a PCM file in the data directory
bool denoiseOutput
[Optional, Default: false] Denoise output
int internalChannels
[Optional, Default: 2] Internal audio channel count rate - 1 or 2
Provides Engage Engine policy configuration.
std::vector< ExternalModule > externalCodecs
Optional external codecs.
EnginePolicyNamedAudioDevices namedAudioDevices
Optional named audio devices (Linux only)
Featureset featureset
Optional feature set.
EnginePolicyDatabase database
Database settings.
EnginePolicyAudio audio
Audio settings.
std::string dataDirectory
Specifies the root of the physical path to store data.
Licensing licensing
Licensing settings.
EnginePolicyLogging logging
Logging settings.
DiscoveryConfiguration discovery
Discovery settings.
std::vector< RtpMapEntry > rtpMap
Optional RTP - overrides the default.
EngineStatusReportConfiguration statusReport
Optional statusReport - details for the status report.
EnginePolicyInternals internals
Internal settings.
EnginePolicySecurity security
Security settings.
EnginePolicyTimelines timelines
Timelines settings.
EnginePolicyNetworking networking
Security settings.
Internal Engage Engine settings.
TuningSettings tuning
[Optional] Low-level tuning
int stickyTidHangSecs
[Optional, Default: 10] The number of seconds after which "sticky" transmission IDs expire.
int maxTxSecs
[Optional, Default: 30] The default duration the engageBeginGroupTx and engageBeginGroupTxAdvanced fu...
int rpConnectionTimeoutSecs
[Optional, Default: 5] Connection timeout in seconds to RP
WatchdogSettings watchdog
[Optional] Settings for the Engine's watchdog.
RallypointCluster::ConnectionStrategy_t rpClusterStrategy
[Optional, Default: csRoundRobin] Specifies the default RP cluster connection strategy to be followed...
int delayedMicrophoneClosureSecs
[Optional, Default: 15] The number of seconds to cache an open microphone before actually closing it.
int rtpExpirationCheckIntervalMs
[Optional, Default: 250] Interval at which to check for RTP expiration.
int rpClusterRolloverSecs
[Optional, Default: 10] Seconds between switching to a new target in a RP cluster
int housekeeperIntervalMs
[Optional, Default: 1000] Interval at which to run the housekeeper thread.
int uriStreamingIntervalMs
[Optional, Default: 60] The packet framing interval for audio streaming from a URI.
int maxLevel
[Optional, Default: 4, Range: 0-4] This is the maximum logging level to display in other words,...
EngineNetworkingRpUdpStreaming rpUdpStreaming
[Optional] Configuration for UDP streaming
std::string defaultNic
The default network interface card the Engage Engine should bind to.
RtpProfile rtpProfile
[Optional] Configuration for RTP profile
AddressResolutionPolicy_t addressResolutionPolicy
[Optional, Default 64] Address resolution policy
int multicastRejoinSecs
[Optional, Default: 8] Number of seconds elapsed between RX of multicast packets before an IGMP rejoi...
bool logRtpJitterBufferStats
[Optional, Default: false] If true, logs RTP jitter buffer statistics periodically
int rallypointRtTestIntervalMs
[Optional, Default: 60000] Milliseconds between sending Rallypoint round-trip test requests
bool preventMulticastFailover
[Optional, Default: false] Overrides/cancels group-level multicast failover if set to true
Default certificate to use for security operation in the Engage Engine.
SecurityCertificate certificate
The default certificate and private key for the Engine instance.
std::vector< std::string > caCertificates
[Optional] An array of CA certificates to be used for validation of far-end X.509 certificates
Engine Policy Timeline configuration.
long autosaveIntervalSecs
[Default 5] Interval at which events are to be saved from memory to disk (a slow operation)
int maxStorageMb
Specifies the maximum storage space to use.
bool enabled
[Optional, Default: true] Specifies if Time Lines are enabled by default.
int maxDiskMb
Specifies the maximum disk space to use - defaults to maxStorageMb.
SecurityCertificate security
The certificate to use for signing the recording.
int maxAudioEventMemMb
Specifies the maximum number of megabytes to allow for a single audio event's memory block - defaults...
long maxEventAgeSecs
Maximum age of an event after which it is to be erased.
int maxMemMb
Specifies the maximum memory to use - defaults to maxStorageMb.
std::string storageRoot
Specifies where the timeline recordings will be stored physically.
bool ephemeral
[Default false] If true, recordings are automatically purged when the Engine is shut down and/or rein...
bool disableSigningAndVerification
[Default false] If true, prevents signing of events - i.e. no anti-tanpering features will be availab...
int maxEvents
Maximum number of events to be retained.
long groomingIntervalSecs
Interval at which events are to be checked for age-based grooming.
TODO: Configuration for the translation server status report file.
bool includeTaskQueueDetail
Describes an external codec.
int samplingRate
Sampling rate.
int rtpPayloadType
RTP payload type.
int rtpTsMultiplier
RTP timestamp multiplier.
TODO: Configuration to enable external systems to use to check if the service is still running.
Base for a description of an external module.
std::string file
File spec.
nlohmann::json configuration
Optional free-form JSON configuration to be passed to the module.
bool debug
[Optional, Default false] If true, requests the crypto engine module to run in debugging mode.
bool enabled
[Optional, Default false] If true, requires FIPS140-2 crypto operation.
std::string curves
[Optional] Specifies the NIST-approved curves to be used for FIPS
std::string path
Path where the crypto engine module is located
std::string ciphers
[Optional] Specifies the NIST-approved ciphers to be used for FIPS
Configuration for the optional custom transport functionality for Group.
bool enabled
[Optional, Default: false] Enables custom feature.
std::string id
The id/name of the transport. This must match the id/name supplied when registering the app transport...
Detailed information for a group connection.
std::string id
ID of the group.
std::string peer
Peer information.
ConnectionType_t
Connection type.
bool asFailover
Indicates whether the connection is for purposes of failover.
ConnectionType_t connectionType
The connection type.
std::string reason
[Optional] Additional reason information
Detailed information for a group creation.
std::string id
ID of the group.
CreationStatus_t status
The creation status.
CreationStatus_t
Creation status.
Detailed information regarding a group's health.
GroupAppTransport appTransport
[Optional] Settings necessary if the group is transported via an application-supplied custom transpor...
std::string source
[Optional, Default: null] Indicates the source of this configuration - e.g. from the application or d...
Presence presence
Presence configuration (see Presence).
std::vector< uint16_t > specializerAffinities
List of specializer IDs that the local node has an affinity for/member of.
std::vector< Source > ignoreSources
[Optional] List of sources to ignore for this group
NetworkAddress rtcpPresenceRx
The network address for receiving RTCP presencing packets.
bool allowLoopback
[Optional, Default: false] Allows for processing of looped back packets - primarily meant for debuggi...
Type_t
Enum describing the group types.
NetworkAddress tx
The network address for transmitting network traffic to.
std::string alias
User alias to transmit as part of the realtime audio stream when using the engageBeginGroupTx API.
int stickyTidHangSecs
[Optional, Default: 10] The number of seconds after which "sticky" transmission IDs expire.
TxAudio txAudio
Audio transmit options such as codec, framing size etc (see TxAudio).
int maxRxSecs
[Optional, Default: 0] Maximum number of seconds the Engine will receive for on this group.
PacketCapturer txCapture
Details for capture of transmitted packets
NetworkTxOptions txOptions
Transmit options for the group (see NetworkTxOptions).
std::string synVoice
Name of the synthesis voice to use for the group
TransportImpairment rxImpairment
[Optional] The RX impairment to apply
std::string languageCode
ISO 639-2 language code for the group
std::string cryptoPassword
Password to be used for encryption. Note that this is not the encryption key but, rather,...
std::vector< std::string > presenceGroupAffinities
List of presence group IDs with which this group has an affinity.
GroupTimeline timeline
Audio timeline is configuration.
GroupPriorityTranslation priorityTranslation
[Optional] Describe how traffic for this group on a different addressing scheme translates to priorit...
bool disablePacketEvents
[Optional, Default: false] Disable packet events.
bool blockAdvertising
[Optional, Default: false] Set this to true if you do not want the Engine to advertise this Group on ...
bool ignoreAudioTraffic
[Optional, Default: false] Indicates that the group should ignore traffic that is audio-related
std::string interfaceName
The name of the network interface to use for multicasting for this group. If not provided,...
bool _wasDeserialized_rtpProfile
[Internal - not serialized
bool enableMulticastFailover
[Optional, Default: false] Set this to true to enable failover to multicast operation if a Rallypoint...
std::string name
The human readable name for the group.
NetworkAddress rx
The network address for receiving network traffic on.
Type_t type
Specifies the group type (see Type_t).
uint16_t blobRtpPayloadType
[Optional, Default: ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE] The RTP payload type to be used for blobs s...
std::vector< Rallypoint > rallypoints
[DEPRECATED] List of Rallypoint (s) the Group should use to connect to a Rallypoint router....
BridgingOpMode_t bom
Specifies the bridging operation mode if applicable (see BridgingOpMode_t).
BridgingOpMode_t
Enum describing bridging operation mode types where applicable.
RtpProfile rtpProfile
[Optional] RTP profile the group
std::vector< RtpPayloadTypeTranslation > inboundRtpPayloadTypeTranslations
[Optional] A vector of translations from external entity RTP payload types to those used by Engage
int multicastFailoverSecs
[Optional, Default: 10] Specifies the number fo seconds to wait after Rallypoint connection failure t...
InboundAliasGenerationPolicy_t
Enum describing the alias generation policy.
RangerPackets rangerPackets
[Optional] Ranger packet options
int rfc4733RtpPayloadId
[Optional, Default: 0] The RTP payload ID by which to identify (RX and TX) payloads encoded according...
uint32_t securityLevel
[Optional, Default: 0] The security classification level of the group.
PacketCapturer rxCapture
Details for capture of received packets
std::string id
Unique identity for the group.
AudioGate gateIn
[Optional] Inbound gating of audio - only audio allowed through by the gate will be processed
RallypointCluster rallypointCluster
Cluster of one or more Rallypoints the group may use.
TransportImpairment txImpairment
[Optional] The TX impairment to apply
Audio audio
Sets audio properties like which audio device to use, audio gain etc (see Audio).
bool lbCrypto
[Optional, Default: false] Use low-bandwidth crypto
std::string spokenName
The group name as spoken - typically by a text-to-speech system
InboundAliasGenerationPolicy_t inboundAliasGenerationPolicy
[Optional, Default: iagpAnonymousAlias]
std::string anonymousAlias
[Optional] Alias to use for inbound streams that do not have an alias component
Details for priority transmission based on unique network addressing.
NetworkAddress tx
TX addressing.
int priority
Engage priority for RX & TX.
NetworkAddress rx
RX addressing.
Detailed information for a group reconfiguration.
ReconfigurationStatus_t status
The creation status.
std::string id
ID of the group.
ReconfigurationStatus_t
Reconfiguration status.
Detailed statistics for group.
List of TalkerInformation objects.
std::vector< TalkerInformation > list
List of TalkerInformation objects.
Configuration for Timeline functionality for Group.
bool enabled
[Optional, Default: true] Enables timeline feature.
int maxAudioTimeMs
[Optional, Default: 30000] Maximum audio block size to record in milliseconds.
Detailed information for a group transmit.
std::string id
ID of the group.
int remotePriority
Remote TX priority (optional)
long nonFdxMsHangRemaining
Milliseconds of hang time remaining on a non-FDX group (optional)
int localPriority
Local TX priority (optional)
uint32_t txId
Transmission ID (optional)
TxStatus_t status
The TX status.
std::string displayName
[Optional, Default: empty string] The display name to be used for the user.
std::string userId
[Optional, Default: empty string] The user ID to be used to represent the user.
std::string nodeId
[Optional, Default: Auto Generated] This is the Node ID to use to represent instance on the network.
std::string avatar
[Optional, Default: empty string] This is a application defined field used to indicate a users avatar...
Configuration for IGMP snooping.
int queryIntervalMs
[Optional, Default 125000] Interval between sending IGMP membership queries. If 0,...
int subscriptionTimeoutMs
[Optional, Default 0] Typically calculated according to RFC specifications. Set a value here to manua...
bool enabled
Enables IGMP. Default is false.
Detailed statistics for an inbound processor.
Helper class for serializing and deserializing the LicenseDescriptor JSON.
std::string entitlement
Entitlement key to use for the product.
std::string cargo
Reserved for internal use.
std::string manufacturerId
[Read only] Manufacturer ID.
std::string key
License Key to be used for the application.
uint8_t cargoFlags
Reserved for internal use.
int type
[Read only] 0 = unknown, 1 = perpetual, 2 = expires
std::string deviceId
[Read only] Unique device identifier generated by the Engine.
int status
The current licensing status.
time_t expires
[Read only] The time that the license key or activation code expires in Unix timestamp - Zulu/UTC.
std::string activationCode
If the key required activation, this is the activation code generated using the entitlement,...
std::string expiresFormatted
[Read only] The time that the license key or activation code expires formatted in ISO 8601 format,...
std::string deviceId
Device Identifier. See LicenseDescriptor::deviceId for details.
std::string manufacturerId
Manufacturer ID to use for the product. See LicenseDescriptor::manufacturerId for details.
std::string activationCode
Activation Code issued for the license key. See LicenseDescriptor::activationCode for details.
std::string key
License key. See LicenseDescriptor::key for details.
std::string entitlement
Entitlement key to use for the product. See LicenseDescriptor::entitlement for details.
std::vector< Group > groups
Array of groups in the configuration.
std::vector< VoiceToVoiceSession > voiceToVoiceSessions
Array of voiceToVoice sessions in the configuration.
Configuration for the linguistics server.
LingoServerStatusReportConfiguration statusReport
Details for producing a status report.
std::string lingoConfigurationFileName
Name of a file containing the linguistics configuration.
std::string configurationCheckSignalName
Name to use for signalling a configuration check.
std::string id
A unqiue identifier for the linguistics server.
ExternalHealthCheckResponder externalHealthCheckResponder
Details concerning the server's interaction with an external health-checker such as a load-balancer.
NsmConfiguration nsm
[Optional] Settings for NSM.
std::string certStorePasswordHex
Hex password for the certificate store (if any)
std::string lingoConfigurationFileCommand
Command-line to execute that returns a linguistics configuration.
LingoServerInternals internals
Internal settings.
EnginePolicy enginePolicy
The policy to be used for the underlying Engage Engine.
int lingoConfigurationFileCheckSecs
Number of seconds between checks to see if the linguistics configuration has been updated....
std::string certStoreFileName
Path to the certificate store.
FipsCryptoSettings fipsCrypto
[Optional] Settings for the FIPS crypto.
NetworkAddress proxy
Address and port of the proxy.
int serviceConfigurationFileCheckSecs
Number of seconds between checks to see if the service configuration has been updated....
Internal translator server settings.
int housekeeperIntervalMs
[Optional, Default: 1000] Interval at which to run the housekeeper thread.
WatchdogSettings watchdog
[Optional] Settings for the watchdog.
TuningSettings tuning
[Optional] Low-level tuning
TODO: Configuration for the translation server status report file.
bool includeSessionGroupDetail
bool includeSessionDetail
Location information used as part of the PresenceDescriptor.
double longitude
Its the longitudinal position using the Signed degrees format (DDD.dddd) format. Valid range is -180 ...
double altitude
[Optional, Default: INVALID_LOCATION_VALUE] The altitude above sea level in meters.
uint32_t ts
[Read Only: Unix timestamp - Zulu/UTC] Indicates the timestamp that the location was recorded.
double latitude
Its the latitude position using the using the Signed degrees format (DDD.dddd). Valid range is -90 to...
double direction
[Optional, Default: INVALID_LOCATION_VALUE] Direction the endpoint is traveling in degrees....
double speed
[Optional, Default: INVALID_LOCATION_VALUE] The speed the endpoint is traveling at in meters per seco...
std::string address
IP address.
NetworkAddressRestrictionList.
RestrictionType_t type
Type indicating how the elements are to be treated.
std::vector< NetworkAddressRxTx > elements
List of elements.
Custom Network Device Configuration.
std::string manufacturer
Device manufacturer (if any)
std::string model
Device mode (if any)
int deviceId
[Read Only] Unique device identifier assigned by Engage Engine at time of device creation.
std::string extra
Extra data provided by the platform (if any)
std::string type
Device type (if any)
std::string hardwareId
Device hardware ID (if any)
std::string serialNumber
Device serial number (if any)
std::string name
Name of the device assigned by the platform.
Network Transmit Options.
int ttl
[Optional, Default: 1] Time to live or hop limit is a mechanism that limits the lifespan or lifetime ...
TxPriority_t priority
[Optional, Default: priVoice] Transmission priority. This has meaning on some operating systems based...
Description of a packet capturer.
Configuration for Rallypoint peers.
int version
TODO: A version number for the mesh configuration. Change this whenever you update your configuration...
std::string comments
Comments.
std::string id
An identifier useful for organizations that track different mesh configurations by ID.
std::vector< RallypointPeer > peers
List of Rallypoint peers to connect to.
Device Power Information used as part of the PresenceDescriptor.
int state
[Optional, Default: 0] Is the current state that the power system is in.
int source
[Optional, Default: 0] Is the source the power is being delivered from
int level
[Optional, Default: 0] Is the current level of the battery or power system as a percentage....
Group Alias used as part of the PresenceDescriptor.
uint16_t status
Status flags for the user's participation on the group.
std::string alias
User's alias for the group.
std::string groupId
Group Id the alias is associated with.
Represents an endpoints presence properties. Used in engageUpdatePresenceDescriptor API and PFN_ENGAG...
Power power
[Optional, Default: see Power] Device power information like charging state, battery level,...
std::string custom
[Optional, Default: empty string] Custom string application can use of presence descriptor....
bool self
[Read Only] Indicates that this presence declaration was generated by the Engage Engine the applicati...
uint32_t nextUpdate
[Read Only, Unix timestamp - Zulu/UTC] Indicates the next time the presence descriptor will be sent.
std::vector< PresenceDescriptorGroupItem > groupAliases
[Read Only] List of group items associated with this presence descriptor.
Identity identity
[Optional, Default see Identity] Endpoint's identity information.
bool announceOnReceive
[Read Only] Indicates that the Engine will announce its PresenceDescriptor in response to this messag...
uint32_t ts
[Read Only, Unix timestamp - Zulu/UTC] Indicates the timestamp that the message was originally sent.
std::string comment
[Optional] No defined limit on size but the total size of the serialized JSON object must fit inside ...
Connectivity connectivity
[Optional, Default: see Connectivity] Device connectivity information like wifi/cellular,...
uint32_t disposition
[Optional] Indicates the users disposition
Location location
[Optional, Default: see Location] Location information
Describes how the Presence is configured for a group of type Group::gtPresence in Group::Type_t.
Format_t format
Format to be used to represent presence information.
Format_t
Presence format types enum.
bool listenOnly
Instructs the Engage Engine to not transmit presence descriptor.
int minIntervalSecs
[Optional, Default: 5] The minimum interval to send at to prevent network flooding
int intervalSecs
[Optional, Default: 30] The interval in seconds at which to send the presence descriptor on the prese...
Defines settings for Rallypoint advertising.
std::string interfaceName
The multicast network interface for mDNS.
std::string serviceName
[Optional, Default "_rallypoint._tcp.local."] The service name
std::string hostName
[Optional] This Rallypoint's DNS-SD host name
int port
[Default: RP port] The multicast network interface for mDNS
bool enabled
[Default: false] Advertising is enabled
int ttl
[Default: 60] TTL for service TTL
int rolloverSecs
Seconds between switching to a new target.
ConnectionStrategy_t
Connection strategy enum.
int connectionTimeoutSecs
[Optional, Default: 0] Default connection timeout in seconds to any RP in the cluster
std::vector< Rallypoint > rallypoints
List of Rallypoints.
ConnectionStrategy_t connectionStrategy
[Optional, Default: csRoundRobin] Specifies the connection strategy to be followed....
Detailed information for a rallypoint connection.
std::string internalId
Id.
float serverProcessingMs
Server processing time in milliseconds - used for roundtrip reports.
uint64_t msToNextConnectionAttempt
Milliseconds until next connection attempt.
Defines settings for Rallypoint extended group restrictions.
std::vector< StringRestrictionList > restrictions
Restrictions.
int transactionTimeoutMs
[Optional, Default 5000] Number of milliseconds that a transaction may take before the link is consid...
bool allowSelfSignedCertificate
[Optional, Default false] Allows the Rallypoint to accept self-signed certificates from the far-end
std::vector< std::string > caCertificates
[Optional] A vector of certificates (raw content, file names, or certificate store elements) used to ...
std::string certificate
This is the X509 certificate to use for mutual authentication.
bool verifyPeer
[Optional, Default true] Indicates whether the connection peer is to be verified by checking the vali...
bool disableMessageSigning
[Optional, Default false] Indicates whether to forego ECSDA signing of control-plane messages.
NetworkAddress host
This is the host address for the Engine to connect to the RallyPoint service.
std::string certificateKey
This is the private key used to generate the X509 certificate.
int connectionTimeoutSecs
[Optional, Default: 5] Connection timeout in seconds to the RP
TcpNetworkTxOptions tcpTxOptions
[Optional] Tx options for the TCP link
SecurityCertificate certificate
Internal certificate detail.
std::string id
Internal ID.
bool forceIsMeshLeaf
Internal enablement setting.
int connectionTimeoutSecs
[Optional, Default: 0 - OS platform default] Connection timeout in seconds to the peer
NetworkAddress host
Internal host detail.
bool enabled
Internal enablement setting.
Definition of a static group for Rallypoints.
NetworkAddress rx
The network address for receiving network traffic on.
std::string id
Unique identity for the group.
std::vector< NetworkAddress > additionalTx
[Optional] Vector of additional TX addresses .
NetworkAddress tx
The network address for transmitting network traffic to.
DirectionRestriction_t directionRestriction
[Optional] Restriction of direction of traffic flow
DirectionRestriction_t
Enum describing direction(s) for the reflector.
std::string multicastInterfaceName
[Optional] The name of the NIC on which to send and receive multicast traffic.
Defines a behavior for a Rallypoint peer roundtrip time.
BehaviorType_t
Enum describing behavior types.
@ btReportWarn
Report at level warning.
@ btReportError
Report at level error.
@ btReportInfo
Report at level info.
BehaviorType_t behavior
Specifies the streaming mode type (see BehaviorType_t).
uint32_t atOrAboveMs
Network address for listening.
Configuration for the Rallypoint server.
uint32_t maxSecurityLevel
[Optional, Default 0] Sets the maximum item security level that can be registered with the RP
bool forwardDiscoveredGroups
Enables automatic forwarding of discovered multicast traffic to peer Rallypoints.
std::string interfaceName
Name of the NIC to bind to for listening for incoming TCP connections.
NetworkTxOptions multicastTxOptions
Tx options for multicast.
bool disableMessageSigning
Set to true to forgo DSA signing of messages. Doing so is is a security risk but can be useful on CPU...
SecurityCertificate certificate
X.509 certificate and private key that identifies the Rallypoint.
std::string multicastInterfaceName
The name of the NIC on which to send and receive multicast traffic.
StringRestrictionList groupRestrictions
Group IDs to be restricted (inclusive or exclusive)
std::string peeringConfigurationFileName
Name of a file containing a JSON array of Rallypoint peers to connect to.
uint32_t sysFlags
[Optional, Default 0] Internal system flags
int listenPort
TCP port to listen on. Default is 7443.
FipsCryptoSettings fipsCrypto
[Optional] Settings for the FIPS crypto.
NetworkAddressRestrictionList multicastRestrictions
Multicasts to be restricted (inclusive or exclusive)
uint32_t normalTaskQueueBias
[Optional, Default 0] Sets the queue's normal task bias
PacketCapturer txCapture
Details for capture of transmitted packets
std::vector< RallypointReflector > staticReflectors
Vector of static groups.
bool enableLeafReflectionReverseSubscription
If enabled, causes a mesh leaf to reverse-subscribe to a core node upon the core subscribing and a re...
std::string configurationCheckSignalName
Name to use for signalling a configuration check.
IpFamilyType_t ipFamily
[Optional, Default IpFamilyType_t::ifIp4] Address familiy to be used for listening
int peerRtTestIntervalMs
[Optional, Default: 60000] Milliseconds between sending round-trip test requests to peers
WatchdogSettings watchdog
[Optional] Settings for the Rallypoint's watchdog.
DiscoveryConfiguration discovery
Details discovery capabilities.
bool isMeshLeaf
Indicates whether this Rallypoint is part of a core mesh or hangs off the periphery as a leaf node.
std::string certStorePasswordHex
Hex password for the certificate store (if any)
GroupRestrictionAccessPolicyType_t groupRestrictionAccessPolicyType
The policy employed to allow group registration.
Licensing licensing
Licensing settings.
PacketCapturer rxCapture
Details for capture of received packets
std::string meshName
[Optional] This Rallypoint's mesh name
uint32_t maxOutboundPeerConnectionIntervalDeltaSecs
[Optional, Default 15] Sets the delta value for the maximum number of seconds to delay when attemptin...
TuningSettings tuning
[Optional] Low-level tuning
RallypointAdvertisingSettings advertising
[Optional] Settings for advertising.
Featureset featureset
Optional feature set.
ExternalHealthCheckResponder externalHealthCheckResponder
Details concerning the Rallypoint's interaction with an external health-checker such as a load-balanc...
std::vector< RallypointExtendedGroupRestriction > extendedGroupRestrictions
Extended group restrictions.
int ioPools
Number of threading pools to create for network I/O. Default is -1 which creates 1 I/O pool per CPU c...
RallypointServerStatusReportConfiguration statusReport
Details for producing a status report.
IgmpSnooping igmpSnooping
IGMP snooping configuration.
RallypointServerLinkGraph linkGraph
Details for producing a Graphviz-compatible link graph.
RallypointServerLimits limits
Details for capacity limits and determining processing load.
PeeringConfiguration peeringConfiguration
Internal - not serialized.
std::vector< std::string > extraMeshes
[Optional] List of additional meshes that can be reached via this RP
bool allowMulticastForwarding
Allows traffic received on unicast links to be forwarded to the multicast network.
RallypointWebsocketSettings websocket
[Optional] Settings for websocket operation
std::string peeringConfigurationFileCommand
Command-line to execute that returns a JSON array of Rallypoint peers to connect to.
RallypointServerRouteMap routeMap
Details for producing a report containing the route map.
bool allowPeerForwarding
Set to true to allow forwarding of packets received from other Rallypoints to all other Rallypoints....
TcpNetworkTxOptions tcpTxOptions
Tx options for TCP.
RallypointUdpStreaming udpStreaming
Optional configuration for high-performance UDP streaming.
bool forwardMulticastAddressing
Enables forwarding of multicast addressing to peer Rallypoints.
std::vector< RallypointRpRtTimingBehavior > peerRtBehaviors
[Optional] Array of behaviors for roundtrip times to peers
std::string id
A unqiue identifier for the Rallypoint.
NsmConfiguration nsm
[Optional] Settings for NSM.
bool disableLoopDetection
If true, turns off loop detection.
std::string certStoreFileName
Path to the certificate store.
int peeringConfigurationFileCheckSecs
Number of seconds between checks to see if the peering configuration has been updated....
Tls tls
Details concerning Transport Layer Security.
TODO: Configuration for Rallypoint limits.
uint32_t maxQOpsPerSec
Maximum number of queue operations per second (0 = unlimited)
uint32_t maxInboundBacklog
Maximum number of inbound backlog requests the Rallypoint will accept.
uint32_t normalPriorityQueueThreshold
Number of normal priority queue operations after which new connections will not be accepted.
uint32_t maxPeers
Maximum number of peers (0 = unlimited)
uint32_t maxTxBytesPerSec
Maximum number of bytes transmitted per second (0 = unlimited)
uint32_t maxTxPacketsPerSec
Maximum number of packets transmitted per second (0 = unlimited)
uint32_t maxRegisteredStreams
Maximum number of registered streams (0 = unlimited)
uint32_t maxClients
Maximum number of clients (0 = unlimited)
uint32_t maxMulticastReflectors
Maximum number of multicastReflectors (0 = unlimited)
uint32_t maxStreamPaths
Maximum number of bidirectional stream paths (0 = unlimited)
uint32_t lowPriorityQueueThreshold
Number of low priority queue operations after which new connections will not be accepted.
uint32_t maxRxBytesPerSec
Maximum number of bytes received per second (0 = unlimited)
uint32_t denyNewConnectionCpuThreshold
The CPU utilization threshold percentage (0-100) beyond which new connections are denied.
uint32_t maxRxPacketsPerSec
Maximum number of packets received per second (0 = unlimited)
uint32_t warnAtCpuThreshold
The CPU utilization threshold percentage (0-100) beyond which warnings are logged.
std::string leafRpStyling
std::string coreRpStyling
bool includeDigraphEnclosure
std::string clientStyling
TODO: Configuration for the Rallypoint status report file.
bool includePeerLinkDetails
bool includeClientLinkDetails
Streaming configuration for RP clients.
int listenPort
UDP port to listen on. Default is 7444.
TxPriority_t priority
[Optional, Default: priVoice] Transmission priority. This has meaning on some operating systems based...
RallypointUdpStreamingIpvX ipv4
IPv4
bool enabled
[Optional, Default true] If true, enables UDP streaming unless turned off on a per-family basis.
CryptoType_t cryptoType
[Optional, Default ctSharedKeyAes256FullIv] The crypto method to be used
int ttl
[Optional, Default: 64] Time to live or hop limit.
CryptoType_t
Enum describing UDP streaming modes.
int keepaliveIntervalSecs
[Optional, Default: 15] Interval (seconds) at which to send UDP keepalives
RallypointUdpStreamingIpvX ipv6
IPv6.
Streaming configuration for RP clients.
bool enabled
[Optional, Default true] If true, enables UDP streaming for vX.
NetworkAddress external
Network address for external entities to transmit to. Defaults to the address of the local interface ...
Defines settings for Rallypoint websockets functionality.
int listenPort
Listen port (TCP). Default is 8443.
SecurityCertificate certificate
Certificate to be used for WebSockets.
bool enabled
[Default: false] Websocket is enabled
Options for Ranger packets.
int count
[Optional, Default: 5] Number of ranger packets to send when a new interval starts
int hangTimerSecs
[Optional, Default: -1] Number of seconds since last packet transmission before 'count' packets are s...
Helper class for serializing and deserializing the RiffDescriptor JSON.
CertificateDescriptor certDescriptor
[Optional] X.509 certificate parsed into a CertificateDescriptor object.
std::string meta
[Optional] Meta data associated with the file - typically a stringified JSON object.
bool verified
True if the ECDSA signature is verified.
int channels
Number of audio channels.
std::string signature
[Optional] ECDSA signature
std::string certPem
[Optional] X.509 certificate in PEM format used to sign the RIFF file.
int sampleCount
Number of audio samples.
std::string file
Name of the RIFF file.
std::string name
Name of the CODEC.
int engageType
An integer representing the codec type.
int rtpPayloadType
The RTP payload type identifier.
RtpPayloadTypeTranslation.
uint16_t engage
The payload type used by Engage.
uint16_t external
The payload type used by the external entity.
Configuration for the optional RtpProfile.
JitterMode_t
Jitter buffer mode.
int signalledInboundProcessorInactivityMs
[Optional, Default: inboundProcessorInactivityMs * 4] The number of milliseconds of RTP inactivity on...
int jitterUnderrunReductionAger
[Optional, Default: 100] Number of jitter buffer operations after which to reduce any underrun
int jitterMinMs
[Optional, Default: 100] Low-water mark for jitter buffers that are in a buffering state.
int jitterMaxFactor
[Optional, Default: 8] The factor by which to multiply the jitter buffer's active low-water to determ...
int inboundProcessorInactivityMs
[Optional, Default: 500] The number of milliseconds of RTP inactivity before heuristically determinin...
JitterMode_t mode
[Optional, Default: jmStandard] Specifies the operation mode (see JitterMode_t).
int jitterForceTrimAtMs
[Optional, Default: 0] Forces trimming of the jitter buffer if the queue length is greater (and not z...
int latePacketSequenceRange
[Optional, Default: 5] The delta in RTP sequence numbers in order to heuristically determine the star...
int jitterMaxExceededClipHangMs
[Optional, Default: 1500] Number of milliseconds for which the jitter buffer may exceed max before cl...
int jitterTrimPercentage
[Optional, Default: 10] The percentage of the overall jitter buffer sample count to trim when potenti...
int jitterMaxTrimMs
[Optional, Default: 250] Maximum number of milliseconds to be trimmed from a jitter buffer at any one...
int jitterMaxMs
[Optional, Default: 10000] Maximum number of milliseconds allowed in the queue
int latePacketTimestampRangeMs
[Optional, Default: 500] The delta in milliseconds in order to heuristically determine the start of a...
int jitterMaxExceededClipPerc
[Optional, Default: 10] Percentage by which maximum number of samples in the queue exceeded computed ...
int zombieLifetimeMs
[Optional, Default: 15000] The number of milliseconds that a "zombified" RTP processor is kept around...
int rtcpPresenceTimeoutMs
[Optional, Default: 45000] Timeout for RTCP presence.
int jitterUnderrunReductionThresholdMs
[Optional, Default: 1500] Number of milliseconds of error-free operations in a jitter buffer before t...
Configuration for a secure signature.
std::string signature
Contains the signature.
std::string certificate
Contains the PEM-formatted text of the certificate.
Configuration for a Security Certificate used in various configurations.
std::string key
As for above but for certificate's private key.
std::string certificate
Contains the PEM-formatted text of the certificate, OR, a reference to a PEM file denoted by "@file:/...
std::string alias
[Optional] An alias
std::string nodeId
[Optional] A node ID
RestrictionType_t type
Type indicating how the elements are to be treated.
std::vector< std::string > elements
List of elements.
RestrictionElementType_t elementsType
Type indicating what kind of data each element contains.
std::string nodeId
A unique identifier for the asset.
Group group
Details for the talkgroup.
Network Transmit Options for TCP.
Parameters for querying the group timeline.
bool onlyCommitted
Include only committed (not in-progress) events.
uint64_t startedOnOrAfter
Include events that started on or after this UNIX millisecond timestamp.
int onlyType
Include events for this type.
long maxCount
Maximum number of records to return.
uint64_t endedOnOrBefore
Include events that ended on or after this UNIX millisecond timestamp.
std::string sql
Ignore all other settings for SQL construction and use this query string instead.
bool mostRecentFirst
Sorted results with most recent timestamp first.
std::string onlyNodeId
Include events for this transmitter node ID.
int onlyDirection
Include events for this direction.
int onlyTxId
Include events for this transmission ID.
std::string onlyAlias
Include events for this transmitter alias.
TODO: Transport Security Layer (TLS) settings.
bool verifyPeers
[Optional, Default: true] When true, checks the far-end certificate validity and Engage-specific TLS ...
StringRestrictionList subjectRestrictions
[NOT USED AT THIS TIME]
std::vector< std::string > caCertificates
[Optional] Array of CA certificates (PEM or "@" file/certstore references) to be used to validate far...
StringRestrictionList issuerRestrictions
[NOT USED AT THIS TIME]
bool allowSelfSignedCertificates
[Optional, Default: false] When true, accepts far-end certificates that are self-signed.
std::vector< std::string > crlSerials
[Optional] Array of serial numbers certificates that have been revoked
Translation configuration.
std::vector< TranslationSession > sessions
Array of sessions in the configuration.
std::vector< Group > groups
Array of groups in the configuration.
Translation session settings.
std::vector< std::string > groups
List of group IDs to be included in the session.
bool enabled
[Optional, Default: true] Enable the session
Description of a transport impairment.
uint32_t maxActiveBlobObjects
[Optional, Default 0 (no max)] Maximum number of blob objects allowed to be active
uint32_t maxActiveRtpProcessors
[Optional, Default 0 (no max)] Maximum number concurrent RTP processors
uint32_t maxPooledBufferMb
[Optional, Default 0 (no max)] Maximum number of buffer bytes allowed to be pooled
uint32_t maxActiveBufferObjects
[Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be active
uint32_t maxPooledBufferObjects
[Optional, Default 0 (no max)] Maximum number of buffer objects allowed to be pooled
uint32_t maxPooledRtpObjects
[Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be pooled
uint32_t maxPooledBlobMb
[Optional, Default 0 (no max)] Maximum number of blob bytes allowed to be pooled
uint32_t maxPooledRtpMb
[Optional, Default 0 (no max)] Maximum number of RTP bytes allowed to be pooled
uint32_t maxActiveRtpObjects
[Optional, Default 0 (no max)] Maximum number of RTP objects allowed to be active
uint32_t maxPooledBlobObjects
[Optional, Default 0 (no max)] Maximum number of blob objects allowed to be pooled
Configuration for the audio transmit properties for a group.
int startTxNotifications
[Optional, Default: 5] Number of start TX notifications to send when TX is about to begin.
int framingMs
[Optional, Default: 60] Audio sample framing size in milliseconds.
int maxTxSecs
[Optional, Default: 0] Maximum number of seconds the Engine will transmit for.
uint32_t internalKey
[INTERNAL] The Engine-assigned key for the codec
bool enabled
[Optional, Default: true] Audio transmission is enabled
bool fdx
[Optional, Default: false] Indicates if full duplex audio is supported.
int initialHeaderBurst
[Optional, Default: 5] Number of headers to send at the beginning of a talk burst.
bool resetRtpOnTx
[Optional, Default: true] Resets RTP counters on each new transmission.
bool dtx
[Optional, Default: false] Support discontinuous transmission on those CODECs that allow it
std::string encoderName
[Optional] The name of the external codec - overrides encoder
TxCodec_t encoder
[Optional, Default: ctOpus8000] Specifies the Codec Type to use for the transmission....
int blockCount
[Optional, Default: 0] If >0, derives framingMs based on the encoder's internal operation
int smoothedHangTimeMs
[Optional, Default: 0] Hang timer for ongoing TX - only applicable if enableSmoothing is true
int customRtpPayloadType
[Optional, Default: -1] The custom RTP payload type to use for transmission. A value of -1 causes the...
bool noHdrExt
[Optional, Default: false] Set to true whether to disable header extensions.
bool enableSmoothing
[Optional, Default: true] Smooth input audio
int trailingHeaderBurst
[Optional, Default: 5] Number of headers to send at the conclusion of a talk burst.
int extensionSendInterval
[Optional, Default: 10] The number of packets when to periodically send the header extension.
TxCodec_t
Codec Types enum.
Optional audio streaming from a URI for engageBeginGroupTxAdvanced.
std::string uri
URI for the file.
int repeatCount
[Optional, Default: 0] Number of times to repeat
Voice Activity Detection settings.
bool enabled
[Optional, Default: false] Enable VAD
Mode_t mode
[Optional, Default: vamDefault] Specifies VAD mode. See Mode_t for all modes
Voice to voice session settings.
std::vector< std::string > groups
List of group IDs to be included in the session.
bool enabled
[Optional, Default: true] Enable the session
int intervalMs
[Optional, Default: 5000] Interval at which checks are made.
int hangDetectionMs
[Optional, Default: 2000] Number of milliseconds that must pass before a hang is assumed.
int slowExecutionThresholdMs
[Optional, Default: 100] Maximum number of milliseconds that a task may take before being considered ...
bool abortOnHang
[Optional, Default: true] If true, aborts the process if a hang is detected.
bool enabled
[Optional, Default: true] Enables/disables a watchdog.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * OID_RTS_PEM
Rally Tactical Systems' PEN as assigned by IANA.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * OID_RTS_CERT_SUBJ_ACCESS_TAGS
The link to the Rallypoint is down.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_EXCLUDED_SERIAL
The Rallypoint denied the registration request because the far-end's certificate serial number has be...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_SECURITY_CLASSIFICATION_LEVEL_TOO_HIGH
The Rallypoint has denied the registration because the registration is for a security level not allow...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_ON_BLACKLIST
The Rallypoint denied the registration request because the far-end does appears in blackist criteria.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_EXCLUDED_FINGERPRINT
The Rallypoint denied the registration request because the far-end's certificate fingerprint has been...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_ISSUER
The Rallypoint denied the registration request because the far-end's certificate does not have an an ...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_GENERAL_DENIAL
The Rallypoint has denied the registration for no specific reason.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_ACCESS_TAG
The Rallypoint denied the registration request because the far-end's certificate does not have an acc...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_SUBJECT
The Rallypoint denied the registration request because the far-end's certificate does not have an an ...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NOT_ALLOWED
The Rallypoint is not accepting registration for the group at this time.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_EXCLUDED_SUBJECT
The Rallypoint denied the registration request because the far-end's certificate subject has been exc...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_LINK
The link to the Rallypoint is down.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_SERIAL
The Rallypoint denied the registration request because the far-end's certificate does not have an an ...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_FINGERPRINT
The Rallypoint denied the registration request because the far-end's certificate does not have an an ...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_EXCLUDED_ISSUER
The Rallypoint denied the registration request because the far-end's certificate issuer has been excl...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_EXCLUDED_ACCESS_TAG
The Rallypoint denied the registration request because the far-end's certificate does not have an acc...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_UNREGISTERED
The group has been gracefully unregistered from the Rallypoint.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NO_REAON
No particular reason was provided.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_DISCONNECTED_REASON_NOT_ON_WHITELIST
The Rallypoint denied the registration request because the far-end does not appear in any whitelist c...
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_DOMO
The source is Domo Tactical via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_CISTECH
The source is CISTECH via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_CORE
The source is a Magellan-capable entity.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_INTERNAL
Internal to Engage.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_TAIT
The source is Tait via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_TRELLISWARE
The source is Trellisware via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_SILVUS
The source is Silvus via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_VOCALITY
The source is Vocality via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_PERSISTENT
The source is Persistent Systems via Magellan discovery.
static ENGAGE_IGNORE_COMPILER_UNUSED_WARNING const char * GROUP_SOURCE_ENGAGE_MAGELLAN_KENWOOD
The source is Kenwood via Magellan discovery.
static const uint8_t ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE
The default RTP payload type Engage uses for RTP blob messaging.