engage.cpp

//
//  Copyright (c) 2019 Rally Tactical Systems, Inc.
//  All rights reserved.
//
 
#include <nan.h>
#include <node_buffer.h>
#include <string>
#include <iostream>
#include <thread>
#include <map>
#include <mutex>
#include <atomic>
 
#include "EngageInterface.h"
#include "EngagePlatformNotifications.h"
 
using namespace std;
using namespace Nan;
using namespace v8;
 
// Makes a binding
#define ENGAGE_BINDING(_nm) \
    Nan::Set(target, \
        New<String>(#_nm).ToLocalChecked(), \
        GetFunction(New<FunctionTemplate>(_nm)).ToLocalChecked());
 
// Gets inbound string parameter @ _infoIndex
#define STRVAL(_infoIndex) \
    *Nan::Utf8String(info[_infoIndex]->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()))
 
// Gets inbound integer parameter @ _infoIndex
#define INTVAL(_index) \
    info[_index]->Int32Value(Nan::GetCurrentContext()).FromJust()
 
// Return an integer
#define NANRETI(_expr) \
    info.GetReturnValue().Set(_expr);
 
// Return a string
#define NANRETS(_expr) \
    info.GetReturnValue().Set(New(_expr).ToLocalChecked());
 
// Defines a callback with no parameters
#define ENGAGE_CB_NO_PARAMS(_ename) \
    void on_ ## _ename(const char *eventExtraJson) \
    { \
        CrossThreadCallbackWorker *cbw = getCallback(#_ename); \
        if(!cbw) \
        { \
            return; \
        } \
        cbw->enqueue(eventExtraJson); \
        cbw->RELEASE_OBJECT_REFERENCE(); \
    }
 
// Defines a callback with a string parameter
#define ENGAGE_CB_STR_PARAM(_ename) \
    void on_ ## _ename(const char *str, const char *eventExtraJson) \
    { \
        CrossThreadCallbackWorker *cbw = getCallback(#_ename); \
        if(!cbw) \
        { \
            return; \
        } \
        cbw->enqueue(str, eventExtraJson); \
        cbw->RELEASE_OBJECT_REFERENCE(); \
    }
 
// Defines a callback with an ID (a string parameter)
#define ENGAGE_CB_ID_PARAM(_ename) \
    void on_ ## _ename(const char *id, const char *eventExtraJson) \
    { \
        CrossThreadCallbackWorker *cbw = getCallback(#_ename); \
        if(!cbw) \
        { \
            return; \
        } \
        cbw->enqueue(id, eventExtraJson); \
        cbw->RELEASE_OBJECT_REFERENCE(); \
    }
 
// Defines a callback with an ID (a string parameter) plus 1 strnig
#define ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(_ename) \
    void on_ ## _ename(const char *id, const char *s, const char *eventExtraJson) \
    { \
        CrossThreadCallbackWorker *cbw = getCallback(#_ename); \
        if(!cbw) \
        { \
            return; \
        } \
        cbw->enqueue(id, s, eventExtraJson); \
        cbw->RELEASE_OBJECT_REFERENCE(); \
    }
 
// A callback table entry
#define ENGAGE_CB_TABLE_ENTRY(_pfn, _ename) \
    g_eventCallbacks._pfn = on_ ## _ename;
 
// This little class wraps callbacks into JS from non-JS threads.  It does so by
// posting the callback/event onto the libuv event loop from which the instance
// of this worker class was created.  So ... be very careful only to create instances
// of this class from a thread that originated in libuv!!
class CrossThreadCallbackWorker
{
public:
    class Parameter
    {
    public:
        typedef enum {ptString, ptInt, ptStringVector} Type_t;
 
        Type_t _type;
    };
 
    class StringParameter : public Parameter
    {
    public:
        StringParameter(const char *s)
        {
            _type = ptString;
            if(s != nullptr && s[0] != 0)
            {
                _val = s;
            }
        }
 
        std::string _val;
    };
 
    class IntParameter : public Parameter
    {
    public:
        IntParameter(int i)
        {
            _type = ptInt;
            _val = i;
        }
 
        int _val;
    };
 
    class StringVectorParameter : public Parameter
    {
    public:
        StringVectorParameter(const char *array[])
        {
            _type = ptStringVector;
 
            // Our array is either null to begin with or terminated with a nullptr at the end
            if(array != nullptr)
            {
                size_t index = 0;
                while(array[index] != nullptr)
                {
                    _val.push_back(array[index] != nullptr ? array[index] : "");
                    index++;
                }
            }
        }
 
        std::vector<std::string> _val;
    };
 
    explicit CrossThreadCallbackWorker(v8::Local<v8::Function> fn)
    {
        Nan::HandleScope scope;
 
        // We're going to post this work on this libuv queue
        _evLoop = GetCurrentEventLoop();
 
        // Marshal the V8 function into a NAN callback structure
        _cb.Reset(fn);
 
        _workCtx.data = this;
        _isBusy = false;
        _refCount = 0;
 
        // TODO: I'm not convinced we even need this as there's no object here to get
        // garbage-collected.  TBD !!
        v8::Local<v8::Object> obj = New<v8::Object>();
        _persistentHandle.Reset(obj);
        _resource = new AsyncResource("CrossThreadCallbackWorker", obj);
 
        ADD_OBJECT_REFERENCE();
    }
 
    virtual ~CrossThreadCallbackWorker()
    {
        Nan::HandleScope scope;
 
        if (!_persistentHandle.IsEmpty())
        {
            _persistentHandle.Reset();
        }
 
        delete _resource;
    }
 
    void ADD_OBJECT_REFERENCE()
    {
        assert(_refCount >= 0);
        _refCount++;
    }
 
    void RELEASE_OBJECT_REFERENCE()
    {
        assert(_refCount > 0);
        if(_refCount.fetch_sub(1) == 1)
        {
            delete this;
        }
    }
 
    void enqueue(const char *extra)
    {
        std::vector<Parameter*> *params = new std::vector<Parameter*>();
        params->push_back(new StringParameter(extra));
        enqueue(params);
    }
 
    void enqueue(const char *s, const char *extra)
    {
        std::vector<Parameter*> *params = new std::vector<Parameter*>();
        params->push_back(new StringParameter(s));
        params->push_back(new StringParameter(extra));
        enqueue(params);
    }
 
    void enqueue(const char *s1, const char *s2, const char *extra)
    {
        std::vector<Parameter*> *params = new std::vector<Parameter*>();
        params->push_back(new StringParameter(s1));
        params->push_back(new StringParameter(s2));
        params->push_back(new StringParameter(extra));
        enqueue(params);
    }
 
    void enqueue(std::vector<Parameter*> *parameters)
    {
        // We need to wait here for the worker to become available (it may already be
        // queued in JS).  The chances of this happening are very slim as callbacks
        // don't happen that often and, when they do, they'll return in just a few
        // microseconds.  But, let's be paranoid shall we!
        _lock.lock();
 
        while(_isBusy)
        {
            _lock.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
            _lock.lock();
        }
 
        // Pass over the pending parameters
        _pendingParameters = parameters;
 
        _isBusy = true;
 
        _lock.unlock();
 
        ADD_OBJECT_REFERENCE();
        uv_queue_work(_evLoop,
                      &_workCtx,
                      CrossThreadCallbackWorker::onExecuteWork,
                      reinterpret_cast<uv_after_work_cb>(CrossThreadCallbackWorker::onWorkCompleted));
    }
 
    static void onExecuteWork(uv_work_t* workCtx)
    {
        // libuv wants us to execute something.  But we don't have any actual work to do.  So
        // we'll just return.
    }
 
    static void onWorkCompleted(uv_work_t* workCtx)
    {
        // We'll just bounce this though to the instance's method
        static_cast<CrossThreadCallbackWorker*>(workCtx->data)->internal_onWorkCompleted();
    }
 
private:
    NAN_DISALLOW_ASSIGN_COPY_MOVE(CrossThreadCallbackWorker)
 
    void internal_onWorkCompleted()
    {
        _lock.lock();
 
        // The real work here is to make the callback...
        Nan::HandleScope scope;
 
        v8::Isolate         *isolate = v8::Isolate::GetCurrent();
        v8::Local<Context>  context = v8::Context::New(isolate);
 
        // ... which we'll do here.
        if(_pendingParameters == nullptr || _pendingParameters->size() == 0)
        {
            _cb.Call(0, nullptr, _resource);
        }
        else
        {
            // We can only call into V8 here to build up the parameters because only now are we
            // on a thread that V8 owns.
            v8::Local<v8::Value> *argv = new v8::Local<v8::Value>[_pendingParameters->size()];
 
            int index = 0;
            for(std::vector<Parameter*>::iterator itr = _pendingParameters->begin();
                itr != _pendingParameters->end();
                itr++)
            {
                if((*itr)->_type == Parameter::ptString)
                {
                    argv[index] = Nan::New<v8::String>(((StringParameter*)(*itr))->_val).ToLocalChecked();
                }
                else if((*itr)->_type == Parameter::ptStringVector)
                {
                    StringVectorParameter *svp = (StringVectorParameter*)(*itr);
                    v8::Local<v8::Array> jsArray = Nan::New<v8::Array>(svp->_val.size());
 
                    int speakerIndex = 0;
                    for(std::vector<std::string>::iterator itrSpeakers = svp->_val.begin();
                        itrSpeakers != svp->_val.end();
                        itrSpeakers++)
                    {
                        #ifndef WIN32
                            #pragma GCC diagnostic push
                            #pragma GCC diagnostic ignored "-Wunused-result"
                        #endif
                        {
                            jsArray->Set(context, speakerIndex, v8::String::NewFromUtf8(isolate, itrSpeakers->c_str(), NewStringType::kNormal).ToLocalChecked());
                        }
                        #ifndef WIN32
                            #pragma GCC diagnostic pop
                        #endif
 
                        speakerIndex++;
                    }
 
                    argv[index] = jsArray;
                }
                else if((*itr)->_type == Parameter::ptInt)
                {
                    argv[index] = Nan::New<v8::Integer>(((IntParameter*)(*itr))->_val);
                }
 
                index++;
            }
 
            // Call into JS-land
            _cb.Call(_pendingParameters->size(), argv, _resource);
 
            // Get rid of any pending parameters
            if(_pendingParameters != nullptr)
            {
                for(std::vector<Parameter*>::iterator itr = _pendingParameters->begin();
                    itr != _pendingParameters->end();
                    itr++)
                {
                    delete *itr;
                }
 
                _pendingParameters->clear();
                delete _pendingParameters;
                _pendingParameters = nullptr;
            }
        }
 
        // ... and only now can we say that this worker is no longer in use - i.e. its out
        // out the libuv queue and won't cause a bus error in case it gets reused very
        // quickly (that can happen if this code runs in onExecuteWork).
        _isBusy = false;
 
        _lock.unlock();
 
        // Finally, let go of the reference we added when this was enqueue
        RELEASE_OBJECT_REFERENCE();
    }
 
    std::mutex _lock;
    uv_loop_t *_evLoop;
    uv_work_t _workCtx;
    bool _isBusy;
    Nan::Callback _cb;
    Nan::Persistent<v8::Object> _persistentHandle;
    AsyncResource *_resource;
    std::atomic<int>  _refCount;
    std::vector<Parameter*> *_pendingParameters;
};
 
typedef std::map<std::string, CrossThreadCallbackWorker*> CallbackMap_t;
 
static EngageEvents_t g_eventCallbacks;
static bool g_wantCallbacks = true;
static CallbackMap_t g_cbMap;
static std::mutex g_cbMapLock;
static std::string g_loggingHookFn;
 
//--------------------------------------------------------
// Returns the callback associated with an event name (if any)
static CrossThreadCallbackWorker *getCallback(const char *cbName)
{
    if(!g_wantCallbacks)
    {
        return nullptr;
    }
 
    CrossThreadCallbackWorker *rc = nullptr;
 
    g_cbMapLock.lock();
 
    CallbackMap_t::iterator itr = g_cbMap.find(cbName);
    if(itr != g_cbMap.end())
    {
        rc = itr->second;
        rc->ADD_OBJECT_REFERENCE();
    }
 
    g_cbMapLock.unlock();
 
    return rc;
}
 
 
// The following convey events from Engage up to JS.  They all follow the same
// basic flow of finding a callback for the event name and, if one is found, calling
// it.  Generally callbacks have no parameters, or a single string parameter.  But,
// some of them are a little unique.  So, for those that look the same, we'll use the
// ENGAGE_CB_xx_PARAMS macros.  For the others, we'll actually write all the code for each.
ENGAGE_CB_NO_PARAMS(engineStarted)
ENGAGE_CB_NO_PARAMS(engineStopped)
ENGAGE_CB_NO_PARAMS(engineAudioDevicesRefreshed)
 
ENGAGE_CB_ID_PARAM(rpPausingConnectionAttempt)
ENGAGE_CB_ID_PARAM(rpConnecting)
ENGAGE_CB_ID_PARAM(rpConnected)
ENGAGE_CB_ID_PARAM(rpDisconnected)
void on_rpRoundtripReport(const char *id, uint32_t rtMs, uint32_t rtQualityRating, const char * eventExtraJson)
{
    CrossThreadCallbackWorker *cbw = getCallback("rpRoundtripReport");
    if(!cbw)
    {
        return;
    }
 
    std::vector<CrossThreadCallbackWorker::Parameter*> *params = new std::vector<CrossThreadCallbackWorker::Parameter*>();
    params->push_back(new CrossThreadCallbackWorker::StringParameter(id));
    params->push_back(new CrossThreadCallbackWorker::IntParameter((int)rtMs));
    params->push_back(new CrossThreadCallbackWorker::IntParameter((int)rtQualityRating));
    params->push_back(new CrossThreadCallbackWorker::StringParameter(eventExtraJson));
    cbw->enqueue(params);
 
    cbw->RELEASE_OBJECT_REFERENCE();
}
 
ENGAGE_CB_ID_PARAM(groupCreated)
ENGAGE_CB_ID_PARAM(groupCreateFailed)
ENGAGE_CB_ID_PARAM(groupDeleted)
 
ENGAGE_CB_ID_PARAM(groupConnected)
ENGAGE_CB_ID_PARAM(groupConnectFailed)
ENGAGE_CB_ID_PARAM(groupDisconnected)
 
ENGAGE_CB_ID_PARAM(groupJoined)
ENGAGE_CB_ID_PARAM(groupJoinFailed)
ENGAGE_CB_ID_PARAM(groupLeft)
 
ENGAGE_CB_ID_PARAM(groupRxStarted)
ENGAGE_CB_ID_PARAM(groupRxEnded)
 
ENGAGE_CB_ID_PARAM(groupRxMuted)
ENGAGE_CB_ID_PARAM(groupRxUnmuted)
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupRxSpeakersChanged)
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupNodeDiscovered)
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupNodeRediscovered)
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupNodeUndiscovered)
 
