node-datachannel 0.1.12 → 0.2.0

package/src/peer-connection-wrapper.cpp

@@ -1,8 +1,20 @@
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
+#include "media-track-wrapper.h"
+#include "media-video-wrapper.h"
+#include "media-audio-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)
 {
@@ -11,19 +23,26 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
     Napi::Function func = DefineClass(
         env,
         "PeerConnection",
-        {InstanceMethod("close", &PeerConnectionWrapper::close),
-         InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
-         InstanceMethod("addRemoteCandidate", &PeerConnectionWrapper::addRemoteCandidate),
-         InstanceMethod("createDataChannel", &PeerConnectionWrapper::createDataChannel),
-         InstanceMethod("onLocalDescription", &PeerConnectionWrapper::onLocalDescription),
-         InstanceMethod("onLocalCandidate", &PeerConnectionWrapper::onLocalCandidate),
-         InstanceMethod("onStateChange", &PeerConnectionWrapper::onStateChange),
-         InstanceMethod("onGatheringStateChange", &PeerConnectionWrapper::onGatheringStateChange),
-         InstanceMethod("onDataChannel", &PeerConnectionWrapper::onDataChannel),
-         InstanceMethod("bytesSent", &PeerConnectionWrapper::bytesSent),
-         InstanceMethod("bytesReceived", &PeerConnectionWrapper::bytesReceived),
-         InstanceMethod("rtt", &PeerConnectionWrapper::rtt),
-         InstanceMethod("getSelectedCandidatePair", &PeerConnectionWrapper::getSelectedCandidatePair)});
+        {
+            InstanceMethod("close", &PeerConnectionWrapper::close),
+            InstanceMethod("setLocalDescription", &PeerConnectionWrapper::setLocalDescription),
+            InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
+            InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
+            InstanceMethod("addRemoteCandidate", &PeerConnectionWrapper::addRemoteCandidate),
+            InstanceMethod("createDataChannel", &PeerConnectionWrapper::createDataChannel),
+            InstanceMethod("addTrack", &PeerConnectionWrapper::addTrack),
+            InstanceMethod("hasMedia", &PeerConnectionWrapper::hasMedia),
+            InstanceMethod("onLocalDescription", &PeerConnectionWrapper::onLocalDescription),
+            InstanceMethod("onLocalCandidate", &PeerConnectionWrapper::onLocalCandidate),
+            InstanceMethod("onStateChange", &PeerConnectionWrapper::onStateChange),
+            InstanceMethod("onGatheringStateChange", &PeerConnectionWrapper::onGatheringStateChange),
+            InstanceMethod("onDataChannel", &PeerConnectionWrapper::onDataChannel),
+            InstanceMethod("onTrack", &PeerConnectionWrapper::onTrack),
+            InstanceMethod("bytesSent", &PeerConnectionWrapper::bytesSent),
+            InstanceMethod("bytesReceived", &PeerConnectionWrapper::bytesReceived),
+            InstanceMethod("rtt", &PeerConnectionWrapper::rtt),
+            InstanceMethod("getSelectedCandidatePair", &PeerConnectionWrapper::getSelectedCandidatePair),
+        });
 
     constructor = Napi::Persistent(func);
     constructor.SuppressDestruct();
@@ -166,9 +185,9 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
             return;
         }
         std::string strPolicy = config.Get("iceTransportPolicy").As<Napi::String>().ToString();
-        if(strPolicy == "all")
+        if (strPolicy == "all")
             rtcConfig.iceTransportPolicy = rtc::TransportPolicy::All;
-        else if(strPolicy == "relay")
+        else if (strPolicy == "relay")
             rtcConfig.iceTransportPolicy = rtc::TransportPolicy::Relay;
         else
         {
@@ -180,21 +199,37 @@ 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();
+            mOnTrackCallback.reset();
+
             mRtcPeerConnPtr->close();
             mRtcPeerConnPtr.reset();
         }
@@ -207,6 +242,11 @@ PeerConnectionWrapper::~PeerConnectionWrapper()
 }
 
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
+{
+    doClose();
+}
+
+void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     if (!mRtcPeerConnPtr)
@@ -215,16 +255,31 @@ void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
         return;
     }
 
-    try
-    {
-        mRtcPeerConnPtr->close();
-        mRtcPeerConnPtr.reset();
-    }
-    catch (std::exception &ex)
+    int length = info.Length();
+
+    rtc::Description::Type type = rtc::Description::Type::Unspec;
+
+    // optional
+    if (length > 0)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while closing peerConnection# ") + ex.what()).ThrowAsJavaScriptException();
-        return;
+        if (!info[0].IsString())
+        {
+            Napi::TypeError::New(env, "type (String) expected").ThrowAsJavaScriptException();
+            return;
+        }
+        std::string typeStr = info[0].As<Napi::String>().ToString();
+
+        if (typeStr == "Answer")
+            type = rtc::Description::Type::Answer;
+        if (typeStr == "Offer")
+            type = rtc::Description::Type::Offer;
+        if (typeStr == "Pranswer")
+            type = rtc::Description::Type::Pranswer;
+        if (typeStr == "Rollback")
+            type = rtc::Description::Type::Rollback;
     }
