node-datachannel 0.2.2 → 0.3.0

package/src/media-track-wrapper.cpp

@@ -22,6 +22,7 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
         {
             InstanceMethod("direction", &TrackWrapper::direction),
             InstanceMethod("mid", &TrackWrapper::mid),
+            InstanceMethod("type", &TrackWrapper::type),
             InstanceMethod("close", &TrackWrapper::close),
             InstanceMethod("sendMessage", &TrackWrapper::sendMessage),
             InstanceMethod("sendMessageBinary", &TrackWrapper::sendMessageBinary),
@@ -45,8 +46,26 @@ 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);
 }
 
@@ -57,19 +76,11 @@ TrackWrapper::~TrackWrapper()
 
 void TrackWrapper::doClose()
 {
-    instances.erase(this);
-
     if (mTrackPtr)
     {
         try
         {
-            mOnOpenCallback.reset();
-            mOnClosedCallback.reset();
-            mOnErrorCallback.reset();
-            mOnMessageCallback.reset();
-
             mTrackPtr->close();
-            mTrackPtr.reset();
         }
         catch (std::exception &ex)
         {
@@ -79,6 +90,17 @@ void TrackWrapper::doClose()
     }
 }
 
+void TrackWrapper::cleanCbsAndEraseInstance()
+{
+    mOnOpenCallback.reset();
+    mOnClosedCallback.reset();
+    mOnErrorCallback.reset();
+    mOnMessageCallback.reset();
+
+    instances.erase(this);
+    mTrackPtr.reset();
+}
+
 void TrackWrapper::close(const Napi::CallbackInfo &info)
 {
     doClose();
@@ -96,6 +118,12 @@ Napi::Value TrackWrapper::mid(const Napi::CallbackInfo &info)
     return Napi::String::New(env, mTrackPtr->mid());
 }
 
+Napi::Value TrackWrapper::type(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    return Napi::String::New(env, mTrackPtr->description().type());
+}
+
 Napi::Value TrackWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
@@ -254,18 +282,7 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    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();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-            }); });
+    // Object cb call moved to the constructor    
 }
 
 void TrackWrapper::onError(const Napi::CallbackInfo &info)
@@ -323,6 +340,8 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
                 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

package/src/media-track-wrapper.h

@@ -23,6 +23,7 @@ public:
   // Functions
   Napi::Value direction(const Napi::CallbackInfo &info);
   Napi::Value mid(const Napi::CallbackInfo &info);
+  Napi::Value type(const Napi::CallbackInfo &info);
   void close(const Napi::CallbackInfo &info);
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
@@ -45,6 +46,7 @@ private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
+  void cleanCbsAndEraseInstance();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;
 

package/src/media-video-wrapper.cpp

@@ -190,15 +190,15 @@ Napi::Value VideoWrapper::generateSdp(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
-    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString())
+    if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsNumber())
     {
-        Napi::TypeError::New(env, "We expect (String, String, String) as param").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "We expect (String, String, Number) as param").ThrowAsJavaScriptException();
         return Napi::String::New(env, "");
     }
 
     std::string eol = info[0].As<Napi::String>().ToString();
     std::string addr = info[1].As<Napi::String>().ToString();
-    std::string port = info[2].As<Napi::String>().ToString();
+    uint16_t port = info[2].As<Napi::Number>().Uint32Value();
 
     return Napi::String::New(env, mVideoPtr->generateSdp(eol, addr, port));
 }
@@ -431,7 +431,7 @@ void VideoWrapper::setBitrate(const Napi::CallbackInfo &info)
 Napi::Value VideoWrapper::getBitrate(const Napi::CallbackInfo &info)
 {
 
-    return Napi::Number::New(info.Env(), mVideoPtr->getBitrate());
+    return Napi::Number::New(info.Env(), mVideoPtr->bitrate());
 }
 
 Napi::Value VideoWrapper::hasPayloadType(const Napi::CallbackInfo &info)
