#include "data-channel-wrapper.h" #include "plog/Log.h" Napi::FunctionReference DataChannelWrapper::constructor = Napi::FunctionReference(); std::unordered_set DataChannelWrapper::instances; void DataChannelWrapper::CloseAll() { PLOG_DEBUG << "CloseAll() called"; auto copy(instances); for (auto inst : copy) inst->doClose(); } void DataChannelWrapper::CleanupAll() { PLOG_DEBUG << "CleanupAll() called"; auto copy(instances); for (auto inst : copy) inst->doCleanup(); } Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports) { Napi::HandleScope scope(env); Napi::Function func = DefineClass( env, "DataChannel", { InstanceMethod("close", &DataChannelWrapper::close), InstanceMethod("getLabel", &DataChannelWrapper::getLabel), InstanceMethod("getId", &DataChannelWrapper::getId), InstanceMethod("getProtocol", &DataChannelWrapper::getProtocol), InstanceMethod("sendMessage", &DataChannelWrapper::sendMessage), InstanceMethod("sendMessageBinary", &DataChannelWrapper::sendMessageBinary), InstanceMethod("isOpen", &DataChannelWrapper::isOpen), InstanceMethod("bufferedAmount", &DataChannelWrapper::bufferedAmount), InstanceMethod("maxMessageSize", &DataChannelWrapper::maxMessageSize), InstanceMethod("setBufferedAmountLowThreshold", &DataChannelWrapper::setBufferedAmountLowThreshold), InstanceMethod("onOpen", &DataChannelWrapper::onOpen), InstanceMethod("onClosed", &DataChannelWrapper::onClosed), InstanceMethod("onError", &DataChannelWrapper::onError), InstanceMethod("onBufferedAmountLow", &DataChannelWrapper::onBufferedAmountLow), InstanceMethod("onMessage", &DataChannelWrapper::onMessage), }); // If this is not the first call, we don't want to reassign the constructor (hot-reload problem) if (constructor.IsEmpty()) { constructor = Napi::Persistent(func); constructor.SuppressDestruct(); } exports.Set("DataChannel", func); return exports; } DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap(info) { PLOG_DEBUG << "Constructor called"; mDataChannelPtr = *(info[0].As>>().Data()); PLOG_DEBUG << "Data Channel created"; // Closed callback must be set to trigger cleanup mOnClosedCallback = std::make_unique(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {})); instances.insert(this); } DataChannelWrapper::~DataChannelWrapper() { PLOG_DEBUG << "Destructor called"; doClose(); } void DataChannelWrapper::doClose() { PLOG_DEBUG << "doClose() called"; if (mDataChannelPtr) { PLOG_DEBUG << "Closing..."; try { mDataChannelPtr->close(); mDataChannelPtr.reset(); } catch (std::exception &ex) { std::cerr << std::string("libdatachannel error while closing data channel: ") + ex.what() << std::endl; return; } } mOnOpenCallback.reset(); mOnErrorCallback.reset(); mOnBufferedAmountLowCallback.reset(); mOnMessageCallback.reset(); } void DataChannelWrapper::doCleanup() { PLOG_DEBUG << "doCleanup() called"; mOnClosedCallback.reset(); // For close there are 3 cases: // 1. Close was called from JS // 2. Close was called from RTC // 3. Close was not called from JS or RTC (we are destroying the object) // This could be coming from rtc (case 2) mDataChannelPtr.reset(); mOnOpenCallback.reset(); mOnErrorCallback.reset(); mOnBufferedAmountLowCallback.reset(); mOnMessageCallback.reset(); instances.erase(this); } void DataChannelWrapper::close(const Napi::CallbackInfo &info) { PLOG_DEBUG << "close() called"; doClose(); } Napi::Value DataChannelWrapper::getLabel(const Napi::CallbackInfo &info) { PLOG_DEBUG << "getLabel() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "getLabel() called on destroyed channel").ThrowAsJavaScriptException(); return info.Env().Null(); } return Napi::String::New(info.Env(), mDataChannelPtr->label()); } Napi::Value DataChannelWrapper::getId(const Napi::CallbackInfo &info) { PLOG_DEBUG << "getId() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "getId() called on destroyed channel").ThrowAsJavaScriptException(); return info.Env().Null(); } return Napi::Number::New(info.Env(), mDataChannelPtr->id().value_or(-1)); } Napi::Value DataChannelWrapper::getProtocol(const Napi::CallbackInfo &info) { PLOG_DEBUG << "getProtocol() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "getProtocol() called on destroyed channel").ThrowAsJavaScriptException(); return info.Env().Null(); } return Napi::String::New(info.Env(), mDataChannelPtr->protocol()); } Napi::Value DataChannelWrapper::sendMessage(const Napi::CallbackInfo &info) { PLOG_DEBUG << "sendMessage() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "sendMessage() called on destroyed channel").ThrowAsJavaScriptException(); return info.Env().Null(); } Napi::Env env = info.Env(); int length = info.Length(); // Allow call with NULL if (length < 1 || (!info[0].IsString() && !info[0].IsNull())) { Napi::TypeError::New(env, "String or Null expected").ThrowAsJavaScriptException(); return info.Env().Null(); } try { return Napi::Boolean::New(info.Env(), mDataChannelPtr->send(info[0].As().ToString())); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()) .ThrowAsJavaScriptException(); return Napi::Boolean::New(info.Env(), false); } } Napi::Value DataChannelWrapper::sendMessageBinary(const Napi::CallbackInfo &info) { PLOG_DEBUG << "sendMessageBinary() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "sendMessagBinary() called on destroyed channel").ThrowAsJavaScriptException(); return info.Env().Null(); } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsBuffer()) { Napi::TypeError::New(env, "Buffer expected").ThrowAsJavaScriptException(); return info.Env().Null(); } try { Napi::Uint8Array buffer = info[0].As(); return Napi::Boolean::New(info.Env(), mDataChannelPtr->send((std::byte *)buffer.Data(), buffer.ByteLength())); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()) .ThrowAsJavaScriptException(); return Napi::Boolean::New(info.Env(), false); } } Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info) { PLOG_DEBUG << "isOpen() called"; Napi::Env env = info.Env(); if (!mDataChannelPtr) { return Napi::Boolean::New(info.Env(), false); } try { return Napi::Boolean::New(info.Env(), mDataChannelPtr->isOpen()); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException(); return Napi::Boolean::New(info.Env(), false); } } Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info) { PLOG_DEBUG << "bufferedAmount() called"; Napi::Env env = info.Env(); if (!mDataChannelPtr) { return Napi::Number::New(info.Env(), 0); } try { return Napi::Number::New(info.Env(), mDataChannelPtr->bufferedAmount()); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException(); return Napi::Number::New(info.Env(), 0); } } Napi::Value DataChannelWrapper::maxMessageSize(const Napi::CallbackInfo &info) { PLOG_DEBUG << "maxMessageSize() called"; Napi::Env env = info.Env(); if (!mDataChannelPtr) { return Napi::Number::New(info.Env(), 0); } try { return Napi::Number::New(info.Env(), mDataChannelPtr->maxMessageSize()); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException(); return Napi::Number::New(info.Env(), 0); } } void DataChannelWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo &info) { PLOG_DEBUG << "setBufferedAmountLowThreshold() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "setBufferedAmountLowThreshold() called on destroyed channel") .ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsNumber()) { Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException(); return; } try { mDataChannelPtr->setBufferedAmountLowThreshold(info[0].ToNumber().Uint32Value()); } catch (std::exception &ex) { Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException(); return; } } void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info) { PLOG_DEBUG << "onOpen() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "onOpen() called on destroyed channel").ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsFunction()) { Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException(); return; } // Callback mOnOpenCallback = std::make_unique(info[0].As()); mDataChannelPtr->onOpen( [&]() { PLOG_DEBUG << "onOpen cb received from rtc"; if (mOnOpenCallback) mOnOpenCallback->call( [this](Napi::Env env, std::vector &args) { PLOG_DEBUG << "mOnOpenCallback call(1)"; // Check the data channel 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 = {}; PLOG_DEBUG << "mOnOpenCallback call(2)"; }); }); } void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info) { PLOG_DEBUG << "onClosed() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "onClosed() called on destroyed channel").ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsFunction()) { Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException(); return; } // Callback mOnClosedCallback = std::make_unique(info[0].As()); mDataChannelPtr->onClosed( [&]() { PLOG_DEBUG << "onClosed cb received from rtc"; if (mOnClosedCallback) mOnClosedCallback->call( [this](Napi::Env env, std::vector &args) { PLOG_DEBUG << "mOnClosedCallback call"; // Do not check if the data channel has been closed here // This will run in main thread and needs to construct the // arguments for the call args = {}; }, [this] { doCleanup(); }); }); } void DataChannelWrapper::onError(const Napi::CallbackInfo &info) { PLOG_DEBUG << "onError() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "onError() called on destroyed channel").ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsFunction()) { Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException(); return; } // Callback mOnErrorCallback = std::make_unique(info[0].As()); mDataChannelPtr->onError( [&](std::string error) { PLOG_DEBUG << "onError cb received from rtc"; if (mOnErrorCallback) mOnErrorCallback->call( [this, error = std::move(error)](Napi::Env env, std::vector &args) { PLOG_DEBUG << "mOnErrorCallback call(1)"; // Check the data channel 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 = {Napi::String::New(env, error)}; PLOG_DEBUG << "mOnErrorCallback call(2)"; }); }); } void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info) { PLOG_DEBUG << "onBufferedAmountLow() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "onBufferedAmountLow() called on destroyed channel").ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsFunction()) { Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException(); return; } // Callback mOnBufferedAmountLowCallback = std::make_unique(info[0].As()); mDataChannelPtr->onBufferedAmountLow( [&]() { PLOG_DEBUG << "onBufferedAmountLow cb received from rtc"; if (mOnBufferedAmountLowCallback) mOnBufferedAmountLowCallback->call( [this](Napi::Env env, std::vector &args) { PLOG_DEBUG << "mOnBufferedAmountLowCallback call(1)"; // Check the data channel 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 = {}; PLOG_DEBUG << "mOnBufferedAmountLowCallback call(2)"; }); }); } void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info) { PLOG_DEBUG << "onMessage() called"; if (!mDataChannelPtr) { Napi::Error::New(info.Env(), "onMessage() called on destroyed channel").ThrowAsJavaScriptException(); return; } Napi::Env env = info.Env(); int length = info.Length(); if (length < 1 || !info[0].IsFunction()) { Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException(); return; } // Callback mOnMessageCallback = std::make_unique(info[0].As()); mDataChannelPtr->onMessage( [&](std::variant message) { PLOG_DEBUG << "onMessage cb received from rtc"; if (mOnMessageCallback) mOnMessageCallback->call( [this, message = std::move(message)](Napi::Env env, std::vector &args) { PLOG_DEBUG << "mOnMessageCallback call(1)"; // Check the data channel 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 if (std::holds_alternative(message)) { args = {Napi::String::New(env, std::get(message))}; } else { auto bin = std::get(std::move(message)); args = {Napi::Buffer::Copy(env, bin.data(), bin.size())}; } PLOG_DEBUG << "mOnMessageCallback call(2)"; }); }); }