node-datachannel 0.1.8

package/src/peer-connection-wrapper.h

@@ -0,0 +1,55 @@
+#ifndef PEER_CONNECTION_WRAPPER_H
+#define PEER_CONNECTION_WRAPPER_H
+
+#include <iostream>
+#include <string>
+#include <variant>
+#include <memory>
+#include <napi.h>
+#include <napi-thread-safe-callback.hpp>
+#include "rtc/rtc.hpp"
+
+class PeerConnectionWrapper : public Napi::ObjectWrap<PeerConnectionWrapper>
+{
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  PeerConnectionWrapper(const Napi::CallbackInfo &info);
+  ~PeerConnectionWrapper();
+
+  // Functions
+  void close(const Napi::CallbackInfo &info);
+  void setRemoteDescription(const Napi::CallbackInfo &info);
+  void addRemoteCandidate(const Napi::CallbackInfo &info);
+  Napi::Value createDataChannel(const Napi::CallbackInfo &info);
+
+  // Callbacks
+  void onLocalDescription(const Napi::CallbackInfo &info);
+  void onLocalCandidate(const Napi::CallbackInfo &info);
+  void onStateChange(const Napi::CallbackInfo &info);
+  void onGatheringStateChange(const Napi::CallbackInfo &info);
+  void onDataChannel(const Napi::CallbackInfo &info);
+
+  // Stats
+  Napi::Value bytesSent(const Napi::CallbackInfo &info);
+  Napi::Value bytesReceived(const Napi::CallbackInfo &info);
+  Napi::Value rtt(const Napi::CallbackInfo &info);
+  Napi::Value getSelectedCandidatePair(const Napi::CallbackInfo &info);
+
+private:
+  static Napi::FunctionReference constructor;
+  std::string mPeerName;
+  std::shared_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;
+
+  // Callback Ptrs
+  std::shared_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
+  std::shared_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
+  std::shared_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
+  std::shared_ptr<ThreadSafeCallback> mOnGatheringStateChangeCallback = nullptr;
+  std::shared_ptr<ThreadSafeCallback> mOnDataChannelCallback = nullptr;
+
+  // Helpers
+  std::string candidateTypeToString(const rtc::Candidate::Type &type);
+  std::string candidateTransportTypeToString(const rtc::Candidate::TransportType &transportType);
+};
+
+#endif // PEER_CONNECTION_WRAPPER_H

package/src/rtc-wrapper.cpp