ENGAGE_CB_ID_PARAM(groupTxStarted);
ENGAGE_CB_ID_PARAM(groupTxEnded);
ENGAGE_CB_ID_PARAM(groupTxFailed);
ENGAGE_CB_ID_PARAM(groupTxUsurpedByPriority);
ENGAGE_CB_ID_PARAM(groupMaxTxTimeExceeded);
 
ENGAGE_CB_ID_PARAM(groupTxMuted)
ENGAGE_CB_ID_PARAM(groupTxUnmuted)
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupAssetDiscovered);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupAssetRediscovered);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupAssetUndiscovered);
 
ENGAGE_CB_NO_PARAMS(licenseChanged)
ENGAGE_CB_NO_PARAMS(licenseExpired)
ENGAGE_CB_STR_PARAM(licenseExpiring)
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupTimelineEventStarted);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupTimelineEventUpdated);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupTimelineEventEnded);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupTimelineReport);
ENGAGE_CB_ID_PARAM(groupTimelineReportFailed);
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupTimelineGroomed);
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupHealthReport);
ENGAGE_CB_ID_PARAM(groupHealthReportFailed);
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupStatsReport);
ENGAGE_CB_ID_PARAM(groupStatsReportFailed);
 
void on_groupRxVolumeChanged(const char *id, int16_t leftLevelPerc, int16_t rightLevelPerc, const char * eventExtraJson)
{
    CrossThreadCallbackWorker *cbw = getCallback("groupRxVolumeChanged");
    if(!cbw)
    {
        return;
    }
 
    std::vector<CrossThreadCallbackWorker::Parameter*> *params = new std::vector<CrossThreadCallbackWorker::Parameter*>();
    params->push_back(new CrossThreadCallbackWorker::StringParameter(id));
    params->push_back(new CrossThreadCallbackWorker::IntParameter((int)leftLevelPerc));
    params->push_back(new CrossThreadCallbackWorker::IntParameter((int)rightLevelPerc));
    params->push_back(new CrossThreadCallbackWorker::StringParameter(eventExtraJson));
    cbw->enqueue(params);
 
    cbw->RELEASE_OBJECT_REFERENCE();
}
 