@@ -465,7 +465,7 @@ void VideoWrapper::addRTXCodec(const Napi::CallbackInfo &info)
     unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
     unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
 
-    mVideoPtr->addRTXCodec(payloadType, originalPayloadType, clockRate);
+    mVideoPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }
 
 void VideoWrapper::addRTPMap(const Napi::CallbackInfo &info)

package/src/peer-connection-wrapper.cpp

@@ -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();
@@ -211,6 +215,27 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
         return;
     }
 
+    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())
+                    throw ThreadSafeCallback::CancelException();
+
+                if(mDoCloseFlag && state == rtc::PeerConnection::State::Closed)
+                    cleanCbsAndEraseInstance();
+
+                // 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())};
+            });
+        else {
+            if(mDoCloseFlag && state == rtc::PeerConnection::State::Closed)
+                cleanCbsAndEraseInstance();
+         } });
+
     instances.insert(this);
 }
 
@@ -221,20 +246,14 @@ PeerConnectionWrapper::~PeerConnectionWrapper()
 
 void PeerConnectionWrapper::doClose()
 {
-    instances.erase(this);
-
-    if (mRtcPeerConnPtr)
+    if (mRtcPeerConnPtr && !mDoCloseFlag)
     {
         try
         {
-            mOnLocalDescriptionCallback.reset();
-            mOnLocalCandidateCallback.reset();
-            mOnStateChangeCallback.reset();
-            mOnGatheringStateChangeCallback.reset();
-            mOnDataChannelCallback.reset();
-            mOnTrackCallback.reset();
-
+            mDoCloseFlag = true;
             mRtcPeerConnPtr->close();
+
+            // Resetting in cleanCbsAndEraseInstance causes a deadlock
             mRtcPeerConnPtr.reset();
         }
         catch (std::exception &ex)
@@ -245,6 +264,20 @@ void PeerConnectionWrapper::doClose()
     }
 }
 
+void PeerConnectionWrapper::cleanCbsAndEraseInstance()
+{
+    mOnLocalDescriptionCallback.reset();
+    mOnLocalCandidateCallback.reset();
+    mOnStateChangeCallback.reset();
+    mOnGatheringStateChangeCallback.reset();
+    mOnDataChannelCallback.reset();
+    mOnTrackCallback.reset();
+
+    instances.erase(this);
+
+    mDoCloseFlag = false;
+}
+
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
 {
     doClose();
@@ -598,19 +631,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) {
-        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())
-                    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())};
-            }); });
+    // onState cb will be called from constructor
 }
 
 void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &info)

package/src/peer-connection-wrapper.h

@@ -55,6 +55,8 @@ private:
   static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
+  void cleanCbsAndEraseInstance();
+  bool mDoCloseFlag = false;
 
   std::string mPeerName;
   std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;

package/test/connectivity.js

@@ -66,6 +66,9 @@ peer2.onDataChannel((dc) => {
         console.log('Peer2 Received Msg:', msg);
     });
     dc2.sendMessage("Hello From Peer2");
+    dc2.onClosed(() => {
+        console.log('dc2 closed');
+     });
 });
 
 // DataChannel Options
