engage-engine 1.232.90720004 → 1.233.90730006

package/include/ConfigurationObjects.h

@@ -248,31 +248,45 @@ namespace AppConfigurationObjects
         \
         std::string serialize(const int indent = -1) \
         { \
-            nlohmann::json j; \
-            to_json(j, *this); \
-            return j.dump(indent); \
+            try \
+            { \
+                nlohmann::json j; \
+                to_json(j, *this); \
+                return j.dump(indent); \
+            } \
+            catch(...) \
+            { \
+                return std::string("{}"); \
+            } \
         }
 
     #define IMPLEMENT_WRAPPED_JSON_SERIALIZATION(_cn) \
         public: \
         std::string serializeWrapped(const int indent = -1) \
         { \
-            nlohmann::json j; \
-            to_json(j, *this); \
-            \
-            std::string rc; \
-            char firstChar[2]; \
-            firstChar[0] = #_cn[0]; \
-            firstChar[1] = 0; \
-            firstChar[0] = tolower(firstChar[0]); \
-            rc.assign("{\""); \
-            rc.append(firstChar); \
-            rc.append((#_cn) + 1); \
-            rc.append("\":"); \
-            rc.append(j.dump(indent)); \
-            rc.append("}"); \
-            \
-            return rc; \
+            try \
+            { \
+                nlohmann::json j; \
+                to_json(j, *this); \
+                \
+                std::string rc; \
+                char firstChar[2]; \
+                firstChar[0] = #_cn[0]; \
+                firstChar[1] = 0; \
+                firstChar[0] = tolower(firstChar[0]); \
+                rc.assign("{\""); \
+                rc.append(firstChar); \
+                rc.append((#_cn) + 1); \
+                rc.append("\":"); \
+                rc.append(j.dump(indent)); \
+                rc.append("}"); \
+                \
+                return rc; \
+            } \
+            catch(...) \
+            { \
+                return std::string("{}"); \
+            } \
         }
 
     #define TOJSON_IMPL(__var) \
@@ -4054,13 +4068,13 @@ namespace AppConfigurationObjects
         std::string             nodeId;
 
         /* NOTE: Not serialized ! */
-        uint8_t                 _internal_binary_nodeId[MAX_NODE_ID_SIZE];
+        uint8_t                 _internal_binary_nodeId[ENGAGE_MAX_NODE_ID_SIZE];
 
         /** @brief [Optional] An alias */
         std::string             alias;
         
         /* NOTE: Not serialized ! */
-        uint8_t                 _internal_binary_alias[MAX_ALIAS_SIZE];
+        uint8_t                 _internal_binary_alias[ENGAGE_MAX_ALIAS_SIZE];
 
         Source()
         {
@@ -7536,6 +7550,48 @@ namespace AppConfigurationObjects
         getOptional<std::string>("runCmd", p.runCmd, j);
     }
 
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(RallypointWebsocketSettings)
+    /**
+     * @brief Defines settings for Rallypoint websockets functionality
+     *
+     * Example: @include[doc] examples/RallypointWebsocketSettings.json
+     *
+     */
+    class RallypointWebsocketSettings : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(RallypointWebsocketSettings)
+
+    public:
+        /** @brief Listen port (TCP).  Default is 8443 */
+        int                                     listenPort;
+
+        RallypointWebsocketSettings()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            listenPort = 8443;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const RallypointWebsocketSettings& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(listenPort)
+        };
+    }
+    static void from_json(const nlohmann::json& j, RallypointWebsocketSettings& p)
+    {
+        p.clear();
+        getOptional<int>("listenPort", p.listenPort, j, 8443);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(RallypointServer)
     /**
@@ -7553,7 +7609,7 @@ namespace AppConfigurationObjects
 
     public:
         /** @brief [Optional] Settings for the FIPS crypto. */
-        FipsCryptoSettings                         fipsCrypto;
+        FipsCryptoSettings                          fipsCrypto;
     
         /** @brief [Optional] Settings for the Rallypoint's watchdog. */
         WatchdogSettings                            watchdog;
@@ -7687,6 +7743,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Array of behaviors for roundtrip times to peers */
         std::vector<RallypointRpRtTimingBehavior>   peerRtBehaviors;
 
+        /** @brief [Optional] Settings for websocket operation */
+        RallypointWebsocketSettings                 websocket;
+
         RallypointServer()
         {
             clear();
@@ -7739,6 +7798,7 @@ namespace AppConfigurationObjects
             maxOutboundPeerConnectionIntervalDeltaSecs = 15;
             peerRtTestIntervalMs = 60000;
             peerRtBehaviors.clear();
+            websocket.clear();
         }
     };
 
@@ -7789,7 +7849,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(routeMap),
             TOJSON_IMPL(maxOutboundPeerConnectionIntervalDeltaSecs),
             TOJSON_IMPL(peerRtTestIntervalMs),
-            TOJSON_IMPL(peerRtBehaviors)
+            TOJSON_IMPL(peerRtBehaviors),
+            TOJSON_IMPL(websocket)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointServer& p)
@@ -7840,6 +7901,7 @@ namespace AppConfigurationObjects
         getOptional<uint32_t>("maxOutboundPeerConnectionIntervalDeltaSecs", p.maxOutboundPeerConnectionIntervalDeltaSecs, j, 15);        
         getOptional<int>("peerRtTestIntervalMs", p.peerRtTestIntervalMs, j, 60000);
         getOptional<std::vector<RallypointRpRtTimingBehavior>>("peerRtBehaviors", p.peerRtBehaviors, j);
+        getOptional<RallypointWebsocketSettings>("websocket", p.websocket, j);
     }
 
     //-----------------------------------------------------------
