node-datachannel 0.1.14-dev → 0.2.2

package/src/peer-connection-wrapper.cpp

@@ -1,15 +1,18 @@
 #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;
+std::unordered_set<PeerConnectionWrapper *> PeerConnectionWrapper::instances;
 
 void PeerConnectionWrapper::CloseAll()
 {
     auto copy(instances);
-    for(auto inst : copy)
+    for (auto inst : copy)
         inst->doClose();
 }
 
@@ -20,19 +23,30 @@ 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("state", &PeerConnectionWrapper::state),
+            InstanceMethod("signalingState", &PeerConnectionWrapper::signalingState),
+            InstanceMethod("gatheringState", &PeerConnectionWrapper::gatheringState),
+            InstanceMethod("onLocalDescription", &PeerConnectionWrapper::onLocalDescription),
+            InstanceMethod("onLocalCandidate", &PeerConnectionWrapper::onLocalCandidate),
+            InstanceMethod("onStateChange", &PeerConnectionWrapper::onStateChange),
+            InstanceMethod("onSignalingStateChange", &PeerConnectionWrapper::onSignalingStateChange),
+            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();
@@ -175,9 +189,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
         {
@@ -218,6 +232,7 @@ void PeerConnectionWrapper::doClose()
             mOnStateChangeCallback.reset();
             mOnGatheringStateChangeCallback.reset();
             mOnDataChannelCallback.reset();
+            mOnTrackCallback.reset();
 
             mRtcPeerConnPtr->close();
             mRtcPeerConnPtr.reset();
@@ -235,6 +250,42 @@ void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
     doClose();
 }
 
+void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        return;
+    }
+
+    int length = info.Length();
+
+    rtc::Description::Type type = rtc::Description::Type::Unspec;
+
+    // optional
+    if (length > 0)
+    {
+        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)
 {
     Napi::Env env = info.Env();
@@ -266,6 +317,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();
@@ -428,7 +490,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();
@@ -490,8 +552,7 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
                 args = {
                     Napi::String::New(env, std::string(sdp)),
                     Napi::String::New(env, sdp.typeString())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
@@ -520,8 +581,7 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
                 args = {
                     Napi::String::New(env, std::string(candidate)),
                     Napi::String::New(env, candidate.mid())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
@@ -550,8 +610,36 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
                 std::ostringstream stream;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
-            });
-    });
+            }); });
+}
+
+void PeerConnectionWrapper::onSignalingStateChange(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
+    mOnSignalingStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mRtcPeerConnPtr->onSignalingStateChange([&](rtc::PeerConnection::SignalingState state) {
+        if (mOnSignalingStateChangeCallback)
+            mOnSignalingStateChangeCallback->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)
@@ -580,8 +668,7 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
                 std::ostringstream stream;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
-            });
-    });
+            }); });
 }
 
 void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
@@ -598,7 +685,8 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
     // Callback
     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([this, dc](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
@@ -610,8 +698,7 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
                 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)
@@ -746,3 +833,109 @@ 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());
+}
+
+Napi::Value PeerConnectionWrapper::state(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::ostringstream stream;
+    stream << mRtcPeerConnPtr->state();
+    return Napi::String::New(env, stream.str());
+}
+
+Napi::Value PeerConnectionWrapper::signalingState(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::ostringstream stream;
+    stream << mRtcPeerConnPtr->signalingState();
+    return Napi::String::New(env, stream.str());
+}
+
+Napi::Value PeerConnectionWrapper::gatheringState(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::ostringstream stream;
+    stream << mRtcPeerConnPtr->gatheringState();
+    return Napi::String::New(env, stream.str());
+}

package/src/peer-connection-wrapper.h

@@ -21,16 +21,25 @@ 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);
+  Napi::Value state(const Napi::CallbackInfo &info);
+  Napi::Value signalingState(const Napi::CallbackInfo &info);
+  Napi::Value gatheringState(const Napi::CallbackInfo &info);
 
   // Callbacks
   void onLocalDescription(const Napi::CallbackInfo &info);
   void onLocalCandidate(const Napi::CallbackInfo &info);
   void onStateChange(const Napi::CallbackInfo &info);
+  void onSignalingStateChange(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);
@@ -43,7 +52,7 @@ public:
 
 private:
   static Napi::FunctionReference constructor;
-  static std::unordered_set<PeerConnectionWrapper*> instances;
+  static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
 
@@ -54,8 +63,10 @@ private:
   std::unique_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnSignalingStateChangeCallback = 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);

package/src/rtc-wrapper.cpp

@@ -1,6 +1,7 @@
 #include "rtc-wrapper.h"
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
+#include "media-track-wrapper.h"
 
 #include <chrono>
 #include <future>
@@ -76,6 +77,7 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
     {
         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)