engage-engine 1.249.90890017 → 1.251.90910019

package/engage.cpp

@@ -1201,6 +1201,20 @@ NAN_METHOD(getRiffDescriptor)
 }
 
 
+//--------------------------------------------------------
+NAN_METHOD(beginGroupPcmPowerTracking)
+{
+    NANRETI(engageBeginGroupPcmPowerTracking(STRVAL(0)));
+}
+
+
+//--------------------------------------------------------
+NAN_METHOD(endGroupPcmPowerTracking)
+{
+    NANRETI(engageEndGroupPcmPowerTracking(STRVAL(0)));
+}
+
+
 //--------------------------------------------------------
 NAN_MODULE_INIT(Init)
 {
@@ -1279,7 +1293,10 @@ NAN_MODULE_INIT(Init)
     ENGAGE_BINDING(getDeviceId);
 
     ENGAGE_BINDING(verifyRiff);
-    ENGAGE_BINDING(getRiffDescriptor);    
+    ENGAGE_BINDING(getRiffDescriptor);
+
+    ENGAGE_BINDING(beginGroupPcmPowerTracking);
+    ENGAGE_BINDING(endGroupPcmPowerTracking);
 }
 
 NODE_MODULE(engage, Init)

package/include/ConfigurationObjects.h

@@ -449,6 +449,52 @@ namespace AppConfigurationObjects
         }
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(KvPair)
+    /**
+    * @brief Holds a key/value pair
+    *
+    * Helper C++ class to serialize and de-serialize KvPair JSON
+    *
+    */
+    class KvPair : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(KvPair)
+
+    public:
+        /** @brief Key */
+        std::string                     key;
+
+        /** @brief Value */
+        std::string                     value;
+        
+        KvPair()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            key.clear();
+            value.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const KvPair& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(key),
+            TOJSON_IMPL(value)
+        };
+    }
+    static void from_json(const nlohmann::json& j, KvPair& p)
+    {
+        p.clear();
+        getOptional<std::string>("key", p.key, j, EMPTY_STRING);
+        getOptional<std::string>("tags", p.value, j, EMPTY_STRING);
+    }    
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(TuningSettings)
     class TuningSettings : public ConfigurationObjectBase
@@ -2781,9 +2827,9 @@ namespace AppConfigurationObjects
             certificateKey.clear();
             caCertificates.clear();
             verifyPeer = false;
-            transactionTimeoutMs = 5000;
+            transactionTimeoutMs = 0;
             disableMessageSigning = false;
-            connectionTimeoutSecs = 5;
+            connectionTimeoutSecs = 0;
             tcpTxOptions.clear();
         }
 
@@ -2877,9 +2923,9 @@ namespace AppConfigurationObjects
         getOptional<bool>("verifyPeer", p.verifyPeer, j, true);
         getOptional<bool>("allowSelfSignedCertificate", p.allowSelfSignedCertificate, j, false);
         getOptional<std::vector<std::string>>("caCertificates", p.caCertificates, j);
-        getOptional<int>("transactionTimeoutMs", p.transactionTimeoutMs, j, 5000);
+        getOptional<int>("transactionTimeoutMs", p.transactionTimeoutMs, j, 0);
         getOptional<bool>("disableMessageSigning", p.disableMessageSigning, j, false);
-        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5);
+        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
         getOptional<TcpNetworkTxOptions>("tcpTxOptions", p.tcpTxOptions, j);
     }
 
@@ -2927,6 +2973,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 0] Default connection timeout in seconds to any RP in the cluster */
         int                                 connectionTimeoutSecs;
 
+        /** @brief [Optional, Default: 0] Default transaction time in milliseconds to any RP in the cluster */
+        int                                 transactionTimeoutMs;
+
         RallypointCluster()
         {
             clear();
@@ -2937,7 +2986,8 @@ namespace AppConfigurationObjects
             connectionStrategy = csRoundRobin;
             rallypoints.clear();
             rolloverSecs = 10;
-            connectionTimeoutSecs = 5;
+            connectionTimeoutSecs = 0;
+            transactionTimeoutMs = 0;
         }
     };
 
@@ -2947,7 +2997,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(connectionStrategy),
             TOJSON_IMPL(rallypoints),
             TOJSON_IMPL(rolloverSecs),