@@ -9154,7 +9216,477 @@ namespace AppConfigurationObjects
         getOptional<uint64_t>("msToNextConnectionAttempt", p.msToNextConnectionAttempt, j, 0);
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(TranslationSession)
+    /**
+    * @brief Translation session settings
+    *
+    * Helper C++ class to serialize and de-serialize TranslationSession JSON
+    *
+    * Example: @include[doc] examples/TranslationSession.json
+    *
+    * @see TODO: ConfigurationObjects::TranslationSession
+    */
+    class TranslationSession : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TranslationSession)
+
+    public:
+        /** @brief ID */
+        std::string                 id;
+
+        /** @brief Name */
+        std::string                 name;
+
+        /** @brief List of group IDs to be included in the session */
+        std::vector<std::string>    groups;
+
+        /** @brief [Optional, Default: true] Enable the session */
+        bool                        enabled;
+
+        TranslationSession()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            name.clear();
+            groups.clear();
+            enabled = true;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const TranslationSession& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(name),
+            TOJSON_IMPL(groups),
+            TOJSON_IMPL(enabled)
+        };
+    }
+    static void from_json(const nlohmann::json& j, TranslationSession& p)
+    {
+        p.clear();
+        FROMJSON_IMPL(id, std::string, EMPTY_STRING);
+        FROMJSON_IMPL(name, std::string, EMPTY_STRING);
+        getOptional<std::vector<std::string>>("groups", p.groups, j);
+        FROMJSON_IMPL(enabled, bool, true);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(TranslationConfiguration)
+    /**
+    * @brief Translation configuration
+    *
+    * Helper C++ class to serialize and de-serialize TranslationConfiguration JSON
+    *
+    * Example: @include[doc] examples/TranslationConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::TranslationConfiguration
+    */
+    class TranslationConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TranslationConfiguration)
+
+    public:
+        /** @brief Array of sessions in the configuration */
+        std::vector<TranslationSession>         sessions;
+
+        /** @brief Array of groups in the configuration */
+        std::vector<Group>                      groups;
+
+        TranslationConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            sessions.clear();
+            groups.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const TranslationConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(sessions),
+            TOJSON_IMPL(groups)
+        };
+    }
+    static void from_json(const nlohmann::json& j, TranslationConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::vector<TranslationSession>>("sessions", p.sessions, j);
+        getOptional<std::vector<Group>>("groups", p.groups, j);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(LingoServerStatusReportConfiguration)
+    /**
+    * @brief TODO: Configuration for the translation server status report file
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerStatusReportConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoServerStatusReportConfiguration.json
+    *
+    * @see RallypointServer
+    */
+    class LingoServerStatusReportConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerStatusReportConfiguration)
+
+    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;
+
+        /** [Optional, Default: false] Indicates whether to include details of each session. */
+        bool                            includeSessionDetail;
+
+        /** [Optional, Default: false] Indicates whether to include details of each group in each session. */
+        bool                            includeSessionGroupDetail;
+
+        LingoServerStatusReportConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            fileName.clear();
+            intervalSecs = 60;
+            enabled = false;
+            includeGroupDetail = false;
+            includeSessionDetail = false;
+            includeSessionGroupDetail = false;
+            runCmd.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const LingoServerStatusReportConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(fileName),
+            TOJSON_IMPL(intervalSecs),
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(includeGroupDetail),
+            TOJSON_IMPL(includeSessionDetail),
+            TOJSON_IMPL(includeSessionGroupDetail),
+            TOJSON_IMPL(runCmd)
+        };
+    }
+    static void from_json(const nlohmann::json& j, LingoServerStatusReportConfiguration& 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);
+        getOptional<bool>("includeSessionDetail", p.includeSessionDetail, j, false);
+        getOptional<bool>("includeSessionGroupDetail", p.includeSessionGroupDetail, j, false);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(LingoServerInternals)
+    /**
+    * @brief Internal translator server settings
+    *
+    * These settings are used to configure internal parameters.
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerInternals JSON
+    *
+    * Example: @include[doc] examples/LingoServerInternals.json
+    *
+    * @see engageInitialize, ConfigurationObjects::LingoServerConfiguration
+    */
+    class LingoServerInternals : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerInternals)
+
+    public:
+        /** @brief [Optional] Settings for the watchdog. */
+        WatchdogSettings    watchdog;
+
+        /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
+        int                 housekeeperIntervalMs;
+
+        LingoServerInternals()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            watchdog.clear();
+            housekeeperIntervalMs = 1000;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const LingoServerInternals& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(watchdog),
+            TOJSON_IMPL(housekeeperIntervalMs)
+        };
+    }
+    static void from_json(const nlohmann::json& j, LingoServerInternals& p)
+    {
+        p.clear();
+        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
+        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(LingoServerConfiguration)
+    /**
+    * @brief Configuration for the linguistics server
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoServerConfiguration.json
+    *
+    */
+    class LingoServerConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerConfiguration)
+
+    public:
+        /** @brief A unqiue identifier for the linguistics 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 linguistics configuration. */
+        std::string                                 lingoConfigurationFileName;
+
+        /** @brief Command-line to execute that returns a linguistics configuration */
+        std::string                                 lingoConfigurationFileCommand;
+
+        /** @brief Number of seconds between checks to see if the linguistics configuration has been updated.  Default is 60.*/
+        int                                         lingoConfigurationFileCheckSecs;
+
+        /** @brief Details for producing a status report. @see LingoServerStatusReportConfiguration */
+        LingoServerStatusReportConfiguration        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 */
+        LingoServerInternals                        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 Address and port of the proxy */
+        NetworkAddress                              proxy;
+
+        LingoServerConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            serviceConfigurationFileCheckSecs = 60;
+            lingoConfigurationFileName.clear();
+            lingoConfigurationFileCommand.clear();
+            lingoConfigurationFileCheckSecs = 60;
+            statusReport.clear();
+            externalHealthCheckResponder.clear();
+            internals.clear();
+            certStoreFileName.clear();
+            certStorePasswordHex.clear();
+            enginePolicy.clear();
+            configurationCheckSignalName = "rts.6cc0651.${id}";
+            fipsCrypto.clear();
+            proxy.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const LingoServerConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
+            TOJSON_IMPL(lingoConfigurationFileName),
+            TOJSON_IMPL(lingoConfigurationFileCommand),
+            TOJSON_IMPL(lingoConfigurationFileCheckSecs),
+            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(proxy)
+        };
+    }
+    static void from_json(const nlohmann::json& j, LingoServerConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("id", p.id, j);
+        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
+        getOptional<std::string>("lingoConfigurationFileName", p.lingoConfigurationFileName, j);
+        getOptional<std::string>("lingoConfigurationFileCommand", p.lingoConfigurationFileCommand, j);
+        getOptional<int>("lingoConfigurationFileCheckSecs", p.lingoConfigurationFileCheckSecs, j, 60);
+        getOptional<LingoServerStatusReportConfiguration>("statusReport", p.statusReport, j);
+        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
+        getOptional<LingoServerInternals>("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.6cc0651.${id}");
+        getOptional<FipsCryptoSettings>("fipsCrypo", p.fipsCrypto, j);
+        getOptional<NetworkAddress>("proxy", p.proxy, j);
+    }
+
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(VoiceToVoiceSession)
+    /**
+    * @brief Voice to voice session settings
+    *
+    * Helper C++ class to serialize and de-serialize VoiceToVoiceSession JSON
+    *
+    * Example: @include[doc] examples/VoiceToVoiceSession.json
+    *
+    * @see TODO: ConfigurationObjects::VoiceToVoiceSession
+    */
+    class VoiceToVoiceSession : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(VoiceToVoiceSession)
+
+    public:
+        /** @brief ID */
+        std::string                 id;
+
+        /** @brief Name */
+        std::string                 name;
+
+        /** @brief List of group IDs to be included in the session */
+        std::vector<std::string>    groups;
+
+        /** @brief [Optional, Default: true] Enable the session */
+        bool                        enabled;
+
+        VoiceToVoiceSession()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            name.clear();
+            groups.clear();
+            enabled = true;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const VoiceToVoiceSession& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(name),
+            TOJSON_IMPL(groups),
+            TOJSON_IMPL(enabled)
+        };
+    }
+    static void from_json(const nlohmann::json& j, VoiceToVoiceSession& p)
+    {
+        p.clear();
+        FROMJSON_IMPL(id, std::string, EMPTY_STRING);
+        FROMJSON_IMPL(name, std::string, EMPTY_STRING);
+        getOptional<std::vector<std::string>>("groups", p.groups, j);
+        FROMJSON_IMPL(enabled, bool, true);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(LingoConfiguration)
+    /**
+    * @brief Lingo configuration
+    *
+    * Helper C++ class to serialize and de-serialize LingoConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::LingoConfiguration
+    */
+    class LingoConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoConfiguration)
+
+    public:
+        /** @brief Array of voiceToVoice sessions in the configuration */
+        std::vector<VoiceToVoiceSession>         voiceToVoiceSessions;
+
+        /** @brief Array of groups in the configuration */
+        std::vector<Group>                       groups;
 
