node-datachannel 0.3.1 → 0.3.2

package/src/media-track-wrapper.cpp

@@ -46,26 +46,8 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 
 TrackWrapper::TrackWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<TrackWrapper>(info)
 {
-    mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());    
+    mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());
 
-    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();
-
-                cleanCbsAndEraseInstance();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-            }); 
-            else {
-             cleanCbsAndEraseInstance();
-         } });
-    
     instances.insert(this);
 }
 
@@ -81,24 +63,21 @@ void TrackWrapper::doClose()
         try
         {
             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;
         }
     }
-}
 
-void TrackWrapper::cleanCbsAndEraseInstance()
-{
     mOnOpenCallback.reset();
     mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnMessageCallback.reset();
 
     instances.erase(this);
-    mTrackPtr.reset();
 }
 
 void TrackWrapper::close(const Napi::CallbackInfo &info)
@@ -108,18 +87,36 @@ 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());
 }
@@ -128,7 +125,7 @@ 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();
     }
 
@@ -148,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);
     }
 }
@@ -157,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();
     }
 
@@ -177,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);
     }
 }
@@ -185,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);
@@ -208,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());
 }
@@ -223,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;
     }
 
@@ -232,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;
     }
 
@@ -242,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();
 
@@ -254,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();
 
@@ -270,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();
 
@@ -282,11 +309,25 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    // Object cb call moved to the constructor    
+    mTrackPtr->onClosed([&]() {
+        if (mOnClosedCallback)
+            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // 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
+                args = {};
+            }); });
 }
 
 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();
 
@@ -299,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();
 
@@ -315,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();
 
@@ -327,26 +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))
-                {
-                    // Track will always send message as binary
-                    // So this code is not needed actually 
-                    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

@@ -46,7 +46,6 @@ private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
-  void cleanCbsAndEraseInstance();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;