-            TOJSON_IMPL(connectionTimeoutSecs)
+            TOJSON_IMPL(connectionTimeoutSecs),
+            TOJSON_IMPL(transactionTimeoutMs)            
         };
     }
     static void from_json(const nlohmann::json& j, RallypointCluster& p)
@@ -2956,7 +3007,8 @@ namespace AppConfigurationObjects
         getOptional<RallypointCluster::ConnectionStrategy_t>("connectionStrategy", p.connectionStrategy, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
         getOptional<std::vector<Rallypoint>>("rallypoints", p.rallypoints, j);
         getOptional<int>("rolloverSecs", p.rolloverSecs, j, 10);
-        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5);
+        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
+        getOptional<int>("transactionTimeoutMs", p.connectionTimeoutSecs, j, 0);        
     }
 
 
@@ -6850,6 +6902,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 5] Connection timeout in seconds to RP */
         int                                     rpConnectionTimeoutSecs;
 
+        /** @brief [Optional, Default: 5] Transaction timeout with RP */
+        int                                     rpTransactionTimeoutMs;        
+
         /** @brief [Optional, Default: 10] The number of seconds after which "sticky" transmission IDs expire. */
         int                                     stickyTidHangSecs;
 
@@ -6875,7 +6930,8 @@ namespace AppConfigurationObjects
             rpClusterStrategy = RallypointCluster::ConnectionStrategy_t::csRoundRobin;
             rpClusterRolloverSecs = 10;
             rtpExpirationCheckIntervalMs = 250;
-            rpConnectionTimeoutSecs = 5;
+            rpConnectionTimeoutSecs = 0;
+            rpTransactionTimeoutMs = 0;
             stickyTidHangSecs = 10;
             uriStreamingIntervalMs = 60;
             delayedMicrophoneClosureSecs = 15;
@@ -6896,6 +6952,7 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(rpClusterRolloverSecs),
             TOJSON_IMPL(rtpExpirationCheckIntervalMs),
             TOJSON_IMPL(rpConnectionTimeoutSecs),
+            TOJSON_IMPL(rpTransactionTimeoutMs),            
             TOJSON_IMPL(stickyTidHangSecs),
             TOJSON_IMPL(uriStreamingIntervalMs),
             TOJSON_IMPL(delayedMicrophoneClosureSecs),
@@ -6914,7 +6971,8 @@ namespace AppConfigurationObjects
         getOptional<RallypointCluster::ConnectionStrategy_t>("rpClusterStrategy", p.rpClusterStrategy, j, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
         getOptional<int>("rpClusterRolloverSecs", p.rpClusterRolloverSecs, j, 10);
         getOptional<int>("rtpExpirationCheckIntervalMs", p.rtpExpirationCheckIntervalMs, j, 250);
-        getOptional<int>("rpConnectionTimeoutSecs", p.rpConnectionTimeoutSecs, j, 5);
+        getOptional<int>("rpConnectionTimeoutSecs", p.rpConnectionTimeoutSecs, j, 0);
+        getOptional<int>("rpTransactionTimeoutMs", p.rpTransactionTimeoutMs, j, 0);
         getOptional<int>("stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
         getOptional<int>("uriStreamingIntervalMs", p.uriStreamingIntervalMs, j, 60);
         getOptional<int>("delayedMicrophoneClosureSecs", p.delayedMicrophoneClosureSecs, j, 15);      
@@ -7565,6 +7623,18 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(RallypointPeer)
 
     public:
+        typedef enum
+        {
+            /** @brief Use the RP's configuration */
+            olpUseRpConfiguration      = 0,
+
+            /** @brief Mark as a domain leaf */
+            olpIsMeshLeaf   = 1,
+
+            /** @brief Do not mark as a domain leaf */
+            olpNotMeshLeaf   = 2
+        } OutboundLeafPolicy_t;
+
         /** @brief Internal ID. */
         std::string             id;
 
@@ -7583,6 +7653,8 @@ namespace AppConfigurationObjects
         /** @brief Internal enablement setting. */
         bool                    forceIsMeshLeaf;
 
+        OutboundLeafPolicy_t    outboundLeafPolicy;
+
         RallypointPeer()
         {
             clear();
@@ -7596,6 +7668,7 @@ namespace AppConfigurationObjects
             certificate.clear();
             connectionTimeoutSecs = 0;
             forceIsMeshLeaf = false;
+            outboundLeafPolicy = OutboundLeafPolicy_t::olpUseRpConfiguration;
         }
     };
 
@@ -7607,7 +7680,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(host),
             TOJSON_IMPL(certificate),
             TOJSON_IMPL(connectionTimeoutSecs),
-            TOJSON_IMPL(forceIsMeshLeaf)
+            TOJSON_IMPL(forceIsMeshLeaf),
+            TOJSON_IMPL(outboundLeafPolicy)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointPeer& p)
@@ -7619,6 +7693,7 @@ namespace AppConfigurationObjects
         getOptional<SecurityCertificate>("certificate", p.certificate, j);
         getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
         getOptional<bool>("forceIsMeshLeaf", p.forceIsMeshLeaf, j, false);
