node-datachannel 0.1.13 → 0.1.14-dev

package/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW)
-project(node_datachannel VERSION 0.1.13)
+project(node_datachannel VERSION 0.1.14)
 
 include_directories(${CMAKE_JS_INC})
 
@@ -27,7 +27,7 @@ include(FetchContent)
 FetchContent_Declare(
     libdatachannel
     GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
-    GIT_TAG "v0.15.6"
+    GIT_TAG "v0.16.0"
 )
 
 option(NO_MEDIA "Disable media transport support in libdatachannel" ON)
@@ -44,6 +44,7 @@ add_library(${PROJECT_NAME} SHARED
     src/rtc-wrapper.cpp
     src/data-channel-wrapper.cpp
     src/peer-connection-wrapper.cpp
+    src/thread-safe-callback.cpp
     src/main.cpp
     ${CMAKE_JS_SRC}
 )
@@ -53,10 +54,16 @@ set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 
 target_include_directories(${PROJECT_NAME} PRIVATE
     ${CMAKE_SOURCE_DIR}/node_modules/node-addon-api
-    ${CMAKE_SOURCE_DIR}/node_modules/napi-thread-safe-callback
     ${CMAKE_BINARY_DIR}/_deps/libdatachannel-src/include
 )
 
+# For compatibility with Node.js 12
+# This should be removed along with the napi-thread-safe-callback-cancellable dependency when dropping support at end-of-life
+target_compile_definitions(${PROJECT_NAME} PRIVATE -DLEGACY_NAPI_THREAD_SAFE_CALLBACK)
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${CMAKE_SOURCE_DIR}/node_modules/napi-thread-safe-callback-cancellable
+)
+
 set(LINK_LIBRARIES
     ${CMAKE_JS_LIB}
     datachannel-static

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-datachannel",
-  "version": "0.1.13",
+  "version": "0.1.14-dev",
   "description": "libdatachannel node bindings",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -15,7 +15,7 @@
     "build": "cmake-js build",
     "_prebuild": "prebuild --backend cmake-js",
     "clean": "cmake-js clean",
-    "test": "jest --forceExit"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -24,7 +24,16 @@
   "keywords": [
     "libdatachannel"
   ],
-  "author": "Murat Doğan",
+  "contributors": [
+    {
+      "name": "Murat Doğan",
+      "url": "https://github.com/murat-dogan"
+    },
+    {
+      "name": "Paul-Louis Ageneau",
+      "url": "https://github.com/paullouisageneau"
+    }
+  ],
   "license": "GPL-2.0-or-later",
   "gypfile": true,
   "bugs": {
@@ -35,8 +44,8 @@
     "cmake-js": "^6.2.1",
     "jest": "^27.2.5",
     "nan": "^2.15.0",
-    "napi-thread-safe-callback": "0.0.6",
-    "node-addon-api": "^3.2.1",
+    "napi-thread-safe-callback-cancellable": "^0.0.7",
+    "node-addon-api": "^4.2.0",
     "prebuild": "^11.0.0"
   },
   "bundledDependencies": [

package/src/data-channel-wrapper.cpp

@@ -1,6 +1,14 @@
 #include "data-channel-wrapper.h"
 
 Napi::FunctionReference DataChannelWrapper::constructor;
+std::unordered_set<DataChannelWrapper*> DataChannelWrapper::instances;
+
+void DataChannelWrapper::CloseAll()
+{
+    auto copy(instances);
+    for(auto inst : copy)
+        inst->doClose();
+}
 
 Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 {
@@ -35,14 +43,30 @@ Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<DataChannelWrapper>(info)
 {
     mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());
+
+    instances.insert(this);
 }
 
 DataChannelWrapper::~DataChannelWrapper()
 {
+    doClose();
+}
+
+void DataChannelWrapper::doClose()
+{
+    instances.erase(this);
+
     if (mDataChannelPtr)
     {
         try
         {
+            mOnOpenCallback.reset();
+            mOnClosedCallback.reset();
+            mOnErrorCallback.reset();
+            mOnAvailableCallback.reset();
+            mOnBufferedAmountLowCallback.reset();
+            mOnMessageCallback.reset();
+
             mDataChannelPtr->close();
             mDataChannelPtr.reset();
         }
@@ -56,23 +80,7 @@ DataChannelWrapper::~DataChannelWrapper()
 
 void DataChannelWrapper::close(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
-    if (!mDataChannelPtr)
-    {
-        Napi::Error::New(env, "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
-        return;
-    }
-
-    try
-    {
-        mDataChannelPtr->close();
-        mDataChannelPtr.reset();
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while closing dataChannel# ") + ex.what()).ThrowAsJavaScriptException();
-        return;
-    }
+    doClose();
 }
 
 Napi::Value DataChannelWrapper::getLabel(const Napi::CallbackInfo &info)
@@ -260,11 +268,15 @@ void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnOpenCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onOpen([&]() {
         if (mOnOpenCallback)
-            mOnOpenCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+            mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
@@ -284,11 +296,15 @@ void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnClosedCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onClosed([&]() {
         if (mOnClosedCallback)
-            mOnClosedCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
@@ -308,11 +324,15 @@ void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnErrorCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onError([&](const std::string &error) {
         if (mOnErrorCallback)
-            mOnErrorCallback->call([error](Napi::Env env, std::vector<napi_value> &args) {
+            mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {Napi::String::New(env, error)};
@@ -332,11 +352,15 @@ void DataChannelWrapper::onAvailable(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnAvailableCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnAvailableCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onAvailable([&]() {
         if (mOnAvailableCallback)
-            mOnAvailableCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+            mOnAvailableCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
@@ -356,11 +380,15 @@ void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnBufferedAmountLowCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnBufferedAmountLowCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onBufferedAmountLow([&]() {
         if (mOnBufferedAmountLowCallback)
-            mOnBufferedAmountLowCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+            mOnBufferedAmountLowCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
@@ -380,11 +408,15 @@ void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnMessageCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mDataChannelPtr->onMessage([&](const std::variant<rtc::binary, std::string> &message) {
         if (mOnMessageCallback)
-            mOnMessageCallback->call([message](Napi::Env env, std::vector<napi_value> &args) {
+            mOnMessageCallback->call([this, message](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 Napi::Object payload = Napi::Object::New(env);
@@ -398,4 +430,4 @@ void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
                 }
             });
     });
-}
+}

package/src/data-channel-wrapper.h

@@ -5,9 +5,12 @@
 #include <string>
 #include <variant>
 #include <memory>
+#include <unordered_set>
+
 #include <napi.h>
-#include <napi-thread-safe-callback.hpp>
-#include "rtc/rtc.hpp"
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
 
 class DataChannelWrapper : public Napi::ObjectWrap<DataChannelWrapper>
 {
@@ -36,17 +39,24 @@ public:
   void onBufferedAmountLow(const Napi::CallbackInfo &info);
   void onMessage(const Napi::CallbackInfo &info);
 
+  // Close all existing DataChannels
+  static void CloseAll();
+
 private:
+  static std::unordered_set<DataChannelWrapper*> instances;
+
+  void doClose();
+
   std::string mLabel;
   std::shared_ptr<rtc::DataChannel> mDataChannelPtr = nullptr;
 
   // Callback Ptrs
-  std::shared_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnAvailableCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnBufferedAmountLowCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnAvailableCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnBufferedAmountLowCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
 };
 
-#endif // DATA_CHANNEL_WRAPPER_H
+#endif // DATA_CHANNEL_WRAPPER_H

package/src/peer-connection-wrapper.cpp

@@ -1,8 +1,17 @@
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
+
 #include <sstream>
 
 Napi::FunctionReference PeerConnectionWrapper::constructor;
+std::unordered_set<PeerConnectionWrapper*> PeerConnectionWrapper::instances;
+
+void PeerConnectionWrapper::CloseAll()
+{
+    auto copy(instances);
+    for(auto inst : copy)
+        inst->doClose();
+}
 
 Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
 {
@@ -180,21 +189,36 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // Create peer-connection
     try
     {
-        mRtcPeerConnPtr = std::make_shared<rtc::PeerConnection>(rtcConfig);
+        mRtcPeerConnPtr = std::make_unique<rtc::PeerConnection>(rtcConfig);
     }
     catch (std::exception &ex)
     {
         Napi::Error::New(env, std::string("libdatachannel error while creating peerConnection# ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
+
+    instances.insert(this);
 }
 
 PeerConnectionWrapper::~PeerConnectionWrapper()
 {
+    doClose();
+}
+
+void PeerConnectionWrapper::doClose()
+{
+    instances.erase(this);
+
     if (mRtcPeerConnPtr)
     {
         try
         {
+            mOnLocalDescriptionCallback.reset();
+            mOnLocalCandidateCallback.reset();
+            mOnStateChangeCallback.reset();
+            mOnGatheringStateChangeCallback.reset();
+            mOnDataChannelCallback.reset();
+
             mRtcPeerConnPtr->close();
             mRtcPeerConnPtr.reset();
         }
@@ -208,23 +232,7 @@ PeerConnectionWrapper::~PeerConnectionWrapper()
 
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
-    if (!mRtcPeerConnPtr)
-    {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
-        return;
-    }
-
-    try
-    {
-        mRtcPeerConnPtr->close();
-        mRtcPeerConnPtr.reset();
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while closing peerConnection# ") + ex.what()).ThrowAsJavaScriptException();
-        return;
-    }
+    doClose();
 }
 
 void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
@@ -468,11 +476,15 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnLocalDescriptionCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnLocalDescriptionCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mRtcPeerConnPtr->onLocalDescription([&](const rtc::Description &sdp) {
         if (mOnLocalDescriptionCallback)
-            mOnLocalDescriptionCallback->call([sdp](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalDescriptionCallback->call([this, sdp](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {
@@ -494,11 +506,15 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnLocalCandidateCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnLocalCandidateCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mRtcPeerConnPtr->onLocalCandidate([&](const rtc::Candidate &candidate) {
         if (mOnLocalCandidateCallback)
-            mOnLocalCandidateCallback->call([candidate](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalCandidateCallback->call([this, candidate](Napi::Env env, std::vector<napi_value> &args) {
+                 // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {
@@ -520,11 +536,15 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnStateChangeCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state) {
         if (mOnStateChangeCallback)
-            mOnStateChangeCallback->call([state](Napi::Env env, std::vector<napi_value> &args) {
+            mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 std::ostringstream stream;
@@ -546,11 +566,15 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
     }
 
     // Callback
-    mOnGatheringStateChangeCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnGatheringStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mRtcPeerConnPtr->onGatheringStateChange([&](rtc::PeerConnection::GatheringState state) {
         if (mOnGatheringStateChangeCallback)
-            mOnGatheringStateChangeCallback->call([state](Napi::Env env, std::vector<napi_value> &args) {
+            mOnGatheringStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 std::ostringstream stream;
@@ -572,11 +596,15 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
     }
 
     // Callback
-    mOnDataChannelCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+    mOnDataChannelCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
     mRtcPeerConnPtr->onDataChannel([&](std::shared_ptr<rtc::DataChannel> dc) {
         if (mOnDataChannelCallback)
-            mOnDataChannelCallback->call([dc](Napi::Env env, std::vector<napi_value> &args) {
+            mOnDataChannelCallback->call([this, dc](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 std::shared_ptr<rtc::DataChannel> dataChannel = dc;

package/src/peer-connection-wrapper.h

@@ -5,9 +5,12 @@
 #include <string>
 #include <variant>
 #include <memory>
+#include <unordered_set>
+
 #include <napi.h>
-#include <napi-thread-safe-callback.hpp>
-#include "rtc/rtc.hpp"
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
 
 class PeerConnectionWrapper : public Napi::ObjectWrap<PeerConnectionWrapper>
 {
@@ -35,21 +38,28 @@ public:
   Napi::Value rtt(const Napi::CallbackInfo &info);
   Napi::Value getSelectedCandidatePair(const Napi::CallbackInfo &info);
 
+  // Close all existing DataChannels
+  static void CloseAll();
+
 private:
   static Napi::FunctionReference constructor;
+  static std::unordered_set<PeerConnectionWrapper*> instances;
+
+  void doClose();
+
   std::string mPeerName;
-  std::shared_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;
+  std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;
 
   // Callback Ptrs
-  std::shared_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnGatheringStateChangeCallback = nullptr;
-  std::shared_ptr<ThreadSafeCallback> mOnDataChannelCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnGatheringStateChangeCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnDataChannelCallback = nullptr;
 
   // Helpers
   std::string candidateTypeToString(const rtc::Candidate::Type &type);
   std::string candidateTransportTypeToString(const rtc::Candidate::TransportType &transportType);
 };
 
-#endif // PEER_CONNECTION_WRAPPER_H
+#endif // PEER_CONNECTION_WRAPPER_H

package/src/rtc-wrapper.cpp

@@ -1,4 +1,9 @@
 #include "rtc-wrapper.h"
+#include "peer-connection-wrapper.h"
+#include "data-channel-wrapper.h"
+
+#include <chrono>
+#include <future>
 
 Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
 {
@@ -69,7 +74,12 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     try
     {
-        rtc::Cleanup();
+        PeerConnectionWrapper::CloseAll();
+        DataChannelWrapper::CloseAll();
+
+        const auto timeout = std::chrono::seconds(10);
+        if(rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
+            throw std::runtime_error("cleanup timeout (possible deadlock)");
     }
     catch (std::exception &ex)
     {

package/src/rtc-wrapper.h

@@ -3,7 +3,9 @@
 
 #include <iostream>
 #include <string>
+
 #include <napi.h>
+
 #include "rtc/rtc.hpp"
 
 class RtcWrapper
@@ -16,4 +18,4 @@ public:
     static void setSctpSettings(const Napi::CallbackInfo &info);
 };
 
-#endif // RTC_WRAPPER_H
+#endif // RTC_WRAPPER_H

package/src/thread-safe-callback.cpp

@@ -0,0 +1,69 @@
+#include "thread-safe-callback.h"
+
+#ifdef LEGACY_NAPI_THREAD_SAFE_CALLBACK
+
+// Nothing to do
+
+#else
+
+const char* ThreadSafeCallback::CancelException::what() const throw()
+{
+    return "ThreadSafeCallback cancelled";
+}
+
+ThreadSafeCallback::ThreadSafeCallback(Napi::Function callback)
+{
+    if (!callback.IsFunction())
+        throw Napi::Error::New(callback.Env(), "Callback must be a function");
+
+    Napi::Env env = callback.Env();
+
+    receiver = Napi::Persistent(static_cast<Napi::Value>(Napi::Object::New(env)));
+    tsfn = tsfn_t::New(env,
+                       std::move(callback),
+                       "ThreadSafeCallback callback",
+                       0, 1, &receiver);
+}
+
+ThreadSafeCallback::~ThreadSafeCallback()
+{
+    tsfn.Abort();
+}
+
+void ThreadSafeCallback::call(arg_func_t argFunc)
+{
+    CallbackData *data = new CallbackData{std::move(argFunc)};
+    if (tsfn.BlockingCall(data) != napi_ok)
+    {
+        delete data;
+        throw std::runtime_error("Failed to call JavaScript callback");
+    }
+}
+
+void ThreadSafeCallback::callbackFunc(Napi::Env env,
+                                      Napi::Function callback,
+                                      Napi::Reference<Napi::Value> *context,
+                                      CallbackData *data)
+{
+    if (!data)
+        return;
+
+    arg_vector_t args;
+    arg_func_t argFunc(std::move(data->argFunc));
+    delete data;
+
+    try
+    {
+        argFunc(env, args);
+    }
+    catch (CancelException &)
+    {
+        return;
+    }
+
+    if (env && callback)
+        callback.Call(context->Value(), args);
+}
+
+#endif
+

package/src/thread-safe-callback.h

@@ -0,0 +1,57 @@
+#ifndef THREAD_SAFE_CALLBACK_H
+#define THREAD_SAFE_CALLBACK_H
+
+#ifdef LEGACY_NAPI_THREAD_SAFE_CALLBACK
+
+#include "napi-thread-safe-callback.hpp"
+
+#else
+
+#include <napi.h>
+
+#include <vector>
+#include <functional>
+
+class ThreadSafeCallback
+{
+public:
+    using arg_vector_t = std::vector<napi_value>;
+    using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
+
+    ThreadSafeCallback(Napi::Function callback);
+    ~ThreadSafeCallback();
+
+    ThreadSafeCallback(const ThreadSafeCallback &) = delete;
+    ThreadSafeCallback(ThreadSafeCallback &&) = delete;
+
+    ThreadSafeCallback& operator=(const ThreadSafeCallback &) = delete;
+    ThreadSafeCallback& operator=(ThreadSafeCallback &&) = delete;
+
+    void call(arg_func_t argFunc);
+
+    class CancelException : public std::exception
+    {
+        const char* what() const throw();
+    };
+
+private:
+    struct CallbackData
+    {
+        arg_func_t argFunc;
+    };
+
+    static void callbackFunc(Napi::Env env,
+                             Napi::Function callback,
+                             Napi::Reference<Napi::Value> *context,
+                             CallbackData *data);
+
+    using tsfn_t = Napi::TypedThreadSafeFunction<Napi::Reference<Napi::Value>, CallbackData, callbackFunc>;
+
+    Napi::Reference<Napi::Value> receiver;
+    tsfn_t tsfn;
+};
+
+#endif // LEGACY_NAPI_THREAD_SAFE_CALLBACK
+
+#endif // THREAD_SAFE_CALLBACK_H
+

package/test/connectivity.js

@@ -96,5 +96,6 @@ setTimeout(() => {
     peer1 = null;
     peer2 = null;
     nodeDataChannel.cleanup();
-    process.exit();
+    // No need for this (>= V0.1.14)
+    // process.exit();
 }, 5 * 1000);

package/test/test.js

@@ -35,115 +35,114 @@ describe('PeerConnection Classes', () => {
 });
 
 
-// describe('P2P', () => {
-//     let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
-//     let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
-//     let dc1 = null;
-//     let dc2 = null;
-
-//     // Mocks
-//     const p1StateMock = jest.fn();
-//     const p1GatheringStateMock = jest.fn();
-//     const p2StateMock = jest.fn();
-//     const p2GatheringStateMock = jest.fn();
-//     const p1SDPMock = jest.fn();
-//     const p1CandidateMock = jest.fn();
-//     const p2SDPMock = jest.fn();
-//     const p2CandidateMock = jest.fn();
-
-//     const p1DCMock = jest.fn();
-//     const p1DCMessageMock = jest.fn();
-//     const p2DCMock = jest.fn();
-//     const p2DCMessageMock = jest.fn();
-
-//     // Set Callbacks
-//     peer1.onStateChange(p1StateMock);
-//     peer1.onGatheringStateChange(p1GatheringStateMock);
-//     peer1.onLocalDescription((sdp, type) => {
-//         p1SDPMock();
-//         peer2.setRemoteDescription(sdp, type);
-//     });
-//     peer1.onLocalCandidate((candidate, mid) => {
-//         p1CandidateMock();
-//         peer2.addRemoteCandidate(candidate, mid);
-//     });
-
-//     // Set Callbacks
-//     peer2.onStateChange(p2StateMock);
-//     peer2.onGatheringStateChange(p2GatheringStateMock);
-//     peer2.onLocalDescription((sdp, type) => {
-//         p2SDPMock();
-//         peer1.setRemoteDescription(sdp, type);
-//     });
-//     peer2.onLocalCandidate((candidate, mid) => {
-//         p2CandidateMock();
-//         peer1.addRemoteCandidate(candidate, mid);
-//     });
-//     peer2.onDataChannel((dc) => {
-//         p2DCMock();
-//         dc2 = dc;
-//         dc2.onMessage((msg) => {
-//             p2DCMessageMock(msg);
-//         });
-//         dc2.sendMessage("Hello From Peer2");
-//     });
-
-//     dc1 = peer1.createDataChannel("test-p2p");
-//     dc1.onOpen(() => {
-//         p1DCMock();
-//         dc1.sendMessage("Hello From Peer1");
-//     });
-//     dc1.onMessage((msg) => {
-//         p1DCMessageMock(msg);
-//     });
-
-//     test('P2P', (done) => {
-//         // Default is 5000 ms but we need more
-//         jest.setTimeout(30000);
-
-//         setTimeout(() => {
-//             dc1.close();
-//             dc2.close();
-//             peer1.close();
-//             peer2.close();
-
-//             // Fee memory 
-//             dc1 = null;
-//             dc2 = null;
-//             peer1 = null;
-//             peer2 = null;
-
-//             // Cleanup Threads
-//             nodeDataChannel.cleanup();
-//         }, 8 * 1000);
-
-//         setTimeout(() => {
-//             // State Callbacks
-//             expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-//             expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-//             expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-//             expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-//             // SDP
-//             expect(p1SDPMock.mock.calls.length).toBe(1);
-//             expect(p2SDPMock.mock.calls.length).toBe(1);
-
-//             // Candidates
-//             expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-//             expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-//             // DataChannel
-//             expect(p1DCMock.mock.calls.length).toBe(1);
-//             expect(p1DCMessageMock.mock.calls.length).toBe(1);
-//             expect(p1DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer2");
-//             expect(p2DCMock.mock.calls.length).toBe(1);
-//             // These 2 tests fails randomly
-//             // Needs investigation ?
-//             // expect(p2DCMessageMock.mock.calls.length).toBe(1);
-//             // expect(p2DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer1");
-
-//             done();
-//         }, 20 * 1000);
-
-//     });
-// });
+describe('P2P', () => {
+    // Default is 5000 ms but we need more
+    jest.setTimeout(30000);
+
+    let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+    let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+    let dc1 = null;
+    let dc2 = null;
+
+    // Mocks
+    const p1StateMock = jest.fn();
+    const p1GatheringStateMock = jest.fn();
+    const p2StateMock = jest.fn();
+    const p2GatheringStateMock = jest.fn();
+    const p1SDPMock = jest.fn();
+    const p1CandidateMock = jest.fn();
+    const p2SDPMock = jest.fn();
+    const p2CandidateMock = jest.fn();
+
+    const p1DCMock = jest.fn();
+    const p1DCMessageMock = jest.fn();
+    const p2DCMock = jest.fn();
+    const p2DCMessageMock = jest.fn();
+
+    // Set Callbacks
+    peer1.onStateChange(p1StateMock);
+    peer1.onGatheringStateChange(p1GatheringStateMock);
+    peer1.onLocalDescription((sdp, type) => {
+        p1SDPMock();
+        peer2.setRemoteDescription(sdp, type);
+    });
+    peer1.onLocalCandidate((candidate, mid) => {
+        p1CandidateMock();
+        peer2.addRemoteCandidate(candidate, mid);
+    });
+
+    // Set Callbacks
+    peer2.onStateChange(p2StateMock);
+    peer2.onGatheringStateChange(p2GatheringStateMock);
+    peer2.onLocalDescription((sdp, type) => {
+        p2SDPMock();
+        peer1.setRemoteDescription(sdp, type);
+    });
+    peer2.onLocalCandidate((candidate, mid) => {
+        p2CandidateMock();
+        peer1.addRemoteCandidate(candidate, mid);
+    });
+    peer2.onDataChannel((dc) => {
+        p2DCMock();
+        dc2 = dc;
+        dc2.onMessage((msg) => {
+            p2DCMessageMock(msg);
+        });
+        dc2.sendMessage("Hello From Peer2");
+    });
+
+    dc1 = peer1.createDataChannel("test-p2p");
+    dc1.onOpen(() => {
+        p1DCMock();
+        dc1.sendMessage("Hello From Peer1");
+    });
+    dc1.onMessage((msg) => {
+        p1DCMessageMock(msg);
+    });
+
+    test('P2P', (done) => {
+        setTimeout(() => {
+            dc1.close();
+            dc2.close();
+            peer1.close();
+            peer2.close();
+
+            // Fee memory 
+            dc1 = null;
+            dc2 = null;
+            peer1 = null;
+            peer2 = null;
+
+            // Cleanup Threads
+            nodeDataChannel.cleanup();
+        }, 10 * 1000);
+
+        setTimeout(() => {
+            // State Callbacks
+            expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+            // SDP
+            expect(p1SDPMock.mock.calls.length).toBe(1);
+            expect(p2SDPMock.mock.calls.length).toBe(1);
+
+            // Candidates
+            expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+            // DataChannel
+            expect(p1DCMock.mock.calls.length).toBe(1);
+            expect(p1DCMessageMock.mock.calls.length).toBe(1);
+            expect(p1DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer2");
+            expect(p2DCMock.mock.calls.length).toBe(1);
+
+            expect(p2DCMessageMock.mock.calls.length).toBe(1);
+            expect(p2DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer1");
+
+            done();
+        }, 12 * 1000);
+
+    });
+});