+        LingoConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            voiceToVoiceSessions.clear();
+            groups.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const LingoConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(voiceToVoiceSessions),
+            TOJSON_IMPL(groups)
+        };
+    }
+    static void from_json(const nlohmann::json& j, LingoConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::vector<VoiceToVoiceSession>>("voiceToVoiceSessions", p.voiceToVoiceSessions, j);
+        getOptional<std::vector<Group>>("groups", p.groups, j);
+    }
+    
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(BridgingConfiguration)
     /**
@@ -9302,7 +9834,7 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(BridgingServerInternals)
 
     public:
-        /** @brief [Optional] Settings for the EAR's watchdog. */
+        /** @brief [Optional] Settings for the watchdog. */
         WatchdogSettings    watchdog;
 
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */

package/include/EngageAudioDevice.h

@@ -11,6 +11,8 @@
 #ifndef EngageAudioDevice_h
 #define EngageAudioDevice_h
 
+#include <stdint.h>
+
 
 #ifdef __cplusplus
 extern "C"

package/include/EngageConstants.h

@@ -8,6 +8,69 @@
 
 #include <stdint.h>
 
+#if 1
+#include <cstddef>
+#include <cstdint>
+
+#ifdef WIN32
+    #include <winsock2.h>
+	#include <windows.h>
+    #include <ws2tcpip.h>
+#else
+    #include <netinet/in.h>
+#endif
+
+static const int ENGAGE_INVALID_IP_ADDRESS_FAMILY = -1;
+
+static const size_t ENGAGE_MAX_RTP_OUTPUT_QUEUE_PACKETS = 100;
+
+static const size_t ENGAGE_MAX_IP_ADDR_SIZE = sizeof(struct sockaddr_in6);
+static const size_t ENGAGE_MAX_ALIAS_SIZE = 16;
+static const size_t ENGAGE_MAX_NODE_ID_SIZE = 16;
+
+static const size_t ENGAGE_BLOB_PACKET_BUFFER_ALLOCATION_EXTRA_BYTES = 512;
+
+static const int16_t ENGAGE_PCM_MIN_VALUE = -32768;
+static const int16_t ENGAGE_PCM_MAX_VALUE = 32767;
+
+static const uint16_t ENGAGE_SELECT_FUNCTION_TIMEOUT_SECS = 1;
+static const uint16_t ENGAGE_MULTICAST_REJOIN_SECS = 8;
+
+static const size_t ENGAGE_MAX_DATAGRAM_SIZE = 4096;
+static const long ENGAGE_MAX_RECONNECT_PAUSE_MS = 30000;
+static const long ENGAGE_RECONNECT_FAILURE_PAUSE_INCREMENT_MS = 1500;
+
+static const size_t ENGAGE_BASE_RTP_HEADER_SIZE = 12;
+static const uint16_t ENGAGE_ACCEPTED_RTP_VERSION = 2;
+static const size_t ENGAGE_MAX_RTP_SAMPLES_THAT_CAN_BE_DECODED = (8000 * 5);
+
+static const size_t ENGAGE_PCM_SAMPLE_COUNT_PER_MS = 8;
+static const size_t ENGAGE_PCM_10_MS_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 10);
+
+#if defined(__APPLE__)
+    static const size_t ENGAGE_PCM_MIN_PLATFORM_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 40);
+#elif defined(__ANDROID__)
+    static const size_t ENGAGE_PCM_MIN_PLATFORM_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 250);
+#elif defined(__linux__)
+    static const size_t ENGAGE_PCM_MIN_PLATFORM_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 250);
+#elif defined(WIN32)
+	static const size_t ENGAGE_PCM_MIN_PLATFORM_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 250);
+#elif defined(__EMSCRIPTEN__)
+	static const size_t ENGAGE_PCM_MIN_PLATFORM_SAMPLE_COUNT = (ENGAGE_PCM_SAMPLE_COUNT_PER_MS * 250);
+#endif
+
+static const long ENGAGE_TLS_CONNECTION_KEY_MATERIAL_SIZE = 32;
+static const uint64_t ENGAGE_RTP_RESET_AFTER_IDLE_MS = (1000 * 30);
+
+#if defined(RTS_DEBUG_BUILD)
+static const uint64_t ENGAGE_GROUP_HEALTH_ERROR_ERROR_NOTIFICATION_INTERVAL_MS = (1000 * 10);
+#else
+static const uint64_t ENGAGE_GROUP_HEALTH_ERROR_ERROR_NOTIFICATION_INTERVAL_MS = (1000 * 30);
+#endif
+
+static const size_t ENGAGE_MAX_GROUPS_PER_BRIDGE = 128;
+#endif
+
 /** @addtogroup resultCodes Engage Engine Result Codes
  *
  * Result codes are returned by calls to the API functions and most often are related to
@@ -37,6 +100,8 @@ static const int ENGAGE_RESULT_ALREADY_STARTED = -6;
 static const int ENGAGE_RESULT_INSUFFICIENT_DESTINATION_SPACE = -7;
 /** @brief Initialization of the crypto module failed */
 static const int ENGAGE_RESULT_CRYPTO_MODULE_INITIALIZATION_FAILED = -8;