+        getOptional<RallypointPeer::OutboundLeafPolicy_t>("outboundLeafPolicy", p.outboundLeafPolicy, j, RallypointPeer::OutboundLeafPolicy_t::olpUseRpConfiguration);
     }
 
     //-----------------------------------------------------------
@@ -8031,10 +8106,10 @@ namespace AppConfigurationObjects
 
     public:
 
-        /** @brief An identifier useful for organizations that track different mesh configurations by ID */
+        /** @brief An identifier useful for organizations that track different domain configurations by ID */
         std::string                     id;
 
-        /** @brief TODO: A version number for the mesh configuration.  Change this whenever you update your configuration */
+        /** @brief TODO: A version number for the domain configuration.  Change this whenever you update your configuration */
         int                             version;
 
         /** @brief Comments */
@@ -8459,6 +8534,9 @@ namespace AppConfigurationObjects
         /** @brief Certificate to be used for WebSockets */
         SecurityCertificate                     certificate;
 
+        /** @brief [Default: false] Indicates whether the client is required to present a certificate */
+        bool                                    requireClientCertificate;
+
         RallypointWebsocketSettings()
         {
             clear();
@@ -8469,6 +8547,7 @@ namespace AppConfigurationObjects
             enabled = false;
             listenPort = 8443;
             certificate.clear();
+            requireClientCertificate = false;
         }
     };
 
@@ -8477,7 +8556,8 @@ namespace AppConfigurationObjects
         j = nlohmann::json{
             TOJSON_IMPL(enabled),
             TOJSON_IMPL(listenPort),
-            TOJSON_IMPL(certificate)
+            TOJSON_IMPL(certificate),
+            TOJSON_IMPL(requireClientCertificate)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointWebsocketSettings& p)
@@ -8486,6 +8566,7 @@ namespace AppConfigurationObjects
         getOptional<bool>("enabled", p.enabled, j, false);
         getOptional<int>("listenPort", p.listenPort, j, 8443);
         getOptional<SecurityCertificate>("certificate", p.certificate, j);
+        getOptional<bool>("requireClientCertificate", p.requireClientCertificate, j, false);
     }
 
 
@@ -8694,7 +8775,7 @@ namespace AppConfigurationObjects
         /** @brief Internal - not serialized. */
         PeeringConfiguration                        peeringConfiguration;       // NOTE: This is NOT serialized
 
-        /** @brief Indicates whether this Rallypoint is part of a core mesh or hangs off the periphery as a leaf node. */
+        /** @brief Indicates whether this Rallypoint is part of a core domain or hangs off the periphery as a leaf node. */
         bool                                        isMeshLeaf;
 
         /** @brief Set to true to forgo DSA signing of messages.  Doing so is is a security risk but can be useful on CPU-constrained systems on already-secure environments. */
@@ -8748,7 +8829,7 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default 0] Sets the queue's normal task bias */
         uint32_t                                    normalTaskQueueBias;
 
-        /** @brief If enabled, causes a mesh leaf to reverse-subscribe to a core node upon the core subscribing and a reflector having been setup */
+        /** @brief If enabled, causes a domain leaf to reverse-subscribe to a core node upon the core subscribing and a reflector having been setup */
         bool                                        enableLeafReflectionReverseSubscription;
 
         /** @brief If true, turns off loop detection. */
@@ -8784,11 +8865,17 @@ namespace AppConfigurationObjects
         /** @brief Details for capture of transmitted packets  */
         PacketCapturer                          txCapture;
 
