node-datachannel 0.2.4 → 0.3.2

package/src/data-channel-wrapper.h

@@ -23,6 +23,8 @@ public:
   // Functions
   void close(const Napi::CallbackInfo &info);
   Napi::Value getLabel(const Napi::CallbackInfo &info);
+  Napi::Value getId(const Napi::CallbackInfo &info);
+  Napi::Value getProtocol(const Napi::CallbackInfo &info);
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
   Napi::Value isOpen(const Napi::CallbackInfo &info);

package/src/media-audio-wrapper.cpp

@@ -157,15 +157,15 @@ Napi::Value AudioWrapper::generateSdp(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
-    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString())
+    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsNumber())
     {
-        Napi::TypeError::New(env, "We expect (String, String, String) as param").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "We expect (String, String, Number) as param").ThrowAsJavaScriptException();
         return Napi::String::New(env, "");
     }
 
     std::string eol = info[0].As<Napi::String>().ToString();
     std::string addr = info[1].As<Napi::String>().ToString();
-    std::string port = info[2].As<Napi::String>().ToString();
+    uint16_t port = info[2].As<Napi::Number>().Uint32Value();
 
     return Napi::String::New(env, mAudioPtr->generateSdp(eol, addr, port));
 }
@@ -398,7 +398,7 @@ void AudioWrapper::setBitrate(const Napi::CallbackInfo &info)
 Napi::Value AudioWrapper::getBitrate(const Napi::CallbackInfo &info)
 {
 
-    return Napi::Number::New(info.Env(), mAudioPtr->getBitrate());
+    return Napi::Number::New(info.Env(), mAudioPtr->bitrate());
 }
 
 Napi::Value AudioWrapper::hasPayloadType(const Napi::CallbackInfo &info)
@@ -432,7 +432,7 @@ void AudioWrapper::addRTXCodec(const Napi::CallbackInfo &info)
     unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
     unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
 
-    mAudioPtr->addRTXCodec(payloadType, originalPayloadType, clockRate);
+    mAudioPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }
 
 void AudioWrapper::addRTPMap(const Napi::CallbackInfo &info)

package/src/media-track-wrapper.cpp

@@ -22,6 +22,7 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
         {
             InstanceMethod("direction", &TrackWrapper::direction),
             InstanceMethod("mid", &TrackWrapper::mid),
+            InstanceMethod("type", &TrackWrapper::type),
             InstanceMethod("close", &TrackWrapper::close),
             InstanceMethod("sendMessage", &TrackWrapper::sendMessage),
             InstanceMethod("sendMessageBinary", &TrackWrapper::sendMessageBinary),
@@ -57,26 +58,26 @@ TrackWrapper::~TrackWrapper()
 
 void TrackWrapper::doClose()
 {
-    instances.erase(this);
-
     if (mTrackPtr)
     {
         try
         {
-            mOnOpenCallback.reset();
-            mOnClosedCallback.reset();
-            mOnErrorCallback.reset();
-            mOnMessageCallback.reset();
-
             mTrackPtr->close();
             mTrackPtr.reset();
         }
         catch (std::exception &ex)
         {
-            std::cout << std::string("libdatachannel error while closing track# ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing track: ") + ex.what() << std::endl;
             return;
         }
     }
+
+    mOnOpenCallback.reset();
+    mOnClosedCallback.reset();
+    mOnErrorCallback.reset();
+    mOnMessageCallback.reset();
+
+    instances.erase(this);
 }
 
 void TrackWrapper::close(const Napi::CallbackInfo &info)
@@ -86,21 +87,45 @@ void TrackWrapper::close(const Napi::CallbackInfo &info)
 
 Napi::Value TrackWrapper::direction(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "direction() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::String::New(env, directionToStr(mTrackPtr->direction()));
 }
 
 Napi::Value TrackWrapper::mid(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "mid() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::String::New(env, mTrackPtr->mid());
 }
 
+Napi::Value TrackWrapper::type(const Napi::CallbackInfo &info)
+{
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "type() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    Napi::Env env = info.Env();
+    return Napi::String::New(env, mTrackPtr->description().type());
+}
+
 Napi::Value TrackWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessage() called on destroyed track").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -120,7 +145,7 @@ Napi::Value TrackWrapper::sendMessage(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending track msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending track message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -129,7 +154,7 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessageBinary() called on destroyed track").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -149,7 +174,7 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending track msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending track message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -157,18 +182,31 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
 Napi::Value TrackWrapper::isOpen(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
+    if (!mTrackPtr)
+    {
+        return Napi::Boolean::New(env, false);
+    }
+
     return Napi::Boolean::New(env, mTrackPtr->isOpen());
 }
 
 Napi::Value TrackWrapper::isClosed(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
+    if (!mTrackPtr)
+    {
+        return Napi::Boolean::New(env, true);
+    }
+
     return Napi::Boolean::New(env, mTrackPtr->isClosed());
 }
 
 Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mTrackPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -180,13 +218,19 @@ Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
 
 Napi::Value TrackWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "requestKeyframe() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::Boolean::New(env, mTrackPtr->requestKeyframe());
 }
