node-datachannel 0.4.3 → 0.5.0-dev

package/src/peer-connection-wrapper.cpp

@@ -4,6 +4,8 @@
 #include "media-video-wrapper.h"
 #include "media-audio-wrapper.h"
 
+#include "plog/Log.h"
+
 #include <cctype>
 #include <sstream>
 
@@ -12,6 +14,7 @@ std::unordered_set<PeerConnectionWrapper *> PeerConnectionWrapper::instances;
 
 void PeerConnectionWrapper::CloseAll()
 {
+    PLOG_DEBUG << "CloseAll() called";
     auto copy(instances);
     for (auto inst : copy)
         inst->doClose();
@@ -19,6 +22,7 @@ void PeerConnectionWrapper::CloseAll()
 
 void PeerConnectionWrapper::ResetCallbacksAll()
 {
+    PLOG_DEBUG << "ResetCallbacksAll() called";
     auto copy(instances);
     for (auto inst : copy)
         inst->doResetCallbacks();
@@ -37,16 +41,19 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("setLocalDescription", &PeerConnectionWrapper::setLocalDescription),
             InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
             InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
+            InstanceMethod("remoteDescription", &PeerConnectionWrapper::remoteDescription),
             InstanceMethod("addRemoteCandidate", &PeerConnectionWrapper::addRemoteCandidate),
             InstanceMethod("createDataChannel", &PeerConnectionWrapper::createDataChannel),
             InstanceMethod("addTrack", &PeerConnectionWrapper::addTrack),
             InstanceMethod("hasMedia", &PeerConnectionWrapper::hasMedia),
             InstanceMethod("state", &PeerConnectionWrapper::state),
+            InstanceMethod("iceState", &PeerConnectionWrapper::iceState),
             InstanceMethod("signalingState", &PeerConnectionWrapper::signalingState),
             InstanceMethod("gatheringState", &PeerConnectionWrapper::gatheringState),
             InstanceMethod("onLocalDescription", &PeerConnectionWrapper::onLocalDescription),
             InstanceMethod("onLocalCandidate", &PeerConnectionWrapper::onLocalCandidate),
             InstanceMethod("onStateChange", &PeerConnectionWrapper::onStateChange),
+            InstanceMethod("onIceStateChange", &PeerConnectionWrapper::onIceStateChange),
             InstanceMethod("onSignalingStateChange", &PeerConnectionWrapper::onSignalingStateChange),
             InstanceMethod("onGatheringStateChange", &PeerConnectionWrapper::onGatheringStateChange),
             InstanceMethod("onDataChannel", &PeerConnectionWrapper::onDataChannel),
@@ -66,6 +73,7 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
 
 PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<PeerConnectionWrapper>(info)
 {
+    PLOG_DEBUG << "Constructor called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -172,7 +180,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     }
 
     // bind address, libjuice only
-    if(config.Get("bindAddress").IsString())
+    if (config.Get("bindAddress").IsString())
         rtcConfig.bindAddress = config.Get("bindAddress").As<Napi::String>().ToString();
 
     // Port Ranges
@@ -228,6 +236,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // Create peer-connection
     try
     {
+        PLOG_DEBUG << "Creating a new peer";
         mRtcPeerConnPtr = std::make_unique<rtc::PeerConnection>(rtcConfig);
     }
     catch (std::exception &ex)
@@ -241,13 +250,16 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
 
 PeerConnectionWrapper::~PeerConnectionWrapper()
 {
+    PLOG_DEBUG << "Destructor called";
     doDestroy();
 }
 
 void PeerConnectionWrapper::doClose()
 {
+    PLOG_DEBUG << "doClose() called";
     if (mRtcPeerConnPtr)
     {
+        PLOG_DEBUG << "Closing...";
         try
         {
             mRtcPeerConnPtr->close();
@@ -263,20 +275,24 @@ void PeerConnectionWrapper::doClose()
 
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "close() called";
     doClose();
 }
 
 void PeerConnectionWrapper::doDestroy()
 {
+    PLOG_DEBUG << "doDestroy() called";
     doClose();
     doResetCallbacks();
 }
 
 void PeerConnectionWrapper::doResetCallbacks()
 {
+    PLOG_DEBUG << "doResetCallbacks() called";
     mOnLocalDescriptionCallback.reset();
     mOnLocalCandidateCallback.reset();
     mOnStateChangeCallback.reset();
+    mOnSignalingStateChangeCallback.reset();
     mOnGatheringStateChangeCallback.reset();
     mOnDataChannelCallback.reset();
     mOnTrackCallback.reset();
@@ -286,11 +302,13 @@ void PeerConnectionWrapper::doResetCallbacks()
 
 void PeerConnectionWrapper::destroy(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "destroy() called";
     doDestroy();
 }
 
 void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "setLocalDescription() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -313,7 +331,7 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
         std::string typeStr = info[0].As<Napi::String>().ToString();
 
         // Accept uppercase first letter for backward compatibility
-        if(typeStr.size() > 0)
+        if (typeStr.size() > 0)
             typeStr[0] = std::tolower(typeStr[0]);
 
         if (typeStr == "answer")
@@ -331,6 +349,7 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 
 void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "setRemoteDescription() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -363,12 +382,32 @@ void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "localDescription() called";
     Napi::Env env = info.Env();
 
     std::optional<rtc::Description> desc = mRtcPeerConnPtr ? mRtcPeerConnPtr->localDescription() : std::nullopt;
 
     // Return JS null if no description
-    if (!desc.has_value()) {
+    if (!desc.has_value())
+    {
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("type", desc->typeString());
+    obj.Set("sdp", desc.value());
+    return obj;
+}
+
+Napi::Value PeerConnectionWrapper::remoteDescription(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    std::optional<rtc::Description> desc = mRtcPeerConnPtr ? mRtcPeerConnPtr->remoteDescription() : std::nullopt;
+
+    // Return JS null if no description
+    if (!desc.has_value())
+    {
         return env.Null();
     }
 
@@ -380,6 +419,7 @@ Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &in
 
 void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "addRemoteCandidate() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -410,6 +450,7 @@ void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "createDataChannel() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -568,6 +609,7 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
         std::string label = info[0].As<Napi::String>().ToString();
         std::shared_ptr<rtc::DataChannel> dataChannel = mRtcPeerConnPtr->createDataChannel(label, std::move(init));
         auto instance = DataChannelWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::DataChannel>>::New(info.Env(), &dataChannel)});
+        PLOG_DEBUG << "Data Channel created. Label: " << label;
         return instance;
     }
     catch (std::exception &ex)
@@ -579,6 +621,7 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
 
 void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onLocalDescription() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -597,9 +640,12 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalDescriptionCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalDescription([&](rtc::Description sdp) {
+    mRtcPeerConnPtr->onLocalDescription([&](rtc::Description sdp)
+                                        {
+        PLOG_DEBUG << "onLocalDescription cb received from rtc";
         if (mOnLocalDescriptionCallback)
             mOnLocalDescriptionCallback->call([this, sdp = std::move(sdp)](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnLocalDescriptionCallback call(1)";
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -609,11 +655,13 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
                 args = {
                     Napi::String::New(env, std::string(sdp)),
                     Napi::String::New(env, sdp.typeString())};
+                PLOG_DEBUG << "mOnLocalDescriptionCallback call(2)";
             }); });
 }
 
 void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onLocalCandidate() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -632,9 +680,12 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalCandidateCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalCandidate([&](rtc::Candidate cand) {
+    mRtcPeerConnPtr->onLocalCandidate([&](rtc::Candidate cand)
+                                      {
+        PLOG_DEBUG << "onLocalCandidate cb received from rtc";
         if (mOnLocalCandidateCallback)
             mOnLocalCandidateCallback->call([this, cand = std::move(cand)](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnLocalCandidateCallback call(1)";
                  // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -644,11 +695,13 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
                 args = {
                     Napi::String::New(env, std::string(cand)),
                     Napi::String::New(env, cand.mid())};
+                PLOG_DEBUG << "mOnLocalCandidateCallback call(2)";
             }); });
 }
 
 void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onStateChange() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -667,9 +720,12 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     // Callback
     mOnStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state) {
+    mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state)
+                                   {
+        PLOG_DEBUG << "onStateChange cb received from rtc";
         if (mOnStateChangeCallback)
             mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnStateChangeCallback call(1)";
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -678,11 +734,52 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
                 std::ostringstream stream;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
+                PLOG_DEBUG << "mOnStateChangeCallback call(2)";
+            }); });
+}
+
+void PeerConnectionWrapper::onIceStateChange(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "onIceStateChange() called";
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onIceStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnIceStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mRtcPeerConnPtr->onIceStateChange([&](rtc::PeerConnection::IceState state)
+                                      {
+        PLOG_DEBUG << "onIceStateChange cb received from rtc";
+        if (mOnIceStateChangeCallback)
+            mOnIceStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnIceStateChangeCallback call(1)";
+                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())};
+                PLOG_DEBUG << "mOnIceStateChangeCallback call(2)";
             }); });
 }
 
 void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onSignalingStateChange() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -701,9 +798,12 @@ void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &inf
     // Callback
     mOnSignalingStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onSignalingStateChange([&](rtc::PeerConnection::SignalingState state) {
+    mRtcPeerConnPtr->onSignalingStateChange([&](rtc::PeerConnection::SignalingState state)
+                                            {
+        PLOG_DEBUG << "onSignalingStateChange cb received from rtc";
         if (mOnSignalingStateChangeCallback)
             mOnSignalingStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnSignalingStateChangeCallback call(1)";
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -713,11 +813,13 @@ void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &inf
                 std::ostringstream stream;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
+                PLOG_DEBUG << "mOnSignalingStateChangeCallback call(2)";
             }); });
 }
 
 void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onGatheringStateChange() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -736,9 +838,12 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
     // Callback
     mOnGatheringStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onGatheringStateChange([&](rtc::PeerConnection::GatheringState state) {
+    mRtcPeerConnPtr->onGatheringStateChange([&](rtc::PeerConnection::GatheringState state)
+                                            {
+        PLOG_DEBUG << "onGatheringStateChange cb received from rtc";
         if (mOnGatheringStateChangeCallback)
             mOnGatheringStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnGatheringStateChangeCallback call(1)";
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -748,11 +853,13 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
                 std::ostringstream stream;
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
+                PLOG_DEBUG << "mOnGatheringStateChangeCallback call(2)";
             }); });
 }
 
 void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onDataChannel() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -773,8 +880,10 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
 
     mRtcPeerConnPtr->onDataChannel([&](std::shared_ptr<rtc::DataChannel> dc)
                                    {
+        PLOG_DEBUG << "onDataChannel cb received from rtc";
         if (mOnDataChannelCallback)
             mOnDataChannelCallback->call([this, dc](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnDataChannelCallback call(1)";
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -784,11 +893,13 @@ 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};
+                PLOG_DEBUG << "mOnDataChannelCallback call(2)";
             }); });
 }
 
 Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "bytesSent() called";
     Napi::Env env = info.Env();
 
     if (!mRtcPeerConnPtr)