@@ -85,17 +88,14 @@ dc1.onOpen(() => {
 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);

package/test/test.js

@@ -24,8 +24,11 @@ describe('PeerConnection Classes', () => {
 
     test('Create Data Channel', () => {
         let peer = new nodeDataChannel.PeerConnection("Peer", { iceServers: ["stun:stun.l.google.com:19302"] });
-        let dc = peer.createDataChannel('test');
+        let dc = peer.createDataChannel('test', { protocol: 'test-protocol' });
         expect(dc).toBeDefined();
+        expect(dc.getId()).toBeDefined();
+        expect(dc.getProtocol()).toBe('test-protocol');
+        expect(dc.getLabel()).toBe('test');
         expect(dc.onOpen).toBeDefined();
         expect(dc.onMessage).toBeDefined();
 
@@ -145,4 +148,46 @@ describe('P2P', () => {
         }, 12 * 1000);
 
     });
+});
+
+function waitForGathering(peer) {
+    return new Promise((resolve) => {
+        peer.onGatheringStateChange((state) => {
+            if (state === 'complete') resolve();
+        });
+        // Handle race conditions where gathering has already completed
+        if (peer.gatheringState() === 'complete') resolve();
+    });
+}
+
+describe('DataChannel streams', () => {
+
+    test('can build an echo pipeline', async () => {
+        let clientPeer = new nodeDataChannel.PeerConnection("Client", { iceServers: [] });
+        let echoPeer = new nodeDataChannel.PeerConnection("Client", { iceServers: [] });
+
+        const echoStream = new nodeDataChannel.DataChannelStream(
+            echoPeer.createDataChannel("echo-channel")
+        );
+        echoStream.pipe(echoStream); // Echo all received data back to the client
+
+        await waitForGathering(echoPeer);
+
+        const { sdp: echoDescSdp, type: echoDescType } = echoPeer.localDescription();
+        clientPeer.setRemoteDescription(echoDescSdp, echoDescType);
+        await waitForGathering(clientPeer);
+
+        const { sdp: clientDescSdp, type: clientDescType } = clientPeer.localDescription();
+        echoPeer.setRemoteDescription(clientDescSdp, clientDescType);
+
+        const clientChannel = await new Promise((resolve) => clientPeer.onDataChannel(resolve));
+
+        const clientResponsePromise = new Promise((resolve) => clientChannel.onMessage(resolve));
+        clientChannel.sendMessage("test message");
+
+        expect(await clientResponsePromise).toBe("test message");
+
+        clientPeer.close();
+        echoPeer.close();
+    });
 });

package/node_modules/detect-libc/.npmignore

@@ -1,7 +0,0 @@
-.nyc_output
-.travis.yml
-coverage
-test.js
-node_modules
-/.circleci
-/tests/integration

package/node_modules/detect-libc/bin/detect-libc.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-
-'use strict';
-
-var spawnSync = require('child_process').spawnSync;
-var libc = require('../');
-
-var spawnOptions = {
-  env: process.env,
-  shell: true,
-  stdio: 'inherit'
-};
-
-if (libc.isNonGlibcLinux) {
-  spawnOptions.env.LIBC = process.env.LIBC || libc.family;
-}
-
-process.exit(spawnSync(process.argv[2], process.argv.slice(3), spawnOptions).status);

package/node_modules/node-abi/.travis.yml

@@ -1,17 +0,0 @@
-language: node_js
-cache:
-  directories:
-    - ~/.npm
-notifications:
-  email: false
-node_js:
-  - '14'
-  - '12'
-  - '10'
-  - '9'
-  - '8'
-after_success:
-  - npm run travis-deploy-once "npm run semantic-release"
-branches:
-  except:
-    - /^v\d+\.\d+\.\d+$/

package/node_modules/semver/CHANGELOG.md

@@ -1,39 +0,0 @@
-# changes log
-
-## 5.7
-
-* Add `minVersion` method
-
-## 5.6
-
-* Move boolean `loose` param to an options object, with
-  backwards-compatibility protection.
-* Add ability to opt out of special prerelease version handling with
-  the `includePrerelease` option flag.
-
-## 5.5
-
-* Add version coercion capabilities
-
-## 5.4
-
-* Add intersection checking
-
-## 5.3
-
-* Add `minSatisfying` method
-
-## 5.2
-
-* Add `prerelease(v)` that returns prerelease components
-
-## 5.1
-
-* Add Backus-Naur for ranges
-* Remove excessively cute inspection methods
-
-## 5.0
-
-* Remove AMD/Browserified build artifacts
-* Fix ltr and gtr when using the `*` range
-* Fix for range `*` with a prerelease identifier

package/node_modules/semver/bin/semver

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-// Standalone semver comparison program.
-// Exits successfully and prints matching version(s) if
-// any supplied version is valid and passes all tests.
-
-var argv = process.argv.slice(2)
-
-var versions = []
-
-var range = []
-
-var inc = null
-
-var version = require('../package.json').version
-
-var loose = false
-
-var includePrerelease = false
-
-var coerce = false
-
-var identifier
-
-var semver = require('../semver')
-
-var reverse = false
-
-var options = {}
-
-main()
-
-function main () {
-  if (!argv.length) return help()
-  while (argv.length) {
-    var a = argv.shift()
-    var indexOfEqualSign = a.indexOf('=')
-    if (indexOfEqualSign !== -1) {
-      a = a.slice(0, indexOfEqualSign)
-      argv.unshift(a.slice(indexOfEqualSign + 1))
-    }
-    switch (a) {
-      case '-rv': case '-rev': case '--rev': case '--reverse':
-        reverse = true
-        break
-      case '-l': case '--loose':
-        loose = true
-        break
-      case '-p': case '--include-prerelease':
-        includePrerelease = true
-        break
-      case '-v': case '--version':
-        versions.push(argv.shift())
-        break
-      case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
-        }
-        break
-      case '--preid':
-        identifier = argv.shift()
-        break
-      case '-r': case '--range':
-        range.push(argv.shift())
-        break
-      case '-c': case '--coerce':
-        coerce = true
-        break
-      case '-h': case '--help': case '-?':
-        return help()
-      default:
-        versions.push(a)
-        break
-    }
-  }
-
-  var options = { loose: loose, includePrerelease: includePrerelease }
-
-  versions = versions.map(function (v) {
-    return coerce ? (semver.coerce(v) || { version: v }).version : v
-  }).filter(function (v) {
-    return semver.valid(v)
-  })
-  if (!versions.length) return fail()
-  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
-
-  for (var i = 0, l = range.length; i < l; i++) {
-    versions = versions.filter(function (v) {
-      return semver.satisfies(v, range[i], options)
-    })
-    if (!versions.length) return fail()
-  }
-  return success(versions)
-}
-
-function failInc () {
-  console.error('--inc can only be used on a single version with no range')
-  fail()
-}
-
-function fail () { process.exit(1) }
-
-function success () {
-  var compare = reverse ? 'rcompare' : 'compare'
-  versions.sort(function (a, b) {
-    return semver[compare](a, b, options)
-  }).map(function (v) {
-    return semver.clean(v, options)
-  }).map(function (v) {
-    return inc ? semver.inc(v, inc, options, identifier) : v
-  }).forEach(function (v, i, _) { console.log(v) })
-}
-
-function help () {
-  console.log(['SemVer ' + version,
-    '',
-    'A JavaScript implementation of the https://semver.org/ specification',
-    'Copyright Isaac Z. Schlueter',
-    '',
-    'Usage: semver [options] <version> [<version> [...]]',
-    'Prints valid versions sorted by SemVer precedence',
-    '',
-    'Options:',
-    '-r --range <range>',
-    '        Print versions that match the specified range.',
-    '',
-    '-i --increment [<level>]',
-    '        Increment a version by the specified level.  Level can',
-    '        be one of: major, minor, patch, premajor, preminor,',
-    "        prepatch, or prerelease.  Default level is 'patch'.",
-    '        Only one version may be specified.',
-    '',
-    '--preid <identifier>',
-    '        Identifier to be used to prefix premajor, preminor,',
-    '        prepatch or prerelease version increments.',
-    '',
-    '-l --loose',
-    '        Interpret versions and ranges loosely',
-    '',
-    '-p --include-prerelease',
-    '        Always include prerelease versions in range matching',
-    '',
-    '-c --coerce',
-    '        Coerce a string into SemVer if possible',
-    '        (does not imply --loose)',
-    '',
-    'Program exits successfully if any valid version satisfies',
-    'all supplied ranges, and prints all satisfying versions.',
-    '',
-    'If no satisfying versions are found, then exits failure.',
-    '',
-    'Versions are printed in ascending order, so supplying',
-    'multiple versions to the utility will just sort them.'
-  ].join('\n'))
-}