node-datachannel 0.2.1 → 0.2.2

package/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW)
-project(node_datachannel VERSION 0.2.1)
+project(node_datachannel VERSION 0.2.2)
 
 include_directories(${CMAKE_JS_INC})
 

package/README.md

@@ -133,7 +133,7 @@ TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
 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
 
-``` 
+```
 
 **close: () => void**
 
@@ -179,7 +179,18 @@ export interface DataChannelInitConfig {
 export const enum ReliabilityType {
     Reliable = 0, Rexmit = 1, Timed = 2
 }
-``` 
+```
+**state: () => string**
+
+Get current state
+
+**signalingState: () => string**
+
+Get current signaling state
+
+**gatheringState: () => string**
+
+Get current gathering state
 
 **onLocalDescription: (cb: (sdp: string, type: DescriptionType) => void) => void**
 
@@ -200,6 +211,10 @@ Local Candidate Callback
 
 State Change Callback
 
+**onSignalingStateChange: (state: (sdp: string) => void) => void**
+
+Signaling State Change Callback
+
 **onGatheringStateChange: (state: (sdp: string) => void) => void**
 
 Gathering State Change Callback
@@ -238,7 +253,7 @@ export interface SelectedCandidateInfo {
 
 **close: () => void**
 
-Close data channel 
+Close data channel
 
 **getLabel: () => string**
 

package/lib/index.d.ts

@@ -134,7 +134,7 @@ export class Video {
     addH264Codec: (payloadType: Number, profile?: string) => void;
     addVP8Codec: (payloadType: Number) => void;
     addVP9Codec: (payloadType: Number) => void;
-    
+
     direction: () => Direction;
     generateSdp: (eol: string, addr: string, port: string) => string;
     mid: () => string;
@@ -205,9 +205,13 @@ export class PeerConnection {
     createDataChannel: (label: string, config?: DataChannelInitConfig) => DataChannel;
     addTrack: (media: Video | Audio) => Track;
     hasMedia: () => boolean;
+    state: () => string;
+    signalingState: () => string;
+    gatheringState: () => string;
     onLocalDescription: (cb: (sdp: string, type: DescriptionType) => void) => void;
     onLocalCandidate: (cb: (candidate: string, mid: string) => void) => void;
     onStateChange: (cb: (state: string) => void) => void;
+    onSignalingStateChange: (state: (sdp: string) => void) => void;
     onGatheringStateChange: (state: (sdp: string) => void) => void;
     onDataChannel: (cb: (dc: DataChannel) => void) => void;
     onTrack: () => Track;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-datachannel",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "libdatachannel node bindings",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/peer-connection-wrapper.cpp

@@ -32,9 +32,13 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
             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),
@@ -536,8 +540,7 @@ 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([&](const rtc::Description &sdp) {
         if (mOnLocalDescriptionCallback)
             mOnLocalDescriptionCallback->call([this, sdp](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
@@ -566,8 +569,7 @@ 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([&](const rtc::Candidate &candidate) {
         if (mOnLocalCandidateCallback)
             mOnLocalCandidateCallback->call([this, candidate](Napi::Env env, std::vector<napi_value> &args) {
                  // Check the peer connection is not closed
@@ -596,8 +598,7 @@ 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) {
         if (mOnStateChangeCallback)
             mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
@@ -612,6 +613,35 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
             }); });
 }
 
+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)
 {
     Napi::Env env = info.Env();
@@ -626,8 +656,7 @@ 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) {
         if (mOnGatheringStateChangeCallback)
             mOnGatheringStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
@@ -841,7 +870,7 @@ Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
             return instance;
         }
 
-          Napi::Error::New(env, std::string("Unknown media type")).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("Unknown media type")).ThrowAsJavaScriptException();
         return env.Null();
     }
     catch (std::exception &ex)
@@ -885,4 +914,28 @@ 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

@@ -26,13 +26,17 @@ public:
   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 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);
@@ -59,6 +63,7 @@ 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;