ENGAGE_CB_ID_PLUS_ONE_STRING_PARAM(groupRxDtmf)
 
 
//--------------------------------------------------------
// Registers an event name and the JS callback function
NAN_METHOD(on)
{
    bool haveAFunction = false;
    std::string functionName = STRVAL(0);
 
    if(info.Length() >= 2 && (!info[1]->IsUndefined()) && (!info[1]->IsNull()))
    {
        haveAFunction = true;
    }
 
    g_cbMapLock.lock();
 
    // Find our map entry
    CallbackMap_t::iterator itr = g_cbMap.find(functionName.c_str());
 
    // We don't yet have an entry in the map
    if(itr == g_cbMap.end())
    {
        // If we don't have a function, then we're done
        if(!haveAFunction)
        {
            g_cbMapLock.unlock();
            return;
        }
 
        // We have a function but not yet an entry, make it and plug it into the map
        g_cbMap[functionName.c_str()] = new CrossThreadCallbackWorker(Nan::To<v8::Function>(info[1]).ToLocalChecked());
    }
    else
    {
        // We have an entry ...
 
        // ... get rid of it (we're either removing or replacing)
        itr->second->RELEASE_OBJECT_REFERENCE();
        g_cbMap.erase(itr);
 
        // ... and maybe put in the new one
        if(haveAFunction)
        {
            g_cbMap[functionName.c_str()] = new CrossThreadCallbackWorker(Nan::To<v8::Function>(info[1]).ToLocalChecked());
        }
    }
 
    g_cbMapLock.unlock();
}
 
 
//--------------------------------------------------------
NAN_METHOD(initialize)
{
    /*
    #if defined(WIN32)
        engageWin32LibraryInit();
    #endif
    */
 
    memset(&g_eventCallbacks, 0, sizeof(g_eventCallbacks));
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_ENGINE_STARTED, engineStarted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_ENGINE_STOPPED, engineStopped);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_ENGINE_AUDIO_DEVICES_REFRESHED, engineAudioDevicesRefreshed);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_RP_PAUSING_CONNECTION_ATTEMPT, rpPausingConnectionAttempt);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_RP_CONNECTING, rpConnecting);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_RP_CONNECTED, rpConnected);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_RP_DISCONNECTED, rpDisconnected);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_RP_ROUNDTRIP_REPORT, rpRoundtripReport);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_CREATED, groupCreated);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_CREATE_FAILED, groupCreateFailed);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_DELETED, groupDeleted);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_CONNECTED, groupConnected);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_CONNECT_FAILED, groupConnectFailed);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_DISCONNECTED, groupDisconnected);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_JOINED, groupJoined);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_JOIN_FAILED, groupJoinFailed);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_LEFT, groupLeft);
    //ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_MEMBER_COUNT_CHANGED)(const char *pId, size_t newCount);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_NODE_DISCOVERED, groupNodeDiscovered);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_NODE_REDISCOVERED, groupNodeRediscovered);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_NODE_UNDISCOVERED, groupNodeUndiscovered);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_STARTED, groupRxStarted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_ENDED, groupRxEnded);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_SPEAKERS_CHANGED, groupRxSpeakersChanged);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_MUTED, groupRxMuted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_UNMUTED, groupRxUnmuted);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_STARTED, groupTxStarted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_ENDED, groupTxEnded);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_FAILED, groupTxFailed);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_USURPED_BY_PRIORITY, groupTxUsurpedByPriority);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_MAX_TX_TIME_EXCEEDED, groupMaxTxTimeExceeded);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_MUTED, groupTxMuted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TX_UNMUTED, groupTxUnmuted);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_ASSET_DISCOVERED, groupAssetDiscovered);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_ASSET_REDISCOVERED, groupAssetRediscovered);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_ASSET_UNDISCOVERED, groupAssetUndiscovered);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_LICENSE_CHANGED, licenseChanged);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_LICENSE_EXPIRED, licenseExpired);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_LICENSE_EXPIRING, licenseExpiring);
 
    // TODO PFN_ENGAGE_GROUP_BLOB_SENT
    // TODO PFN_ENGAGE_GROUP_BLOB_SEND_FAILED
    // TODO PFN_ENGAGE_GROUP_BLOB_RECEIVED
 
    // TODO PFN_ENGAGE_GROUP_RTP_SENT
    // TODO PFN_ENGAGE_GROUP_RTP_SEND_FAILED
    // TODO PFN_ENGAGE_GROUP_RTP_RECEIVED
 
    // TODO PFN_ENGAGE_GROUP_RAW_SENT
    // TODO PFN_ENGAGE_GROUP_RAW_SEND_FAILED
    // TODO PFN_ENGAGE_GROUP_RAW_RECEIVED
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_EVENT_STARTED, groupTimelineEventStarted);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_EVENT_UPDATED, groupTimelineEventUpdated);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_EVENT_ENDED, groupTimelineEventEnded);
    
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_REPORT, groupTimelineReport);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_REPORT_FAILED, groupTimelineReportFailed);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_TIMELINE_GROOMED, groupTimelineGroomed);
    
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_HEALTH_REPORT, groupHealthReport);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_HEALTH_REPORT_FAILED, groupHealthReportFailed);
    
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_STATS_REPORT, groupStatsReport);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_STATS_REPORT_FAILED, groupStatsReportFailed);
 
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_VOLUME_CHANGED, groupRxVolumeChanged);
    ENGAGE_CB_TABLE_ENTRY(PFN_ENGAGE_GROUP_RX_DTMF, groupRxDtmf);
 
    engageRegisterEventCallbacks(&g_eventCallbacks);
 
    NANRETI(engageInitialize(STRVAL(0), STRVAL(1), STRVAL(2)));
}
 