@@ -0,0 +1,110 @@
+#include "rtc-wrapper.h"
+
+Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::HandleScope scope(env);
+
+    exports.Set("initLogger", Napi::Function::New(env, &RtcWrapper::initLogger));
+    exports.Set("cleanup", Napi::Function::New(env, &RtcWrapper::cleanup));
+    exports.Set("preload", Napi::Function::New(env, &RtcWrapper::preload));
+    exports.Set("setSctpSettings", Napi::Function::New(env, &RtcWrapper::setSctpSettings));
+
+    return exports;
+}
+
+void RtcWrapper::preload(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    try
+    {
+        rtc::Preload();
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+    }
+}
+
+void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    // We expect (String, Object, Function) as param
+    if (length < 1 || !info[0].IsString())
+    {
+        Napi::TypeError::New(env, "LogLevel(String) expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    std::string logLevelStr = info[0].As<Napi::String>().ToString();
+    rtc::LogLevel logLevel = rtc::LogLevel::None;
+
+    if (logLevelStr == "Verbose")
+        logLevel = rtc::LogLevel::Verbose;
+    if (logLevelStr == "Debug")
+        logLevel = rtc::LogLevel::Debug;
+    if (logLevelStr == "Info")
+        logLevel = rtc::LogLevel::Info;
+    if (logLevelStr == "Warning")
+        logLevel = rtc::LogLevel::Warning;
+    if (logLevelStr == "Error")
+        logLevel = rtc::LogLevel::Error;
+    if (logLevelStr == "Fatal")
+        logLevel = rtc::LogLevel::Fatal;
+
+    try
+    {
+        rtc::InitLogger(logLevel);
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    try
+    {
+        rtc::Cleanup();
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+void RtcWrapper::setSctpSettings(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    // We expect (Object) as param
+    if (length < 1 || !info[0].IsObject())
+    {
+        Napi::TypeError::New(env, "Configuration (Object) expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    rtc::SctpSettings settings;
+    Napi::Object config = info[0].As<Napi::Object>();
+
+    if (config.Get("recvBufferSize").IsNumber())
+        settings.recvBufferSize = config.Get("recvBufferSize").As<Napi::Number>().Uint32Value();
+    if (config.Get("sendBufferSize").IsNumber())
+        settings.sendBufferSize = config.Get("sendBufferSize").As<Napi::Number>().Uint32Value();
+    if (config.Get("maxChunksOnQueue").IsNumber())
+        settings.maxChunksOnQueue = config.Get("maxChunksOnQueue").As<Napi::Number>().Uint32Value();
+    if (config.Get("initialCongestionWindow").IsNumber())
+        settings.initialCongestionWindow = config.Get("initialCongestionWindow").As<Napi::Number>().Uint32Value();
+    if (config.Get("congestionControlModule").IsNumber())
+        settings.congestionControlModule = config.Get("congestionControlModule").As<Napi::Number>().Uint32Value();
+    if (config.Get("delayedSackTime").IsNumber())
+        settings.delayedSackTime = std::chrono::milliseconds(config.Get("delayedSackTime").As<Napi::Number>().Uint32Value());
+
+    rtc::SetSctpSettings(settings);
+}

package/src/rtc-wrapper.h

@@ -0,0 +1,19 @@
+#ifndef RTC_WRAPPER_H
+#define RTC_WRAPPER_H
+
+#include <iostream>
+#include <string>
+#include <napi.h>
+#include "rtc/rtc.hpp"
+
+class RtcWrapper
+{
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static void preload(const Napi::CallbackInfo &info);
+    static void initLogger(const Napi::CallbackInfo &info);
+    static void cleanup(const Napi::CallbackInfo &info);
+    static void setSctpSettings(const Napi::CallbackInfo &info);
+};
+
+#endif // RTC_WRAPPER_H

package/test/connectivity.js

@@ -0,0 +1,100 @@
+const nodeDataChannel = require('../lib/index');
+
+nodeDataChannel.initLogger("Debug");
+nodeDataChannel.preload();
+
+let dc1 = null;
+let dc2 = null;
+
+// Config options
+// export interface RtcConfig {
+//     iceServers: string[];
+//     proxyServer?: ProxyServer;
+//     enableIceTcp?: boolean;
+//     portRangeBegin?: number;
+//     portRangeEnd?: number;
+//     maxMessageSize?: number;
+//     iceTransportPolicy?: TransportPolicy;
+// }
+//
+// "iceServers" option is an array of stun/turn server urls
+// Examples;
+// STUN Server Example          : stun:stun.l.google.com:19302
+// 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
+
+let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+
+// Set Callbacks
+peer1.onStateChange((state) => {
+    console.log("Peer1 State:", state);
+});
+peer1.onGatheringStateChange((state) => {
+    console.log("Peer1 GatheringState:", state);
+});
+peer1.onLocalDescription((sdp, type) => {
+    console.log("Peer1 SDP:", sdp, " Type:", type);
+    peer2.setRemoteDescription(sdp, type);
+});
+peer1.onLocalCandidate((candidate, mid) => {
+    console.log("Peer1 Candidate:", candidate);
+    peer2.addRemoteCandidate(candidate, mid);
+});
+
+let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+
+// Set Callbacks
+peer2.onStateChange((state) => {
+    console.log("Peer2 State:", state);
+});
+peer2.onGatheringStateChange((state) => {
+    console.log("Peer2 GatheringState:", state);
+});
+peer2.onLocalDescription((sdp, type) => {
+    console.log("Peer2 SDP:", sdp, " Type:", type);
+    peer1.setRemoteDescription(sdp, type);
+});
+peer2.onLocalCandidate((candidate, mid) => {
+    console.log("Peer2 Candidate:", candidate);
+    peer1.addRemoteCandidate(candidate, mid);
+});
+peer2.onDataChannel((dc) => {
+    console.log("Peer2 Got DataChannel: ", dc.getLabel());
+    dc2 = dc;
+    dc2.onMessage((msg) => {
+        console.log('Peer2 Received Msg:', msg);
+    });
+    dc2.sendMessage("Hello From Peer2");
+});
+
+// DataChannel Options
+// export interface DataChannelInitConfig {
+//     protocol?: string;
+//     negotiated?: boolean;
+//     id?: number;
+//     ordered?: boolean;
+//     maxPacketLifeTime?: number;
+//     maxRetransmits?: number;
+// }
+dc1 = peer1.createDataChannel("test");
+dc1.onOpen(() => {
+    dc1.sendMessage("Hello from Peer1");
+    // Binary message: Use sendMessageBinary(Buffer)
+});
+dc1.onMessage((msg) => {
+    console.log('Peer1 Received Msg:', msg);
+});
+
+setTimeout(() => {
+    dc1.close();
+    dc2.close();
+    peer1.close();
+    peer2.close();
+    dc1 = null;
+    dc2 = null;
+    peer1 = null;
+    peer2 = null;
+    nodeDataChannel.cleanup();
+    process.exit();
+}, 5 * 1000);

package/test/test.js

@@ -0,0 +1,149 @@
+const nodeDataChannel = require('../lib/index');
+
+describe('Module Definition', () => {
+    test('Module Defined', () => {
+        expect(nodeDataChannel).toBeDefined();
+        expect(nodeDataChannel.initLogger).toBeDefined();
+        expect(nodeDataChannel.PeerConnection).toBeDefined();
+        expect(typeof nodeDataChannel.PeerConnection).toBe('function');
+        expect(nodeDataChannel.DataChannel).toBeDefined();
+        expect(typeof nodeDataChannel.DataChannel).toBe('function');
+    });
+});
+
+describe('PeerConnection Classes', () => {
+
+    test('Create PeerConnection', () => {
+        let peer = new nodeDataChannel.PeerConnection("Peer", { iceServers: ["stun:stun.l.google.com:19302"] });
+        expect(peer).toBeDefined();
+        expect(peer.onStateChange).toBeDefined();
+        expect(peer.createDataChannel).toBeDefined();
+
+        peer.close();
+    });
+
+    test('Create Data Channel', () => {
+        let peer = new nodeDataChannel.PeerConnection("Peer", { iceServers: ["stun:stun.l.google.com:19302"] });
+        let dc = peer.createDataChannel('test');
+        expect(dc).toBeDefined();
+        expect(dc.onOpen).toBeDefined();
+        expect(dc.onMessage).toBeDefined();
+
+        dc.close();
+        peer.close();
+    });
+});
+
+
+// describe('P2P', () => {
+//     let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+//     let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+//     let dc1 = null;
+//     let dc2 = null;
+
+//     // Mocks
+//     const p1StateMock = jest.fn();
+//     const p1GatheringStateMock = jest.fn();
+//     const p2StateMock = jest.fn();
+//     const p2GatheringStateMock = jest.fn();
+//     const p1SDPMock = jest.fn();
+//     const p1CandidateMock = jest.fn();
+//     const p2SDPMock = jest.fn();
+//     const p2CandidateMock = jest.fn();
+
+//     const p1DCMock = jest.fn();
+//     const p1DCMessageMock = jest.fn();
+//     const p2DCMock = jest.fn();
+//     const p2DCMessageMock = jest.fn();
+
+//     // Set Callbacks
+//     peer1.onStateChange(p1StateMock);
+//     peer1.onGatheringStateChange(p1GatheringStateMock);
+//     peer1.onLocalDescription((sdp, type) => {
+//         p1SDPMock();
+//         peer2.setRemoteDescription(sdp, type);
+//     });
+//     peer1.onLocalCandidate((candidate, mid) => {
+//         p1CandidateMock();
+//         peer2.addRemoteCandidate(candidate, mid);
+//     });
+
+//     // Set Callbacks
+//     peer2.onStateChange(p2StateMock);
+//     peer2.onGatheringStateChange(p2GatheringStateMock);
+//     peer2.onLocalDescription((sdp, type) => {
+//         p2SDPMock();
+//         peer1.setRemoteDescription(sdp, type);
+//     });
+//     peer2.onLocalCandidate((candidate, mid) => {
+//         p2CandidateMock();
+//         peer1.addRemoteCandidate(candidate, mid);
+//     });
+//     peer2.onDataChannel((dc) => {
+//         p2DCMock();
+//         dc2 = dc;
+//         dc2.onMessage((msg) => {
+//             p2DCMessageMock(msg);
+//         });
+//         dc2.sendMessage("Hello From Peer2");
+//     });
+
+//     dc1 = peer1.createDataChannel("test-p2p");
+//     dc1.onOpen(() => {
+//         p1DCMock();
+//         dc1.sendMessage("Hello From Peer1");
+//     });
+//     dc1.onMessage((msg) => {
+//         p1DCMessageMock(msg);
+//     });
+
+//     test('P2P', (done) => {
+//         // Default is 5000 ms but we need more
+//         jest.setTimeout(30000);
+
+//         setTimeout(() => {
+//             dc1.close();
+//             dc2.close();
+//             peer1.close();
+//             peer2.close();
+
+//             // Fee memory 
+//             dc1 = null;
+//             dc2 = null;
+//             peer1 = null;
+//             peer2 = null;
+
+//             // Cleanup Threads
+//             nodeDataChannel.cleanup();
+//         }, 8 * 1000);
+
+//         setTimeout(() => {
+//             // State Callbacks
+//             expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+//             expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+//             expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+//             expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+//             // SDP
+//             expect(p1SDPMock.mock.calls.length).toBe(1);
+//             expect(p2SDPMock.mock.calls.length).toBe(1);
+
+//             // Candidates
+//             expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+//             expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+//             // DataChannel
+//             expect(p1DCMock.mock.calls.length).toBe(1);
+//             expect(p1DCMessageMock.mock.calls.length).toBe(1);
+//             expect(p1DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer2");
+//             expect(p2DCMock.mock.calls.length).toBe(1);
+//             // These 2 tests fails randomly
+//             // Needs investigation ?
+//             // expect(p2DCMessageMock.mock.calls.length).toBe(1);
+//             // expect(p2DCMessageMock.mock.calls[0][0]).toEqual("Hello From Peer1");
+
+//             done();
+//         }, 20 * 1000);
+
+//     });
+// });