-        /** @brief [Optional] This Rallypoint's mesh name */
-        std::string                             meshName;
+        /** @brief [Optional] This Rallypoint's domain name */
+        std::string                             domainName;
+
+        /** @brief [Optional] List of domains that explicitly MAY connect to this RP */
+        std::vector<std::string>                allowedDomains;
+
+        /** @brief [Optional] List of domains that explictly MAY NOT connect to this RP */
+        std::vector<std::string>                blockedDomains;
 
-        /** @brief [Optional] List of additional meshes that can be reached via this RP */
-        std::vector<std::string>                extraMeshes;
+        /** @brief [Optional] List of additional domains that can be reached via this RP */
+        std::vector<std::string>                extraDomains;
 
         /** @brief [Optional] Low-level tuning */
         TuningSettings                          tuning; 
@@ -8850,11 +8937,13 @@ namespace AppConfigurationObjects
             advertising.clear();
             extendedGroupRestrictions.clear();
             groupRestrictionAccessPolicyType = GroupRestrictionAccessPolicyType_t::graptPermissive;
-            ipFamily = IpFamilyType_t::ifIpUnspec;
+            ipFamily = IpFamilyType_t::ifIp4;
             rxCapture.clear();
             txCapture.clear();
-            meshName.clear();
-            extraMeshes.clear();
+            domainName.clear();
+            allowedDomains.clear();
+            blockedDomains.clear();
+            extraDomains.clear();
             tuning.clear();
         }
     };
@@ -8915,8 +9004,10 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(ipFamily),
             TOJSON_IMPL(rxCapture),
             TOJSON_IMPL(txCapture),
-            TOJSON_IMPL(meshName),
-            TOJSON_IMPL(extraMeshes),
+            TOJSON_IMPL(domainName),
+            TOJSON_IMPL(allowedDomains),
+            TOJSON_IMPL(blockedDomains),
+            TOJSON_IMPL(extraDomains),
             TOJSON_IMPL(tuning)
         };
     }
@@ -8973,11 +9064,13 @@ namespace AppConfigurationObjects
         getOptional<RallypointAdvertisingSettings>("advertising", p.advertising, j);
         getOptional<std::vector<RallypointExtendedGroupRestriction>>("extendedGroupRestrictions", p.extendedGroupRestrictions, j);        
         getOptional<GroupRestrictionAccessPolicyType_t>("groupRestrictionAccessPolicyType", p.groupRestrictionAccessPolicyType, j, GroupRestrictionAccessPolicyType_t::graptPermissive);
-        getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIpUnspec);
+        getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIp4);
         getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
         getOptional<PacketCapturer>("txCapture", p.txCapture, j);
-        getOptional<std::string>("meshName", p.meshName, j);
-        getOptional<std::vector<std::string>>("extraMeshes", p.extraMeshes, j);
+        getOptional<std::string>("domainName", p.domainName, j);
+        getOptional<std::vector<std::string>>("allowedDomains", p.allowedDomains, j);
+        getOptional<std::vector<std::string>>("blockedDomains", p.blockedDomains, j);
+        getOptional<std::vector<std::string>>("extraDomains", p.extraDomains, j);
         getOptional<TuningSettings>("tuning", p.tuning, j);
     }
 
@@ -9265,6 +9358,9 @@ namespace AppConfigurationObjects
         /** @brief Array of certificates in this store */
         std::vector<CertStoreCertificate>    certificates;
 
+        /** @brief [Optional] Array of KV pairs */
+        std::vector<KvPair>                  kvp;
+
         CertStore()
         {
             clear();
@@ -9274,6 +9370,7 @@ namespace AppConfigurationObjects
         {
             id.clear();
             certificates.clear();
+            kvp.clear();
         }
     };
 
@@ -9281,7 +9378,8 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(id),
-            TOJSON_IMPL(certificates)
+            TOJSON_IMPL(certificates),
+            TOJSON_IMPL(kvp)
         };
     }
     static void from_json(const nlohmann::json& j, CertStore& p)
@@ -9289,6 +9387,7 @@ namespace AppConfigurationObjects
         p.clear();
         getOptional<std::string>("id", p.id, j, EMPTY_STRING);
         getOptional<std::vector<CertStoreCertificate>>("certificates", p.certificates, j);
