engage-engine 1.249.90890017 → 1.250.90900018

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
@@ -8459,6 +8505,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 +8518,7 @@ namespace AppConfigurationObjects
             enabled = false;
             listenPort = 8443;
             certificate.clear();
+            requireClientCertificate = false;
         }
     };
 
@@ -8477,7 +8527,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 +8537,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);
     }
 
 
@@ -9265,6 +9317,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 +9329,7 @@ namespace AppConfigurationObjects
         {
             id.clear();
             certificates.clear();
+            kvp.clear();
         }
     };
 
@@ -9281,7 +9337,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 +9346,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 +9439,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 +9454,7 @@ namespace AppConfigurationObjects
             version = 0;
             flags = 0;
             certificates.clear();
+            kvp.clear();
         }
     };
 
@@ -9403,7 +9465,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 +9477,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 +11934,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.250.90900018",
   "description": "Use Engage to communicate with everyone, everywhere, from any device",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"