+/** @brief An application high resolution timer is already defined */
+static const int ENGAGE_RESULT_HIGH_RES_TIMER_ALREADY_EXISTS = -9;
 /** @} */
 
 

package/include/EngageInterface.h

@@ -13,6 +13,11 @@
 #define EngageInterface_h
 
 #include <stdint.h>
+
+#if defined(__EMSCRIPTEN__)
+    #include <emscripten.h>
+#endif
+
 #include "EngageConstants.h"
 
 #ifdef __cplusplus
@@ -20,6 +25,10 @@ extern "C"
 {
 #endif
 
+#if defined(ENGAGE_ALLOW_NATIVE)
+#include "ILogger.h"
+#endif
+
 #if !defined(ENGAGE_API)
     #if defined(WIN32)
         #ifdef ENGAGE_EXPORTS
@@ -29,7 +38,11 @@ extern "C"
             #define ENGAGE_API  extern
         #endif
     #else
-        #define ENGAGE_API  __attribute__ ((visibility ("default")))
+        #if defined(__EMSCRIPTEN__)
+            #define ENGAGE_API  EMSCRIPTEN_KEEPALIVE __attribute__ ((visibility ("default")))
+        #else
+            #define ENGAGE_API  __attribute__ ((visibility ("default")))
+        #endif
     #endif
 #endif
 
@@ -41,6 +54,9 @@ extern "C"
 /** @brief Prototype for logging callbacks */
 typedef void (*PFN_ENGAGE_LOG_HOOK)(int level, const char * _Nonnull tag, const char * _Nonnull message);
 
+/** @brief Prototype for the high-resolution timer callback */
+typedef void (*PFN_ENGAGE_HIGH_RES_TIMER_TICK)(uint32_t tickType, uint64_t ticksSoFar);
+
 // Structures (all packed on 1-byte boundaries)
 #pragma pack(push, 1)
 
@@ -273,6 +289,9 @@ typedef struct _EngageEvents_t
 
     /** @brief Fired when an audio recording has ended */    
     void (* _Nullable PFN_ENGAGE_AUDIO_RECORDING_ENDED)(const char * _Nonnull pId, const char * _Nullable eventExtraJson);    
+
+    /** @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);
 } EngageEvents_t;
 /** @} */
 
@@ -1635,6 +1654,46 @@ ENGAGE_API int engageCompress(const uint8_t * _Nonnull src, size_t srcSize, uint
 ENGAGE_API int engageDecompress(const uint8_t * _Nonnull src, size_t srcSize, uint8_t * _Nonnull dst, size_t maxDstSize);
 #endif
 
+
+#if defined(ENGAGE_ALLOW_NATIVE)
+/**
+ * @brief [SYNC] Returns a pointer to the library's internbal logger as an ILogger interface
+ *
+ * No events are generated by this API call.
+ *
+ * @return ILogger*
+ */
+ENGAGE_API ILogger * _Nullable engageGetLoggerNative();
+
+/**
+ * @brief [SYNC] Registers for a high resolution (millisecond-precision) timer via direct native callback
+ *
+ * Creates an ongoing timer at millisecond resolution.  Only a single high resolution
+ * timer can exist at any one time.
+ *
+ * No events are generated by this API call.
+ *
+ * @param durationMs Milliseconds between intervals
+ * @param pfnDirectCallback Pointer to the application callback function
+ * @return ENGAGE_RESULT_OK on success, other values on failure
+ * @see engageUnregisterFromHighResolutionTimerNative()
+ */
+ENGAGE_API int engageRegisterForHighResolutionTimerNative(uint32_t durationMs, PFN_ENGAGE_HIGH_RES_TIMER_TICK _Nullable pfnDirectCallback);
+
+
+/**
+ * @brief [SYNC] Unregisters the previously-registered native high-resolution timer if any.
+ *
+ * Unregisters the previously registered timer.  If none exists no error occurs.
+ *
+ * No events are generated by this API call.
+ *
+ * @return ENGAGE_RESULT_OK on success, other values on failure
+ * @see engageRegisterForHighResolutionTimerNative()
+ */
+ENGAGE_API int engageUnregisterFromHighResolutionTimerNative(void);
+#endif
+
 #endif
 
 #ifdef __cplusplus

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engage-engine",
-  "version": "1.232.90720004",
+  "version": "1.233.90730006",
   "description": "Use Engage to communicate with everyone, everywhere, from any device",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -23,6 +23,6 @@
   "dependencies": {
     "bindings": "^1.5.0",
     "nan": "^2.14.0",
-    "node-gyp": "^7.1.2"
+    "node-gyp": "^9.0.3"
   }
 }