+        getOptional<std::vector<KvPair>>("kvp", p.kvp, j);
     }
 
     //-----------------------------------------------------------
@@ -9381,6 +9480,9 @@ namespace AppConfigurationObjects
         /** @brief Array of certificate elements. */
         std::vector<CertStoreCertificateElement>        certificates;
 
+        /** @brief Array of kv pairs. */
+        std::vector<KvPair>                             kvp;
+
         CertStoreDescriptor()
         {
             clear();
@@ -9393,6 +9495,7 @@ namespace AppConfigurationObjects
             version = 0;
             flags = 0;
             certificates.clear();
+            kvp.clear();
         }
     };
 
@@ -9403,7 +9506,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(fileName),
             TOJSON_IMPL(version),
             TOJSON_IMPL(flags),
-            TOJSON_IMPL(certificates)
+            TOJSON_IMPL(certificates),
+            TOJSON_IMPL(kvp)
         };
     }
     static void from_json(const nlohmann::json& j, CertStoreDescriptor& p)
@@ -9414,6 +9518,7 @@ namespace AppConfigurationObjects
         getOptional<int>("version", p.version, j, 0);
         getOptional<int>("flags", p.flags, j, 0);
         getOptional<std::vector<CertStoreCertificateElement>>("certificates", p.certificates, j);
+        getOptional<std::vector<KvPair>>("kvp", p.kvp, j);
     }
 
     //-----------------------------------------------------------