@@ -195,7 +239,7 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "setMediaHandler() called on destroyed track").ThrowAsJavaScriptException();
         return;
     }
 
@@ -204,7 +248,7 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 
     if (length < 1 || !info[0].IsObject())
     {
-        Napi::TypeError::New(env, "Mediahandler class instance expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "MediaHandler class instance expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -214,6 +258,12 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onOpen() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -226,11 +276,10 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onOpen([&]()
-                      {
+    mTrackPtr->onOpen([&]() {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the track is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -242,6 +291,12 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onClosed() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -254,13 +309,10 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onClosed([&]()
-                        {
+    mTrackPtr->onClosed([&]() {
         if (mOnClosedCallback)
             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();
+                // Do not check if the data channel has been closed here
 
                 // This will run in main thread and needs to construct the
                 // arguments for the call
@@ -270,6 +322,12 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onError(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onError() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -282,11 +340,10 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onError([&](const std::string &error)
-                       {
+    mTrackPtr->onError([&](const std::string &error) {
         if (mOnErrorCallback)
             mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the track is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -298,6 +355,12 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onMessage() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -310,24 +373,19 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onMessage([&](const std::variant<rtc::binary, std::string> &message)
-                         {
+    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
         if (mOnMessageCallback)
-            mOnMessageCallback->call([this, message](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+            mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the track 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);
-                if (std::holds_alternative<std::string>(message))
-                {
-                    args = {Napi::String::New(env, std::get<std::string>(message))};
-                }
-                else
+                if (std::holds_alternative<rtc::binary>(message)) // Track will always receive messages as binary
                 {
-                    args = {Napi::Buffer<std::byte>::Copy(env, std::get<rtc::binary>(message).data(), std::get<rtc::binary>(message).size())};
+                    auto bin = std::get<rtc::binary>(std::move(message));
+                    args = {Napi::Buffer<std::byte>::Copy(env, bin.data(), bin.size())};
                 }
             }); });
-}
+}

package/src/media-track-wrapper.h

@@ -23,6 +23,7 @@ public:
   // Functions
   Napi::Value direction(const Napi::CallbackInfo &info);
   Napi::Value mid(const Napi::CallbackInfo &info);
+  Napi::Value type(const Napi::CallbackInfo &info);
   void close(const Napi::CallbackInfo &info);
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);

package/src/media-video-wrapper.cpp

@@ -190,15 +190,15 @@ Napi::Value VideoWrapper::generateSdp(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
-    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString())
+    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsNumber())
     {
-        Napi::TypeError::New(env, "We expect (String, String, String) as param").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "We expect (String, String, Number) as param").ThrowAsJavaScriptException();
         return Napi::String::New(env, "");
     }
 
     std::string eol = info[0].As<Napi::String>().ToString();
     std::string addr = info[1].As<Napi::String>().ToString();
-    std::string port = info[2].As<Napi::String>().ToString();
+    uint16_t port = info[2].As<Napi::Number>().Uint32Value();
 
     return Napi::String::New(env, mVideoPtr->generateSdp(eol, addr, port));
 }
@@ -431,7 +431,7 @@ void VideoWrapper::setBitrate(const Napi::CallbackInfo &info)
 Napi::Value VideoWrapper::getBitrate(const Napi::CallbackInfo &info)
 {
 
-    return Napi::Number::New(info.Env(), mVideoPtr->getBitrate());
+    return Napi::Number::New(info.Env(), mVideoPtr->bitrate());
 }
 
 Napi::Value VideoWrapper::hasPayloadType(const Napi::CallbackInfo &info)
@@ -465,7 +465,7 @@ void VideoWrapper::addRTXCodec(const Napi::CallbackInfo &info)
     unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
     unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
 
-    mVideoPtr->addRTXCodec(payloadType, originalPayloadType, clockRate);
+    mVideoPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }
 
 void VideoWrapper::addRTPMap(const Napi::CallbackInfo &info)