node-datachannel 0.2.4 → 0.3.2

package/src/peer-connection-wrapper.cpp

@@ -63,7 +63,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // We expect (String, Object, Function) as param
     if (length < 2 || !info[0].IsString() || !info[1].IsObject())
     {
-        Napi::TypeError::New(env, "Peer Name (String) & Configuration (Object) expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Peer Name (String) and Configuration (Object) expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -147,10 +147,6 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
         std::string strType = proxyServer.Get("type").As<Napi::String>().ToString();
         rtc::ProxyServer::Type type = rtc::ProxyServer::Type::Http;
 
-        if (strType == "None")
-            type = rtc::ProxyServer::Type::None;
-        if (strType == "Http")
-            type = rtc::ProxyServer::Type::Http;
         if (strType == "Socks5")
             type = rtc::ProxyServer::Type::Socks5;
 
@@ -176,6 +172,14 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     if (config.Get("enableIceTcp").IsBoolean())
         rtcConfig.enableIceTcp = config.Get("enableIceTcp").As<Napi::Boolean>();
 
+    // enableIceUdpMux option
+    if (config.Get("enableIceUdpMux").IsBoolean())
+        rtcConfig.enableIceUdpMux = config.Get("enableIceUdpMux").As<Napi::Boolean>();
+
+    // disableAutoNegotiation option
+    if (config.Get("disableAutoNegotiation").IsBoolean())
+        rtcConfig.disableAutoNegotiation = config.Get("disableAutoNegotiation").As<Napi::Boolean>();
+
     // Max Message Size
     if (config.Get("maxMessageSize").IsNumber())
         rtcConfig.maxMessageSize = config.Get("maxMessageSize").As<Napi::Number>().Uint32Value();
@@ -207,7 +211,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while creating peerConnection# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while creating peer connection: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 
@@ -221,28 +225,28 @@ PeerConnectionWrapper::~PeerConnectionWrapper()
 
 void PeerConnectionWrapper::doClose()
 {
-    instances.erase(this);
-
     if (mRtcPeerConnPtr)
     {
         try
         {
-            mOnLocalDescriptionCallback.reset();
-            mOnLocalCandidateCallback.reset();
-            mOnStateChangeCallback.reset();
-            mOnGatheringStateChangeCallback.reset();
-            mOnDataChannelCallback.reset();
-            mOnTrackCallback.reset();
-
             mRtcPeerConnPtr->close();
             mRtcPeerConnPtr.reset();
         }
         catch (std::exception &ex)
         {
-            std::cout << std::string("libdatachannel error while closing peerConnection# ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing peer connection: ") + ex.what() << std::endl;
             return;
         }
     }
+
+    mOnLocalDescriptionCallback.reset();
+    mOnLocalCandidateCallback.reset();
+    mOnStateChangeCallback.reset();
+    mOnGatheringStateChangeCallback.reset();
+    mOnDataChannelCallback.reset();
+    mOnTrackCallback.reset();
+
+    instances.erase(this);
 }
 
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
@@ -253,14 +257,14 @@ void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
 void PeerConnectionWrapper::setLocalDescription(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();
+        Napi::Error::New(env, "setLocalDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
-
     rtc::Description::Type type = rtc::Description::Type::Unspec;
 
     // optional
@@ -289,13 +293,14 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 void PeerConnectionWrapper::setRemoteDescription(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();
+        Napi::Error::New(env, "setRemoteDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
     if (length < 2 || !info[0].IsString() || !info[1].IsString())
     {
         Napi::TypeError::New(info.Env(), "String,String expected").ThrowAsJavaScriptException();
@@ -312,7 +317,7 @@ void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while adding remote decsription # ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while adding remote description: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
@@ -320,7 +325,13 @@ 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();
+
+    std::optional<rtc::Description> desc = mRtcPeerConnPtr ? mRtcPeerConnPtr->localDescription() : std::nullopt;
+
+    // Return JS null if no description
+    if (!desc.has_value()) {
+        return env.Null();
+    }
 
     Napi::Object obj = Napi::Object::New(env);
     obj.Set("type", desc->typeString());
@@ -331,16 +342,17 @@ Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &in
 void PeerConnectionWrapper::addRemoteCandidate(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();
+        Napi::Error::New(env, "addRemoteCandidate() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
     if (length < 2 || !info[0].IsString() || !info[1].IsString())
     {
-        Napi::TypeError::New(info.Env(), "String,String expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(info.Env(), "String, String expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -352,22 +364,22 @@ void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while adding remote candidate# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while adding remote candidate: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
 
 Napi::Value PeerConnectionWrapper::createDataChannel(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();
+        Napi::Error::New(env, "createDataChannel() called on destroyed peer connection").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
     if (length < 1 || !info[0].IsString())
     {
         Napi::TypeError::New(env, "Data Channel Label expected").ThrowAsJavaScriptException();
@@ -521,7 +533,7 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while creating datachannel# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while creating datachannel: ") + ex.what()).ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 }
@@ -531,6 +543,12 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onLocalDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -540,9 +558,9 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalDescriptionCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalDescription([&](const rtc::Description &sdp) {
+    mRtcPeerConnPtr->onLocalDescription([&](rtc::Description sdp) {
         if (mOnLocalDescriptionCallback)
-            mOnLocalDescriptionCallback->call([this, sdp](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalDescriptionCallback->call([this, sdp = std::move(sdp)](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -560,6 +578,12 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onLocalCandidate() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -569,9 +593,9 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalCandidateCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalCandidate([&](const rtc::Candidate &candidate) {
+    mRtcPeerConnPtr->onLocalCandidate([&](rtc::Candidate cand) {
         if (mOnLocalCandidateCallback)
-            mOnLocalCandidateCallback->call([this, candidate](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalCandidateCallback->call([this, cand = std::move(cand)](Napi::Env env, std::vector<napi_value> &args) {
                  // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -579,8 +603,8 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {
-                    Napi::String::New(env, std::string(candidate)),
-                    Napi::String::New(env, candidate.mid())};
+                    Napi::String::New(env, std::string(cand)),
+                    Napi::String::New(env, cand.mid())};
             }); });
 }
 
@@ -589,6 +613,12 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -601,8 +631,8 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state) {
         if (mOnStateChangeCallback)
             mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
-                if(instances.find(this) == instances.end())
+                // Check the peer connection is not closed but still allow a call for State::Closed
+                if(state != rtc::PeerConnection::State::Closed && instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
                 // This will run in main thread and needs to construct the
@@ -618,6 +648,12 @@ void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &inf
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onSignalingStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -647,6 +683,12 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onGatheringStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -676,6 +718,12 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onDataChannel() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -704,6 +752,7 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -715,7 +764,7 @@ Napi::Value PeerConnectionWrapper::bytesSent(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);
     }
 }
@@ -723,6 +772,7 @@ Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -734,7 +784,7 @@ Napi::Value PeerConnectionWrapper::bytesReceived(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);
     }
 }
@@ -742,6 +792,7 @@ Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -753,7 +804,7 @@ Napi::Value PeerConnectionWrapper::rtt(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(), -1);
     }
 }
@@ -761,16 +812,17 @@ Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
-        return Napi::Number::New(info.Env(), 0);
+        return env.Null();
     }
 
     try
     {
         rtc::Candidate local, remote;
         if (!mRtcPeerConnPtr->getSelectedCandidatePair(&local, &remote))
-            return info.Env().Null();
+            return env.Null();
 
         Napi::Object retvalue = Napi::Object::New(env);
         Napi::Object localObj = Napi::Object::New(env);
@@ -793,7 +845,7 @@ Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::Callback
     }
     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(), -1);
     }
 }
@@ -841,7 +893,7 @@ Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
 
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "addTrack() called on destroyed peer connection").ThrowAsJavaScriptException();
         return env.Null();
     }
 
@@ -875,7 +927,7 @@ Napi::Value PeerConnectionWrapper::addTrack(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 env.Null();
     }
 }
@@ -885,6 +937,12 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onGatheringStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -894,8 +952,7 @@ 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
@@ -913,14 +970,14 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::hasMedia(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    return Napi::Boolean::New(env, mRtcPeerConnPtr->hasMedia());
+    return Napi::Boolean::New(env, mRtcPeerConnPtr ? mRtcPeerConnPtr->hasMedia() : false);
 }
 
 Napi::Value PeerConnectionWrapper::state(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->state();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->state() : rtc::PeerConnection::State::Closed);
     return Napi::String::New(env, stream.str());
 }
 
@@ -928,7 +985,7 @@ Napi::Value PeerConnectionWrapper::signalingState(const Napi::CallbackInfo &info
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->signalingState();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->signalingState() : rtc::PeerConnection::SignalingState::Stable);
     return Napi::String::New(env, stream.str());
 }
 
@@ -936,6 +993,6 @@ Napi::Value PeerConnectionWrapper::gatheringState(const Napi::CallbackInfo &info
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->gatheringState();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->gatheringState() : rtc::PeerConnection::GatheringState::Complete);
     return Napi::String::New(env, stream.str());
 }

package/test/connectivity.js

@@ -1,6 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const nodeDataChannel = require('../lib/index');
 
-nodeDataChannel.initLogger("Debug");
+nodeDataChannel.initLogger('Debug');
 nodeDataChannel.preload();
 
 let dc1 = null;
@@ -24,48 +25,51 @@ let dc2 = null;
 // TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
 // TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
 
-let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
 
 // Set Callbacks
 peer1.onStateChange((state) => {
-    console.log("Peer1 State:", state);
+    console.log('Peer1 State:', state);
 });
 peer1.onGatheringStateChange((state) => {
-    console.log("Peer1 GatheringState:", state);
+    console.log('Peer1 GatheringState:', state);
 });
 peer1.onLocalDescription((sdp, type) => {
-    console.log("Peer1 SDP:", sdp, " Type:", type);
+    console.log('Peer1 SDP:', sdp, ' Type:', type);
     peer2.setRemoteDescription(sdp, type);
 });
 peer1.onLocalCandidate((candidate, mid) => {
-    console.log("Peer1 Candidate:", candidate);
+    console.log('Peer1 Candidate:', candidate);
     peer2.addRemoteCandidate(candidate, mid);
 });
 
-let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
 
 // Set Callbacks
 peer2.onStateChange((state) => {
-    console.log("Peer2 State:", state);
+    console.log('Peer2 State:', state);
 });
 peer2.onGatheringStateChange((state) => {
-    console.log("Peer2 GatheringState:", state);
+    console.log('Peer2 GatheringState:', state);
 });
 peer2.onLocalDescription((sdp, type) => {
-    console.log("Peer2 SDP:", sdp, " Type:", type);
+    console.log('Peer2 SDP:', sdp, ' Type:', type);
     peer1.setRemoteDescription(sdp, type);
 });
 peer2.onLocalCandidate((candidate, mid) => {
-    console.log("Peer2 Candidate:", candidate);
+    console.log('Peer2 Candidate:', candidate);
     peer1.addRemoteCandidate(candidate, mid);
 });
 peer2.onDataChannel((dc) => {
-    console.log("Peer2 Got DataChannel: ", dc.getLabel());
+    console.log('Peer2 Got DataChannel: ', dc.getLabel());
     dc2 = dc;
     dc2.onMessage((msg) => {
         console.log('Peer2 Received Msg:', msg);
     });
-    dc2.sendMessage("Hello From Peer2");
+    dc2.sendMessage('Hello From Peer2');
+    dc2.onClosed(() => {
+        console.log('dc2 closed');
+    });
 });
 
 // DataChannel Options
@@ -77,25 +81,22 @@ peer2.onDataChannel((dc) => {
 //     maxPacketLifeTime?: number;
 //     maxRetransmits?: number;
 // }
-dc1 = peer1.createDataChannel("test");
+dc1 = peer1.createDataChannel('test');
 dc1.onOpen(() => {
-    dc1.sendMessage("Hello from Peer1");
+    dc1.sendMessage('Hello from Peer1');
     // Binary message: Use sendMessageBinary(Buffer)
 });
 dc1.onMessage((msg) => {
     console.log('Peer1 Received Msg:', msg);
 });
+dc1.onClosed(() => {
+    console.log('dc1 closed');
+});
 
 setTimeout(() => {
     dc1.close();
     dc2.close();
     peer1.close();
     peer2.close();
-    dc1 = null;
-    dc2 = null;
-    peer1 = null;
-    peer2 = null;
     nodeDataChannel.cleanup();
-    // No need for this (>= V0.1.14)
-    // process.exit();
 }, 5 * 1000);