//--------------------------------------------------------
NAN_METHOD(enableCallbacks)
{
    g_wantCallbacks = true;
    NANRETI((int)ENGAGE_RESULT_OK);
}
 
//--------------------------------------------------------
NAN_METHOD(disableCallbacks)
{
    g_wantCallbacks = false;
    NANRETI((int)ENGAGE_RESULT_OK);
}
 
//--------------------------------------------------------
NAN_METHOD(setLogLevel)
{
    NANRETI(engageSetLogLevel(INTVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(setLogTagExtension)
{
    NANRETI(engageSetLogTagExtension(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(engageEnableSyslog)
{
    NANRETI(engageEnableSyslog(INTVAL(0) == 1 ? ENGAGE_SYSLOG_ENABLE : ENGAGE_SYSLOG_DISABLE));
}
 
//--------------------------------------------------------
NAN_METHOD(engageEnableWatchdog)
{
    NANRETI(engageEnableWatchdog(INTVAL(0) == 1 ? ENGAGE_WATCHDOG_ENABLE : ENGAGE_WATCHDOG_DISABLE));
}
 
//--------------------------------------------------------
NAN_METHOD(shutdown)
{
    NANRETI(engageShutdown());
 
    /*
    #if defined(WIN32)
        engageWin32LibraryDeinit();
    #endif
    */
}
 
//--------------------------------------------------------
NAN_METHOD(start)
{
    NANRETI(engageStart());
}
 
//--------------------------------------------------------
NAN_METHOD(stop)
{
    NANRETI(engageStop());
}
 
//--------------------------------------------------------
NAN_METHOD(createGroup)
{
    NANRETI(engageCreateGroup(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(deleteGroup)
{
    NANRETI(engageDeleteGroup(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(joinGroup)
{
    NANRETI(engageJoinGroup(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(leaveGroup)
{
    NANRETI(engageLeaveGroup(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(setGroupRules)
{
    NANRETI(engageSetGroupRules(STRVAL(0), STRVAL(1)));
}
 
//--------------------------------------------------------
NAN_METHOD(beginGroupTx)
{
    NANRETI(engageBeginGroupTx(STRVAL(0), INTVAL(1), INTVAL(2)));
}
 
//--------------------------------------------------------
NAN_METHOD(beginGroupTxAdvanced)
{
    NANRETI(engageBeginGroupTxAdvanced(STRVAL(0), STRVAL(1)));
}
 
//--------------------------------------------------------
NAN_METHOD(endGroupTx)
{
    NANRETI(engageEndGroupTx(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(setGroupRxTag)
{
    NANRETI(engageSetGroupRxTag(STRVAL(0), INTVAL(1)));
}
 
//--------------------------------------------------------
NAN_METHOD(muteGroupRx)
{
    NANRETI(engageMuteGroupRx(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(unmuteGroupRx)
{
    NANRETI(engageUnmuteGroupRx(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(muteGroupTx)
{
    NANRETI(engageMuteGroupTx(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(unmuteGroupTx)
{
    NANRETI(engageUnmuteGroupTx(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(setGroupRxVolume)
{
    NANRETI(engageSetGroupRxVolume(STRVAL(0), INTVAL(1), INTVAL(2)));
}
 
//--------------------------------------------------------
NAN_METHOD(updatePresenceDescriptor)
{
    NANRETI(engageUpdatePresenceDescriptor(STRVAL(0), STRVAL(1), INTVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(encrypt)
{
    uint8_t* inputBytes = (uint8_t*) node::Buffer::Data(info[0]);
 
    size_t inputOfs = INTVAL(1);
    size_t inputLen = INTVAL(2);
 
    // Our output is going to contain encrypted data padded to 16 bytes + another 16 bytes of IV
    uint8_t *outputBytes = new uint8_t[inputLen + 16 * 2];
 
    int bytesInOutput = engageEncrypt(inputBytes + inputOfs, inputLen, outputBytes, STRVAL(3));
 
    if(bytesInOutput > 0)
    {
        info.GetReturnValue().Set(Nan::CopyBuffer((char*)outputBytes, bytesInOutput).ToLocalChecked());
    }
 
    delete[] outputBytes;
}
 
//--------------------------------------------------------
NAN_METHOD(decrypt)
{
    uint8_t* inputBytes = (uint8_t*) node::Buffer::Data(info[0]);
 
    size_t inputOfs = INTVAL(1);
    size_t inputLen = INTVAL(2);
 
    // Our output is not going to be larger than the input (if anything, it'll be smaller)
    uint8_t *outputBytes = new uint8_t[inputLen];
 
    int bytesInOutput =  engageDecrypt(inputBytes + inputOfs, inputLen, outputBytes, STRVAL(3));
 
    if(bytesInOutput > 0)
    {
        info.GetReturnValue().Set(Nan::CopyBuffer((char*)outputBytes, bytesInOutput).ToLocalChecked());
    }
 
    delete[] outputBytes;
}
 
//--------------------------------------------------------
NAN_METHOD(getVersion)
{
    const char *rc = engageGetVersion();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getHardwareReport)
{
    const char *rc = engageGetHardwareReport();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getActiveLicenseDescriptor)
{
    const char *rc = engageGetActiveLicenseDescriptor();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getLicenseDescriptor)
{
    const char *rc = engageGetLicenseDescriptor(STRVAL(0), STRVAL(1), STRVAL(2), STRVAL(3));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(updateLicense)
{
    NANRETI(engageUpdateLicense(STRVAL(0), STRVAL(1), STRVAL(2), STRVAL(3)));
}
 
// TODO: engageSendGroupRtp
// TODO: engageRegisterGroupRtpHandler
// TODO: engageUnregisterGroupRtpHandler
// TODO: engageSendGroupBlob
// TODO: engageSendGroupRaw
// TODO: engagePlatformServiceDiscovered
// TODO: engagePlatformServiceRediscovered
// TODO: engagePlatformServiceUndiscovered
 
//--------------------------------------------------------
NAN_METHOD(queryGroupTimeline)
{
    NANRETI(engageQueryGroupTimeline(STRVAL(0), STRVAL(1)));
}
 
//--------------------------------------------------------
NAN_METHOD(queryGroupHealth)
{
    NANRETI(engageQueryGroupHealth(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(queryGroupStats)
{
    NANRETI(engageQueryGroupStats(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(getNetworkInterfaceDevices)
{
    const char *rc = engageGetNetworkInterfaceDevices();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getAudioDevices)
{
    const char *rc = engageGetAudioDevices();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(generateMission)
{
    const char *rc = engageGenerateMission(STRVAL(0), INTVAL(1), STRVAL(2), STRVAL(3));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(generateMissionUsingCertStore)
{
    const char *rc = engageGenerateMissionUsingCertStore(STRVAL(0), INTVAL(1), STRVAL(2), STRVAL(3), STRVAL(4), STRVAL(5), STRVAL(6));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(setMissionId)
{
    NANRETI(engageSetMissionId(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(openCertStore)
{
    NANRETI(engageOpenCertStore(STRVAL(0), STRVAL(1)));
}
 
//--------------------------------------------------------
NAN_METHOD(closeCertStore)
{
    NANRETI(engageCloseCertStore());
}
 
//--------------------------------------------------------
NAN_METHOD(setCertStoreCertificatePem)
{
    NANRETI(engageSetCertStoreCertificatePem(STRVAL(0), STRVAL(1), STRVAL(2), STRVAL(3)));
}
 
//--------------------------------------------------------
NAN_METHOD(setCertStoreCertificateP12)
{
    NANRETI(engageSetCertStoreCertificateP12(STRVAL(0), (uint8_t*) node::Buffer::Data(info[1]), INTVAL(2), STRVAL(3), STRVAL(4)));
}
 
//--------------------------------------------------------
NAN_METHOD(deleteCertStoreCertificate)
{
    NANRETI(engageDeleteCertStoreCertificate(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(getCertStoreCertificatePem)
{
    const char *rc = engageGetCertStoreCertificatePem(STRVAL(0));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getArrayOfCertificateDescriptorsFromPem)
{
    const char *rc = engageGetArrayOfCertificateDescriptorsFromPem(STRVAL(0));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(getCertificateDescriptorFromPem)
{
    const char *rc = engageGetCertificateDescriptorFromPem(STRVAL(0));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(importCertStoreElementFromCertStore)
{
    NANRETI(engageImportCertStoreElementFromCertStore(STRVAL(0), STRVAL(1), STRVAL(2), STRVAL(3), STRVAL(4)));
}
 
//--------------------------------------------------------
NAN_METHOD(queryCertStoreContents)
{
    const char *rc = engageQueryCertStoreContents(STRVAL(0), STRVAL(1));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
//--------------------------------------------------------
NAN_METHOD(setCertStoreCertificateTags)
{
    NANRETI(engageSetCertStoreCertificateTags(STRVAL(0), STRVAL(1)));
}
 
 
//--------------------------------------------------------
NAN_METHOD(logMsg)
{
    NANRETI(engageLogMsg(INTVAL(0), STRVAL(1), STRVAL(2)));
}
 
//--------------------------------------------------------
NAN_METHOD(platformNotifyChanges)
{
    NANRETI(engagePlatformNotifyChanges(STRVAL(0)));
}
 
//--------------------------------------------------------
static void internalEngageLoggingHook(int level, const char *tag, const char *message)
{
    if(g_loggingHookFn.empty())
    {
        return;
    }
 
    CrossThreadCallbackWorker *cbw = getCallback(g_loggingHookFn.c_str());
    if(!cbw)
    {
        return;
    }
 
    std::vector<CrossThreadCallbackWorker::Parameter*> *params = new std::vector<CrossThreadCallbackWorker::Parameter*>();
    params->push_back(new CrossThreadCallbackWorker::IntParameter(level));
    params->push_back(new CrossThreadCallbackWorker::StringParameter(tag));
    params->push_back(new CrossThreadCallbackWorker::StringParameter(message));
    cbw->enqueue(params);
 
    cbw->RELEASE_OBJECT_REFERENCE();
}
 
//--------------------------------------------------------
NAN_METHOD(hookEngineLogging)
{
    g_loggingHookFn = STRVAL(0);
 
    if(!g_loggingHookFn.empty())
    {
        engageSetLoggingOutputOverride(internalEngageLoggingHook);
    }
    else
    {
        engageSetLoggingOutputOverride(nullptr);
    }
}
 
//--------------------------------------------------------
NAN_METHOD(setFipsCrypto)
{
    NANRETI(engageSetFipsCrypto(STRVAL(0)));
}
 
//--------------------------------------------------------
NAN_METHOD(isCryptoFipsValidated)
{
    NANRETI(engageIsCryptoFipsValidated());
}
 
//--------------------------------------------------------
NAN_METHOD(setCertStore)
{
    NANRETI(engageSetCertStore((uint8_t*) node::Buffer::Data(info[0]), INTVAL(1), STRVAL(2)));
}
 
//--------------------------------------------------------
NAN_METHOD(getDeviceId)
{
    const char *rc = engageGetDeviceId();
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
 
//--------------------------------------------------------
NAN_METHOD(verifyRiff)
{
    NANRETI(engageVerifyRiff(STRVAL(0)));
}
 
 
//--------------------------------------------------------
NAN_METHOD(getRiffDescriptor)
{
    const char *rc = engageGetRiffDescriptor(STRVAL(0));
 
    if(rc == nullptr)
    {
        rc = "";
    }
 
    NANRETS(rc);
}
 
 
//--------------------------------------------------------
NAN_MODULE_INIT(Init)
{
    ENGAGE_BINDING(on);
 
    ENGAGE_BINDING(setLogLevel);
 
    ENGAGE_BINDING(enableCallbacks);
    ENGAGE_BINDING(disableCallbacks);
 
    ENGAGE_BINDING(initialize);
    ENGAGE_BINDING(shutdown);
 
    ENGAGE_BINDING(start);
    ENGAGE_BINDING(stop);
 
    ENGAGE_BINDING(createGroup);
    ENGAGE_BINDING(deleteGroup);
    ENGAGE_BINDING(joinGroup);
    ENGAGE_BINDING(leaveGroup);
    ENGAGE_BINDING(setGroupRules);
 
    ENGAGE_BINDING(beginGroupTx);
    ENGAGE_BINDING(beginGroupTxAdvanced);
    ENGAGE_BINDING(endGroupTx);
    ENGAGE_BINDING(setGroupRxTag);
 
    ENGAGE_BINDING(muteGroupRx);
    ENGAGE_BINDING(unmuteGroupRx);
 
    ENGAGE_BINDING(muteGroupTx);
    ENGAGE_BINDING(unmuteGroupTx);
 
    ENGAGE_BINDING(setGroupRxVolume);
 
    ENGAGE_BINDING(queryGroupTimeline);
 
    ENGAGE_BINDING(updatePresenceDescriptor);
 
    ENGAGE_BINDING(encrypt);
    ENGAGE_BINDING(decrypt);
 
    ENGAGE_BINDING(updateLicense);
    ENGAGE_BINDING(getVersion);
    ENGAGE_BINDING(getHardwareReport);
    ENGAGE_BINDING(getNetworkInterfaceDevices);
    ENGAGE_BINDING(getAudioDevices);
 
    ENGAGE_BINDING(getActiveLicenseDescriptor);
    ENGAGE_BINDING(getLicenseDescriptor);
 
    ENGAGE_BINDING(openCertStore);
    ENGAGE_BINDING(closeCertStore);
    ENGAGE_BINDING(setCertStore);
    ENGAGE_BINDING(setCertStoreCertificatePem);
    ENGAGE_BINDING(setCertStoreCertificateP12);
    ENGAGE_BINDING(deleteCertStoreCertificate);
    ENGAGE_BINDING(getCertStoreCertificatePem);
    ENGAGE_BINDING(getCertificateDescriptorFromPem);
    ENGAGE_BINDING(importCertStoreElementFromCertStore);
    ENGAGE_BINDING(queryCertStoreContents);
    ENGAGE_BINDING(setCertStoreCertificateTags);
 
    ENGAGE_BINDING(generateMission);
    ENGAGE_BINDING(generateMissionUsingCertStore);    
 
    ENGAGE_BINDING(setMissionId);
    ENGAGE_BINDING(platformNotifyChanges);
 
    ENGAGE_BINDING(logMsg);
    ENGAGE_BINDING(hookEngineLogging);
 
    ENGAGE_BINDING(setFipsCrypto);
    ENGAGE_BINDING(isCryptoFipsValidated);
 
    ENGAGE_BINDING(getDeviceId);
 
    ENGAGE_BINDING(verifyRiff);
    ENGAGE_BINDING(getRiffDescriptor);    
}
 
NODE_MODULE(engage, Init)