@@ -11870,6 +11975,352 @@ namespace AppConfigurationObjects
         getOptional<int>("maxPriority", p.maxPriority, j, 255);
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngateGroup)
+    /**
+    * @brief Engate configuration
+    *
+    * Helper C++ class to serialize and de-serialize EngateGroup JSON
+    *
+    * Example: @include[doc] examples/EngateGroup.json
+    *
+    * @see TODO: ConfigurationObjects::EngateGroupsConfiguration
+    */
+    class EngateGroup : public Group
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngateGroup)
+
+    public:
+        bool                        useVad;
+        uint32_t                    inputHangMs;
+        uint32_t                    inputActivationPowerThreshold;
+        uint32_t                    inputDeactivationPowerThreshold;
+
+        EngateGroup()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            Group::clear();
+            useVad = false;
+            inputHangMs = 750;
+            inputActivationPowerThreshold = 700;
+            inputDeactivationPowerThreshold = 125;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngateGroup& p)
+    {
+        nlohmann::json g;
+        to_json(g, static_cast<const Group&>(p));
+
+        j = nlohmann::json{
+            TOJSON_IMPL(useVad),
+            TOJSON_IMPL(inputHangMs),
+            TOJSON_IMPL(inputActivationPowerThreshold),
+            TOJSON_IMPL(inputDeactivationPowerThreshold)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngateGroup& p)
+    {
+        p.clear();
+        from_json(j, static_cast<Group&>(p));
+        getOptional<uint32_t>("inputHangMs", p.inputHangMs, j, 750);
+        getOptional<uint32_t>("inputActivationPowerThreshold", p.inputActivationPowerThreshold, j, 700);
+        getOptional<uint32_t>("inputDeactivationPowerThreshold", p.inputDeactivationPowerThreshold, j, 125);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngateGroupsConfiguration)
+    /**
+    * @brief Engate configuration
+    *
+    * Helper C++ class to serialize and de-serialize EngateGroupsConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngateGroupsConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::EngateGroupsConfiguration
+    */
+    class EngateGroupsConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngateGroupsConfiguration)
+
+    public:
+        /** @brief Array of groups in the configuration */
+        std::vector<EngateGroup>          groups;
+
+        EngateGroupsConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            groups.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngateGroupsConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(groups)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngateGroupsConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::vector<EngateGroup>>("groups", p.groups, j);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngateServerStatusReportConfiguration)
+    /**
+    * @brief TODO: Configuration for the engate server status report file
+    *
+    * Helper C++ class to serialize and de-serialize EngateServerStatusReportConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngateServerStatusReportConfiguration.json
+    *
+    * @see RallypointServer
+    */
+    class EngateServerStatusReportConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngateServerStatusReportConfiguration)
+
+    public:
+        /** File name to use for the status report. */
+        std::string                     fileName;
+
+        /** [Optional, Default: 30] The interval at which to write out the status report to file. */
+        int                             intervalSecs;
+
+        /** [Optional, Default: false] Indicates if status reporting is enabled. */
+        bool                            enabled;
+
+        /** [Optional, Default: null] Command to be executed every time the status report is produced. */
+        std::string                     runCmd;
+
+        /** [Optional, Default: false] Indicates whether to include details of each group. */
+        bool                            includeGroupDetail;
+
+        EngateServerStatusReportConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            fileName.clear();
+            intervalSecs = 60;
+            enabled = false;
+            includeGroupDetail = false;
+            runCmd.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngateServerStatusReportConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(fileName),
+            TOJSON_IMPL(intervalSecs),
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(includeGroupDetail),
+            TOJSON_IMPL(runCmd)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngateServerStatusReportConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("fileName", p.fileName, j);
+        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
+        getOptional<bool>("enabled", p.enabled, j, false);
+        getOptional<std::string>("runCmd", p.runCmd, j);
+        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngateServerInternals)
+    /**
+    * @brief Internal engate server settings
+    *
+    * These settings are used to configure internal parameters.
+    *
+    * Helper C++ class to serialize and de-serialize EngateServerInternals JSON
+    *
+    * Example: @include[doc] examples/EngateServerInternals.json
+    *
+    * @see engageInitialize, ConfigurationObjects::EngateServerConfiguration
+    */
+    class EngateServerInternals : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngateServerInternals)
+
+    public:
+        /** @brief [Optional] Settings for the EAR's watchdog. */
+        WatchdogSettings    watchdog;
+
+        /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
+        int                 housekeeperIntervalMs;
+
+        /** @brief [Optional] Low-level tuning */
+        TuningSettings      tuning; 
+
+        EngateServerInternals()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            watchdog.clear();
+            tuning.clear();
+            housekeeperIntervalMs = 1000;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngateServerInternals& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(watchdog),
+            TOJSON_IMPL(housekeeperIntervalMs),
+            TOJSON_IMPL(tuning)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngateServerInternals& p)
+    {
+        p.clear();
+        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
+        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+        getOptional<TuningSettings>("tuning", p.tuning, j);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngateServerConfiguration)
+    /**
+    * @brief Configuration for the engate server
+    *
+    * Helper C++ class to serialize and de-serialize EngateServerConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngateServerConfiguration.json
+    *
+    */
+    class EngateServerConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngateServerConfiguration)
+
+    public:
+
+        /** @brief A unqiue identifier for the EAR server */
+        std::string                                 id;
+
+        /** @brief Number of seconds between checks to see if the service configuration has been updated.  Default is 60.*/
+        int                                         serviceConfigurationFileCheckSecs;
+        
+        /** @brief Name of a file containing the ear configuration. */
+        std::string                                 groupsConfigurationFileName;
+
+        /** @brief Command-line to execute that returns a configuration */
+        std::string                                 groupsConfigurationFileCommand;
+
+        /** @brief Number of seconds between checks to see if the configuration has been updated.  Default is 60.*/
+        int                                         groupsConfigurationFileCheckSecs;
+
+        /** @brief Details for producing a status report. @see EngateServerStatusReportConfiguration */
+        EngateServerStatusReportConfiguration          statusReport;
+
+        /** @brief Details concerning the server's interaction with an external health-checker such as a load-balancer.  @see ExternalHealthCheckResponder */
+        ExternalHealthCheckResponder                 externalHealthCheckResponder;
+
+        /** @brief Internal settings */
+        EngateServerInternals                           internals;
+
+        /** @brief Path to the certificate store */
+        std::string                                  certStoreFileName;
+
+        /** @brief Hex password for the certificate store (if any) */
+        std::string                                  certStorePasswordHex;
+
+        /** @brief The policy to be used for the underlying Engage Engine */
+        EnginePolicy                                 enginePolicy;
+
+        /** @brief Name to use for signalling a configuration check */
+        std::string                                 configurationCheckSignalName;
+
+        /** @brief [Optional] Settings for the FIPS crypto. */
+        FipsCryptoSettings                          fipsCrypto;
+
+        /** @brief [Optional] Settings for NSM. */
+        NsmConfiguration                            nsm;
+
+        EngateServerConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            serviceConfigurationFileCheckSecs = 60;
+            groupsConfigurationFileName.clear();
+            groupsConfigurationFileCommand.clear();
+            groupsConfigurationFileCheckSecs = 60;
+            statusReport.clear();
+            externalHealthCheckResponder.clear();
+            internals.clear();
+            certStoreFileName.clear();
+            certStorePasswordHex.clear();
+            enginePolicy.clear();
+            configurationCheckSignalName = "rts.9a164fa.${id}";
+            fipsCrypto.clear();
+            nsm.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngateServerConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
+            TOJSON_IMPL(groupsConfigurationFileName),
+            TOJSON_IMPL(groupsConfigurationFileCommand),
+            TOJSON_IMPL(groupsConfigurationFileCheckSecs),
+            TOJSON_IMPL(statusReport),
+            TOJSON_IMPL(externalHealthCheckResponder),
+            TOJSON_IMPL(internals),
+            TOJSON_IMPL(certStoreFileName),
+            TOJSON_IMPL(certStorePasswordHex),
+            TOJSON_IMPL(enginePolicy),
+            TOJSON_IMPL(configurationCheckSignalName),
+            TOJSON_IMPL(fipsCrypto),
+            TOJSON_IMPL(nsm)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngateServerConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("id", p.id, j);
+        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
+        getOptional<std::string>("groupsConfigurationFileName", p.groupsConfigurationFileName, j);
+        getOptional<std::string>("groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
+        getOptional<int>("groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
+        getOptional<EngateServerStatusReportConfiguration>("statusReport", p.statusReport, j);
+        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
+        getOptional<EngateServerInternals>("internals", p.internals, j);
+        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
+        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
+        j.at("enginePolicy").get_to(p.enginePolicy);
+        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
+        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
+        getOptional<NsmConfiguration>("nsm", p.nsm, j);
+    }    
+
     //-----------------------------------------------------------
     static inline void dumpExampleConfigurations(const char *path)
     {

package/include/EngageInterface.h

@@ -292,6 +292,12 @@ typedef struct _EngageEvents_t
 
     /** @brief Fired whenever the previously-registered high-resolution timer interval ticks.  'tickType' is 1, 2, or 3 for pre-tick, tick, and post-tick respectively */    
     // void (* _Nullable PFN_ENGAGE_ON_HIGH_RESOLUTION_TIMER_TICK)(uint32_t tickType, uint32_t ticksSoFarLow, uint32_t ticksSoFarHigh, const char * _Nullable eventExtraJson);
+
+    /** @brief Fired on a group-by-group pcm power report */    
+    void (* _Nullable PFN_ENGAGE_ENGINE_GROUP_BY_GROUP_PCM_POWER_LEVEL_REPORT)(const char * _Nullable eventExtraJson);    
+
+    /** @brief Fired on an audio device event */    
+    void (* _Nullable PFN_ENGAGE_ENGINE_AUDIO_DEVICE_EVENT)(const char * _Nullable eventExtraJson);    
 } EngageEvents_t;
 /** @} */
 
@@ -1781,6 +1787,22 @@ ENGAGE_API int engageRegisterForHighResolutionTimerNative(uint32_t durationMs, P
 ENGAGE_API int engageUnregisterFromHighResolutionTimerNative(void);
 #endif
 
+/**
+ * @brief [ASYNC] Begins tracking of input and output PCM power for the group
+ *
+ * @param id The ID of the group on which to start pcm power tracking
+ * @return ENGAGE_RESULT_OK if the submission request was successful
+ */
+ENGAGE_API int engageBeginGroupPcmPowerTracking(const char * _Nonnull id);
+
+/**
+ * @brief [ASYNC] End tracking of input and output PCM power for the group
+ *
+ * @param id The ID of the group on which to end pcm power tracking
+ * @return ENGAGE_RESULT_OK if the submission request was successful
+ */
+ENGAGE_API int engageEndGroupPcmPowerTracking(const char * _Nonnull id);
+
 #endif
 
 #ifdef __cplusplus

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engage-engine",
-  "version": "1.249.90890017",
+  "version": "1.251.90910019",
   "description": "Use Engage to communicate with everyone, everywhere, from any device",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"