@@ -809,6 +920,7 @@ Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "bytesReceived() called";
     Napi::Env env = info.Env();
 
     if (!mRtcPeerConnPtr)
@@ -829,6 +941,7 @@ Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "rtt() called";
     Napi::Env env = info.Env();
 
     if (!mRtcPeerConnPtr)
@@ -849,6 +962,7 @@ Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "getSelectedCandidatePair() called";
     Napi::Env env = info.Env();
 
     if (!mRtcPeerConnPtr)
@@ -890,6 +1004,7 @@ Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::Callback
 
 std::string PeerConnectionWrapper::candidateTypeToString(const rtc::Candidate::Type &type)
 {
+    PLOG_DEBUG << "candidateTypeToString() called";
     switch (type)
     {
     case rtc::Candidate::Type::Host:
@@ -907,6 +1022,7 @@ std::string PeerConnectionWrapper::candidateTypeToString(const rtc::Candidate::T
 
 std::string PeerConnectionWrapper::candidateTransportTypeToString(const rtc::Candidate::TransportType &transportType)
 {
+    PLOG_DEBUG << "candidateTransportTypeToString() called";
     switch (transportType)
     {
     case rtc::Candidate::TransportType::Udp:
@@ -926,6 +1042,7 @@ std::string PeerConnectionWrapper::candidateTransportTypeToString(const rtc::Can
 
 Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "addTrack() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -972,6 +1089,7 @@ Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
 
 void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "onTrack() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -990,7 +1108,8 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
     // Callback
     mOnTrackCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onTrack([&](std::shared_ptr<rtc::Track> track) {
+    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
@@ -1007,20 +1126,32 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
 
 Napi::Value PeerConnectionWrapper::hasMedia(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "hasMedia() called";
     Napi::Env env = info.Env();
     return Napi::Boolean::New(env, mRtcPeerConnPtr ? mRtcPeerConnPtr->hasMedia() : false);
 }
 
 Napi::Value PeerConnectionWrapper::state(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "state() called";
     Napi::Env env = info.Env();
     std::ostringstream stream;
     stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->state() : rtc::PeerConnection::State::Closed);
     return Napi::String::New(env, stream.str());
 }
 
+Napi::Value PeerConnectionWrapper::iceState(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "iceState() called";
+    Napi::Env env = info.Env();
+    std::ostringstream stream;
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->iceState() : rtc::PeerConnection::IceState::Closed);
+    return Napi::String::New(env, stream.str());
+}
+
 Napi::Value PeerConnectionWrapper::signalingState(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "signalingState() called";
     Napi::Env env = info.Env();
     std::ostringstream stream;
     stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->signalingState() : rtc::PeerConnection::SignalingState::Stable);
@@ -1029,6 +1160,7 @@ Napi::Value PeerConnectionWrapper::signalingState(const Napi::CallbackInfo &info
 
 Napi::Value PeerConnectionWrapper::gatheringState(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "gatheringState() called";
     Napi::Env env = info.Env();
     std::ostringstream stream;
     stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->gatheringState() : rtc::PeerConnection::GatheringState::Complete);

package/src/peer-connection-wrapper.h

@@ -26,11 +26,13 @@ public:
   void setLocalDescription(const Napi::CallbackInfo &info);
   void setRemoteDescription(const Napi::CallbackInfo &info);
   Napi::Value localDescription(const Napi::CallbackInfo &info);
+  Napi::Value remoteDescription(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 iceState(const Napi::CallbackInfo &info);
   Napi::Value signalingState(const Napi::CallbackInfo &info);
   Napi::Value gatheringState(const Napi::CallbackInfo &info);
 
@@ -38,6 +40,7 @@ public:
   void onLocalDescription(const Napi::CallbackInfo &info);
   void onLocalCandidate(const Napi::CallbackInfo &info);
   void onStateChange(const Napi::CallbackInfo &info);
+  void onIceStateChange(const Napi::CallbackInfo &info);
   void onSignalingStateChange(const Napi::CallbackInfo &info);
   void onGatheringStateChange(const Napi::CallbackInfo &info);
   void onDataChannel(const Napi::CallbackInfo &info);
@@ -70,6 +73,7 @@ private:
   std::unique_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnIceStateChangeCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnSignalingStateChangeCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnGatheringStateChangeCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnDataChannelCallback = nullptr;

package/src/rtc-wrapper.cpp

@@ -3,6 +3,8 @@
 #include "data-channel-wrapper.h"
 #include "media-track-wrapper.h"
 
+#include "plog/Log.h"
+
 #include <chrono>
 #include <future>
 
@@ -20,6 +22,7 @@ Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
 
 void RtcWrapper::preload(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "preload() called";
     Napi::Env env = info.Env();
     try
     {
@@ -73,7 +76,8 @@ void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
                 return;
             }
             logCallback = std::make_unique<ThreadSafeCallback>(info[1].As<Napi::Function>());
-            rtc::InitLogger(logLevel, [&](rtc::LogLevel level, std::string message) {
+            rtc::InitLogger(logLevel, [&](rtc::LogLevel level, std::string message)
+                            {
                 if (logCallback)
                     logCallback->call([level, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
                         // This will run in main thread and needs to construct the
@@ -93,10 +97,8 @@ void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
                         if (level == rtc::LogLevel::Fatal)
                             logLevel = "Fatal";
                         args = {Napi::String::New(env, logLevel), Napi::String::New(env, message)};
-                    });
-            });
+                    }); });
         }
-
     }
     catch (std::exception &ex)
     {
@@ -107,6 +109,7 @@ void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
 
 void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "cleanup() called";
     Napi::Env env = info.Env();
     try
     {
@@ -115,14 +118,15 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
         TrackWrapper::CloseAll();
 
         const auto timeout = std::chrono::seconds(10);
-        if(rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
+        if (rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
             throw std::runtime_error("cleanup timeout (possible deadlock)");
-        
-        // Clear Callbacks    
+
+        // Clear Callbacks
         PeerConnectionWrapper::ResetCallbacksAll();
 
-        if (logCallback) logCallback.reset();
-    }        
+        if (logCallback)
+            logCallback.reset();
+    }
     catch (std::exception &ex)
     {
         Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
@@ -132,6 +136,7 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
 
 void RtcWrapper::setSctpSettings(const Napi::CallbackInfo &info)
 {
+    PLOG_DEBUG << "setSctpSettings() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 

package/src/thread-safe-callback.cpp

@@ -1,12 +1,8 @@
 #include "thread-safe-callback.h"
 
-#ifdef LEGACY_NAPI_THREAD_SAFE_CALLBACK
+#include <stdexcept>
 
-// Nothing to do
-
-#else
-
-const char* ThreadSafeCallback::CancelException::what() const throw()
+const char *ThreadSafeCallback::CancelException::what() const throw()
 {
     return "ThreadSafeCallback cancelled";
 }
@@ -45,7 +41,8 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
                                       Napi::Reference<Napi::Value> *context,
                                       CallbackData *data)
 {
-    if (!data)
+    // if env is gone this could mean cb fn has changed. See issue#176
+    if (!data || !env)
         return;
 
     arg_vector_t args;
@@ -64,6 +61,3 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
     if (env && callback)
         callback.Call(context->Value(), args);
 }
-
-#endif
-

package/src/thread-safe-callback.h

@@ -1,12 +1,6 @@
 #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>
@@ -24,14 +18,14 @@ public:
     ThreadSafeCallback(const ThreadSafeCallback &) = delete;
     ThreadSafeCallback(ThreadSafeCallback &&) = delete;
 
-    ThreadSafeCallback& operator=(const ThreadSafeCallback &) = delete;
-    ThreadSafeCallback& operator=(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();
+        const char *what() const throw();
     };
 
 private:
@@ -51,7 +45,4 @@ private:
     tsfn_t tsfn;
 };
 
-#endif // LEGACY_NAPI_THREAD_SAFE_CALLBACK
-
 #endif // THREAD_SAFE_CALLBACK_H
-