node-datachannel 0.1.13 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-datachannel",
-  "version": "0.1.13",
+  "version": "0.2.1",
   "description": "libdatachannel node bindings",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -15,17 +15,31 @@
     "build": "cmake-js build",
     "_prebuild": "prebuild --backend cmake-js",
     "clean": "cmake-js clean",
-    "test": "jest --forceExit"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/murat-dogan/node-datachannel.git"
   },
   "keywords": [
-    "libdatachannel"
+    "libdatachannel",
+    "webrtc",
+    "p2p",
+    "peer-to-peer",
+    "datachannel",
+    "data channel"
   ],
-  "author": "Murat Doğan",
-  "license": "GPL-2.0-or-later",
+  "contributors": [
+    {
+      "name": "Murat Doğan",
+      "url": "https://github.com/murat-dogan"
+    },
+    {
+      "name": "Paul-Louis Ageneau",
+      "url": "https://github.com/paullouisageneau"
+    }
+  ],
+  "license": "LGPL",
   "gypfile": true,
   "bugs": {
     "url": "https://github.com/murat-dogan/node-datachannel/issues"
@@ -35,8 +49,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)
 {
@@ -9,21 +17,21 @@ Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
     Napi::Function func = DefineClass(
         env,
         "DataChannel",
-        {InstanceMethod("close", &DataChannelWrapper::close),
-         InstanceMethod("getLabel", &DataChannelWrapper::getLabel),
-         InstanceMethod("sendMessage", &DataChannelWrapper::sendMessage),
-         InstanceMethod("sendMessageBinary", &DataChannelWrapper::sendMessageBinary),
-         InstanceMethod("isOpen", &DataChannelWrapper::isOpen),
-         InstanceMethod("availableAmount", &DataChannelWrapper::availableAmount),
-         InstanceMethod("bufferedAmount", &DataChannelWrapper::bufferedAmount),
-         InstanceMethod("maxMessageSize", &DataChannelWrapper::maxMessageSize),
-         InstanceMethod("setBufferedAmountLowThreshold", &DataChannelWrapper::setBufferedAmountLowThreshold),
-         InstanceMethod("onOpen", &DataChannelWrapper::onOpen),
-         InstanceMethod("onClosed", &DataChannelWrapper::onClosed),
-         InstanceMethod("onError", &DataChannelWrapper::onError),
-         InstanceMethod("onAvailable", &DataChannelWrapper::onAvailable),
-         InstanceMethod("onBufferedAmountLow", &DataChannelWrapper::onBufferedAmountLow),
-         InstanceMethod("onMessage", &DataChannelWrapper::onMessage)});
+        {
+            InstanceMethod("close", &DataChannelWrapper::close),
+            InstanceMethod("getLabel", &DataChannelWrapper::getLabel),
+            InstanceMethod("sendMessage", &DataChannelWrapper::sendMessage),
+            InstanceMethod("sendMessageBinary", &DataChannelWrapper::sendMessageBinary),
+            InstanceMethod("isOpen", &DataChannelWrapper::isOpen),
+            InstanceMethod("bufferedAmount", &DataChannelWrapper::bufferedAmount),
+            InstanceMethod("maxMessageSize", &DataChannelWrapper::maxMessageSize),
+            InstanceMethod("setBufferedAmountLowThreshold", &DataChannelWrapper::setBufferedAmountLowThreshold),
+            InstanceMethod("onOpen", &DataChannelWrapper::onOpen),
+            InstanceMethod("onClosed", &DataChannelWrapper::onClosed),
+            InstanceMethod("onError", &DataChannelWrapper::onError),
+            InstanceMethod("onBufferedAmountLow", &DataChannelWrapper::onBufferedAmountLow),
+            InstanceMethod("onMessage", &DataChannelWrapper::onMessage),
+        });
 
     constructor = Napi::Persistent(func);
     constructor.SuppressDestruct();
@@ -35,14 +43,29 @@ 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();
+            mOnBufferedAmountLowCallback.reset();
+            mOnMessageCallback.reset();
+
             mDataChannelPtr->close();
             mDataChannelPtr.reset();
         }
@@ -56,23 +79,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)
@@ -163,25 +170,6 @@ Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info)
     }
 }
 
-Napi::Value DataChannelWrapper::availableAmount(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
-    if (!mDataChannelPtr)
-    {
-        return Napi::Number::New(info.Env(), 0);
-    }
-
-    try
-    {
-        return Napi::Number::New(info.Env(), mDataChannelPtr->availableAmount());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Number::New(info.Env(), 0);
-    }
-}
-
 Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -260,16 +248,20 @@ 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([&]() {
+    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 = {};
-            });
-    });
+            }); });
 }
 
 void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
@@ -284,16 +276,20 @@ 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([&]() {
+    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 = {};
-            });
-    });
+            }); });
 }
 
 void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
@@ -308,40 +304,20 @@ 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) {
+    mDataChannelPtr->onError([&](const std::string &error)
+                             {
         if (mOnErrorCallback)
-            mOnErrorCallback->call([error](Napi::Env env, std::vector<napi_value> &args) {
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {Napi::String::New(env, error)};
-            });
-    });
-}
+            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();
 
-void DataChannelWrapper::onAvailable(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
-    mOnAvailableCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    mDataChannelPtr->onAvailable([&]() {
-        if (mOnAvailableCallback)
-            mOnAvailableCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
                 // This will run in main thread and needs to construct the
                 // arguments for the call
-                args = {};
-            });
-    });
+                args = {Napi::String::New(env, error)};
+            }); });
 }
 
 void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
@@ -356,16 +332,20 @@ 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([&]() {
+    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 = {};
-            });
-    });
+            }); });
 }
 
 void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
@@ -380,11 +360,16 @@ 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) {
+    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);
@@ -396,6 +381,5 @@ void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
                 {
                     args = {Napi::Buffer<std::byte>::Copy(env, std::get<rtc::binary>(message).data(), std::get<rtc::binary>(message).size())};
                 }
-            });
-    });
-}
+            }); });
+}

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>
 {
@@ -23,7 +26,6 @@ public:
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
   Napi::Value isOpen(const Napi::CallbackInfo &info);
-  Napi::Value availableAmount(const Napi::CallbackInfo &info);
   Napi::Value bufferedAmount(const Napi::CallbackInfo &info);
   Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
   void setBufferedAmountLowThreshold(const Napi::CallbackInfo &info);
@@ -32,21 +34,26 @@ public:
   void onOpen(const Napi::CallbackInfo &info);
   void onClosed(const Napi::CallbackInfo &info);
   void onError(const Napi::CallbackInfo &info);
-  void onAvailable(const Napi::CallbackInfo &info);
   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> mOnBufferedAmountLowCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
 };
 
-#endif // DATA_CHANNEL_WRAPPER_H
+#endif // DATA_CHANNEL_WRAPPER_H

package/src/main.cpp

@@ -2,10 +2,18 @@
 #include "rtc-wrapper.h"
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
+#include "media-rtcpreceivingsession-wrapper.h"
+#include "media-track-wrapper.h"
+#include "media-video-wrapper.h"
+#include "media-audio-wrapper.h"
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports)
 {
     RtcWrapper::Init(env, exports);
+    RtcpReceivingSessionWrapper::Init(env,exports);
+    TrackWrapper::Init(env,exports);
+    VideoWrapper::Init(env,exports);
+    AudioWrapper::Init(env,exports);
     DataChannelWrapper::Init(env, exports);
     PeerConnectionWrapper::Init(env, exports);
     return exports;