+
+    mRtcPeerConnPtr->setLocalDescription(type);
 }
 
 void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
@@ -258,6 +313,17 @@ void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
     }
 }
 
+Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::optional<rtc::Description> desc = mRtcPeerConnPtr->localDescription();
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("type", desc->typeString());
+    obj.Set("sdp", desc.value());
+    return obj;
+}
+
 void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -420,7 +486,7 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
             init.reliability.unordered = !initConfig.Get("ordered").As<Napi::Boolean>();
         }
 
-        if(initConfig.Get("maxPacketLifeTime").IsNumber() && initConfig.Get("maxRetransmits").IsNumber())
+        if (initConfig.Get("maxPacketLifeTime").IsNumber() && initConfig.Get("maxRetransmits").IsNumber())
         {
             Napi::TypeError::New(env, "Wrong DataChannel Init Config, maxPacketLifeTime and maxRetransmits are exclusive").ThrowAsJavaScriptException();
             return info.Env().Null();
@@ -468,18 +534,22 @@ 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) {
+    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 = {
                     Napi::String::New(env, std::string(sdp)),
                     Napi::String::New(env, sdp.typeString())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
@@ -494,18 +564,22 @@ 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) {
+    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 = {
                     Napi::String::New(env, std::string(candidate)),
                     Napi::String::New(env, candidate.mid())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
@@ -520,18 +594,22 @@ 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) {
+    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;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &info)
@@ -546,18 +624,22 @@ 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) {
+    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;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
@@ -572,18 +654,22 @@ 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) {
+    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;
                 auto instance = DataChannelWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::DataChannel>>::New(env, &dataChannel)});
                 args = {instance};
-            });
-    });
+            }); });
 }
 
 Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
@@ -718,3 +804,85 @@ std::string PeerConnectionWrapper::candidateTransportTypeToString(const rtc::Can
         return "unknown";
     }
 }
+
+Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (length < 1 || !info[0].IsObject())
+    {
+        Napi::TypeError::New(env, "Media class instance expected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        Napi::Object obj = info[0].As<Napi::Object>();
+        if (obj.Get("media-type-video").IsBoolean())
+        {
+            VideoWrapper *videoPtr = Napi::ObjectWrap<VideoWrapper>::Unwrap(obj);
+            std::shared_ptr<rtc::Track> track = mRtcPeerConnPtr->addTrack(videoPtr->getVideoInstance());
+            auto instance = TrackWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::Track>>::New(info.Env(), &track)});
+            return instance;
+        }
+
+        if (obj.Get("media-type-audio").IsBoolean())
+        {
+            AudioWrapper *audioPtr = Napi::ObjectWrap<AudioWrapper>::Unwrap(obj);
+            std::shared_ptr<rtc::Track> track = mRtcPeerConnPtr->addTrack(audioPtr->getAudioInstance());
+            auto instance = TrackWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::Track>>::New(info.Env(), &track)});
+            return instance;
+        }
+
+          Napi::Error::New(env, std::string("Unknown media type")).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnTrackCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mRtcPeerConnPtr->onTrack([&](std::shared_ptr<rtc::Track> track)
+                             {
+        if (mOnTrackCallback)
+            mOnTrackCallback->call([this, track](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::Track> newTrack = track;
+                auto instance = TrackWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::Track>>::New(env, &newTrack)});
+                args = {instance};
+            }); });
+}
+
+Napi::Value PeerConnectionWrapper::hasMedia(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, mRtcPeerConnPtr->hasMedia());
+}

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>
 {
@@ -18,9 +21,13 @@ public:
 
   // Functions
   void close(const Napi::CallbackInfo &info);
+  void setLocalDescription(const Napi::CallbackInfo &info);
   void setRemoteDescription(const Napi::CallbackInfo &info);
+  Napi::Value localDescription(const Napi::CallbackInfo &info);
   void addRemoteCandidate(const Napi::CallbackInfo &info);
   Napi::Value createDataChannel(const Napi::CallbackInfo &info);
+  Napi::Value addTrack(const Napi::CallbackInfo &info);  
+  Napi::Value hasMedia(const Napi::CallbackInfo &info); 
 
   // Callbacks
   void onLocalDescription(const Napi::CallbackInfo &info);
@@ -28,6 +35,7 @@ public:
   void onStateChange(const Napi::CallbackInfo &info);
   void onGatheringStateChange(const Napi::CallbackInfo &info);
   void onDataChannel(const Napi::CallbackInfo &info);
+  void onTrack(const Napi::CallbackInfo &info);
 
   // Stats
   Napi::Value bytesSent(const Napi::CallbackInfo &info);
@@ -35,21 +43,29 @@ 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;
+  std::unique_ptr<ThreadSafeCallback> mOnTrackCallback = 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,10 @@
 #include "rtc-wrapper.h"
+#include "peer-connection-wrapper.h"
+#include "data-channel-wrapper.h"
+#include "media-track-wrapper.h"
+
+#include <chrono>
+#include <future>
 
 Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
 {
@@ -69,7 +75,13 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     try
     {
-        rtc::Cleanup();
+        PeerConnectionWrapper::CloseAll();
+        DataChannelWrapper::CloseAll();
+        TrackWrapper::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);