react-native-webrtc-nitro 1.0.0

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/rtppacketizer.hpp

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2020 Filip Klembara (in2core)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_RTP_PACKETIZER_H
+#define RTC_RTP_PACKETIZER_H
+
+#if RTC_ENABLE_MEDIA
+
+#include "mediahandler.hpp"
+#include "message.hpp"
+#include "rtppacketizationconfig.hpp"
+
+namespace rtc {
+
+/// RTP packetizer
+class RTC_CPP_EXPORT RtpPacketizer : public MediaHandler {
+public:
+	/// Default maximum fragment size (for video packetizers)
+	inline static const size_t DefaultMaxFragmentSize = RTC_DEFAULT_MAX_FRAGMENT_SIZE;
+
+	/// Clock rate for video in RTP
+	inline static const uint32_t VideoClockRate = 90 * 1000;
+
+	/// Constructs packetizer with given RTP configuration
+	/// @note RTP configuration is used in packetization process which may change some configuration
+	/// properties such as sequence number.
+	/// @param rtpConfig  RTP configuration
+	RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig);
+	virtual ~RtpPacketizer();
+
+	virtual void media(const Description::Media &desc) override;
+	virtual void outgoing(message_vector &messages, const message_callback &send) override;
+
+	/// RTP packetization config
+	const shared_ptr<RtpPacketizationConfig> rtpConfig;
+
+protected:
+	/// Fragment data into payloads
+	/// Default implementation returns data as a single payload
+	/// @param message Input data
+	virtual std::vector<binary> fragment(binary data);
+
+	/// Creates an RTP packet for a payload
+	/// @note This function increases the sequence number.
+	/// @param payload RTP payload
+	/// @param mark Set marker flag in RTP packet if true
+	virtual message_ptr packetize(const binary &payload, bool mark);
+
+	// For backward compatibility, do not use
+	[[deprecated]] virtual message_ptr packetize(shared_ptr<binary> payload, bool mark);
+
+private:
+	static const auto RtpHeaderSize = 12;
+	static const auto RtpExtHeaderCvoSize = 8;
+};
+
+// Generic audio RTP packetizer
+template <uint32_t DEFAULT_CLOCK_RATE>
+class RTC_CPP_EXPORT AudioRtpPacketizer final : public RtpPacketizer {
+public:
+	inline static const uint32_t DefaultClockRate = DEFAULT_CLOCK_RATE;
+	inline static const uint32_t defaultClockRate [[deprecated("Use DefaultClockRate")]] =
+	    DEFAULT_CLOCK_RATE; // for backward compatibility
+
+	AudioRtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig)
+	    : RtpPacketizer(std::move(rtpConfig)) {}
+};
+
+// Audio RTP packetizers
+using OpusRtpPacketizer = AudioRtpPacketizer<48000>;
+using AACRtpPacketizer = AudioRtpPacketizer<48000>;
+using PCMARtpPacketizer = AudioRtpPacketizer<8000>;
+using PCMURtpPacketizer = AudioRtpPacketizer<8000>;
+using G722RtpPacketizer = AudioRtpPacketizer<8000>;
+
+// Dummy wrapper for backward compatibility, do not use
+class RTC_CPP_EXPORT PacketizationHandler final : public MediaHandler {
+public:
+	PacketizationHandler(shared_ptr<RtpPacketizer> packetizer)
+	    : mPacketizer(std::move(packetizer)) {}
+
+	inline void outgoing(message_vector &messages, const message_callback &send) {
+		return mPacketizer->outgoing(messages, send);
+	}
+
+private:
+	shared_ptr<RtpPacketizer> mPacketizer;
+};
+
+// Audio packetization handlers for backward compatibility, do not use
+using OpusPacketizationHandler [[deprecated("Add OpusRtpPacketizer directly")]] =
+    PacketizationHandler;
+using AACPacketizationHandler [[deprecated("Add AACRtpPacketizer directly")]] =
+    PacketizationHandler;
+
+} // namespace rtc
+
+#endif /* RTC_ENABLE_MEDIA */
+
+#endif /* RTC_RTP_PACKETIZER_H */

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/track.hpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_TRACK_H
+#define RTC_TRACK_H
+
+#include "channel.hpp"
+#include "common.hpp"
+#include "description.hpp"
+#include "mediahandler.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+class Track;
+
+} // namespace impl
+
+class RTC_CPP_EXPORT Track final : private CheshireCat<impl::Track>, public Channel {
+public:
+	Track(impl_ptr<impl::Track> impl);
+	~Track() override;
+
+	string mid() const;
+	Description::Direction direction() const;
+	Description::Media description() const;
+
+	void setDescription(Description::Media description);
+
+	void close(void) override;
+	bool send(message_variant data) override;
+	bool send(const byte *data, size_t size) override;
+
+	bool isOpen(void) const override;
+	bool isClosed(void) const override;
+	size_t maxMessageSize() const override;
+
+	void sendFrame(binary data, FrameInfo info);
+	void sendFrame(const byte *data, size_t size, FrameInfo info);
+	void onFrame(std::function<void(binary data, FrameInfo info)> callback);
+
+	bool requestKeyframe();
+	bool requestBitrate(unsigned int bitrate);
+
+	void setMediaHandler(shared_ptr<MediaHandler> handler);
+	void chainMediaHandler(shared_ptr<MediaHandler> handler);
+	shared_ptr<MediaHandler> getMediaHandler();
+
+	// Deprecated, use setMediaHandler() and getMediaHandler()
+	inline void setRtcpHandler(shared_ptr<MediaHandler> handler) { setMediaHandler(handler); }
+	inline shared_ptr<MediaHandler> getRtcpHandler() { return getMediaHandler(); }
+
+private:
+	using CheshireCat<impl::Track>::impl;
+};
+
+} // namespace rtc
+
+#endif

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/utils.hpp

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2019-2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_UTILS_H
+#define RTC_UTILS_H
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <tuple>
+#include <utility>
+
+namespace rtc {
+
+// overloaded helper
+template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+// weak_ptr bind helper
+template <typename F, typename T, typename... Args> auto weak_bind(F &&f, T *t, Args &&..._args) {
+	return [bound = std::bind(f, t, _args...), weak_this = t->weak_from_this()](auto &&...args) {
+		if (auto shared_this = weak_this.lock())
+			return bound(args...);
+		else
+			return static_cast<decltype(bound(args...))>(false);
+	};
+}
+
+// scope_guard helper
+class scope_guard final {
+public:
+	scope_guard(std::function<void()> func) : function(std::move(func)) {}
+	scope_guard(scope_guard &&other) = delete;
+	scope_guard(const scope_guard &) = delete;
+	void operator=(const scope_guard &) = delete;
+
+	~scope_guard() {
+		if (function)
+			function();
+	}
+
+private:
+	std::function<void()> function;
+};
+
+// callback with built-in synchronization
+template <typename... Args> class synchronized_callback {
+public:
+	synchronized_callback() = default;
+	synchronized_callback(synchronized_callback &&cb) { *this = std::move(cb); }
+	synchronized_callback(const synchronized_callback &cb) { *this = cb; }
+	synchronized_callback(std::function<void(Args...)> func) { *this = std::move(func); }
+	virtual ~synchronized_callback() { *this = nullptr; }
+
+	synchronized_callback &operator=(synchronized_callback &&cb) {
+		std::scoped_lock lock(mutex, cb.mutex);
+		set(std::exchange(cb.callback, nullptr));
+		return *this;
+	}
+
+	synchronized_callback &operator=(const synchronized_callback &cb) {
+		std::scoped_lock lock(mutex, cb.mutex);
+		set(cb.callback);
+		return *this;
+	}
+
+	synchronized_callback &operator=(std::function<void(Args...)> func) {
+		std::lock_guard lock(mutex);
+		set(std::move(func));
+		return *this;
+	}
+
+	bool operator()(Args... args) const {
+		std::lock_guard lock(mutex);
+		return call(std::move(args)...);
+	}
+
+	operator bool() const {
+		std::lock_guard lock(mutex);
+		return callback ? true : false;
+	}
+
+protected:
+	virtual void set(std::function<void(Args...)> func) { callback = std::move(func); }
+	virtual bool call(Args... args) const {
+		if (!callback)
+			return false;
+
+		callback(std::move(args)...);
+		return true;
+	}
+
+	std::function<void(Args...)> callback;
+	mutable std::recursive_mutex mutex;
+};
+
+// callback with built-in synchronization and replay of the last missed call
+template <typename... Args>
+class synchronized_stored_callback final : public synchronized_callback<Args...> {
+public:
+	template <typename... CArgs>
+	synchronized_stored_callback(CArgs &&...cargs)
+	    : synchronized_callback<Args...>(std::forward<CArgs>(cargs)...) {}
+	~synchronized_stored_callback() {}
+
+private:
+	void set(std::function<void(Args...)> func) {
+		synchronized_callback<Args...>::set(func);
+		if (func && stored) {
+			std::apply(func, std::move(*stored));
+			stored.reset();
+		}
+	}
+
+	bool call(Args... args) const {
+		if (!synchronized_callback<Args...>::call(args...))
+			stored.emplace(std::move(args)...);
+
+		return true;
+	}
+
+	mutable std::optional<std::tuple<Args...>> stored;
+};
+
+// pimpl base class
+template <typename T> using impl_ptr = std::shared_ptr<T>;
+template <typename T> class CheshireCat {
+public:
+	CheshireCat(impl_ptr<T> impl) : mImpl(std::move(impl)) {}
+	template <typename... Args>
+	CheshireCat(Args... args) : mImpl(std::make_shared<T>(std::forward<Args>(args)...)) {}
+	CheshireCat(CheshireCat<T> &&cc) { *this = std::move(cc); }
+	CheshireCat(const CheshireCat<T> &) = delete;
+
+	virtual ~CheshireCat() = default;
+
+	CheshireCat &operator=(CheshireCat<T> &&cc) {
+		mImpl = std::move(cc.mImpl);
+		return *this;
+	};
+	CheshireCat &operator=(const CheshireCat<T> &) = delete;
+
+protected:
+	impl_ptr<T> impl() { return mImpl; }
+	impl_ptr<const T> impl() const { return mImpl; }
+
+private:
+	impl_ptr<T> mImpl;
+};
+
+} // namespace rtc
+
+#endif

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/version.h

@@ -0,0 +1,9 @@
+#ifndef RTC_VERSION_H
+#define RTC_VERSION_H
+
+#define RTC_VERSION_MAJOR 0
+#define RTC_VERSION_MINOR 23
+#define RTC_VERSION_PATCH 1
+#define RTC_VERSION "0.23.1"
+
+#endif

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/websocket.hpp

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020-2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_WEBSOCKET_H
+#define RTC_WEBSOCKET_H
+
+#if RTC_ENABLE_WEBSOCKET
+
+#include "channel.hpp"
+#include "common.hpp"
+#include "configuration.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+struct WebSocket;
+
+}
+
+class RTC_CPP_EXPORT WebSocket final : private CheshireCat<impl::WebSocket>, public Channel {
+public:
+	enum class State : int {
+		Connecting = 0,
+		Open = 1,
+		Closing = 2,
+		Closed = 3,
+	};
+
+	using Configuration = WebSocketConfiguration;
+
+	WebSocket();
+	WebSocket(Configuration config);
+	WebSocket(impl_ptr<impl::WebSocket> impl);
+	~WebSocket() override;
+
+	State readyState() const;
+
+	bool isOpen() const override;
+	bool isClosed() const override;
+	size_t maxMessageSize() const override;
+
+	void open(const string &url);
+	void close() override;
+	void forceClose();
+	bool send(const message_variant data) override;
+	bool send(const byte *data, size_t size) override;
+
+	optional<string> remoteAddress() const;
+	optional<string> path() const;
+
+private:
+	using CheshireCat<impl::WebSocket>::impl;
+};
+
+std::ostream &operator<<(std::ostream &out, WebSocket::State state);
+
+} // namespace rtc
+
+#endif
+
+#endif // RTC_WEBSOCKET_H

package/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64_x86_64-simulator/Headers/rtc/websocketserver.hpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_WEBSOCKETSERVER_H
+#define RTC_WEBSOCKETSERVER_H
+
+#if RTC_ENABLE_WEBSOCKET
+
+#include "common.hpp"
+#include "configuration.hpp"
+#include "websocket.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+struct WebSocketServer;
+
+}
+
+class RTC_CPP_EXPORT WebSocketServer final : private CheshireCat<impl::WebSocketServer> {
+public:
+	using Configuration = WebSocketServerConfiguration;
+
+	WebSocketServer();
+	WebSocketServer(Configuration config);
+	~WebSocketServer();
+
+	void stop();
+
+	uint16_t port() const;
+
+	void onClient(std::function<void(shared_ptr<WebSocket>)> callback);
+
+private:
+	using CheshireCat<impl::WebSocketServer>::impl;
+};
+
+} // namespace rtc
+
+#endif
+
+#endif // RTC_WEBSOCKET_H

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kaizhi-singtown
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# react-native-webrtc-nitro
+
+Nitro WebRTC module for React Native
+
+[![Version](https://img.shields.io/npm/v/react-native-webrtc-nitro.svg)](https://www.npmjs.com/package/react-native-webrtc)
+[![Downloads](https://img.shields.io/npm/dm/react-native-webrtc-nitro.svg)](https://www.npmjs.com/package/react-native-webrtc-nitro)
+[![License](https://img.shields.io/npm/l/react-native-webrtc-nitro.svg)](https://github.com/patrickkabwe/react-native-webrtc-nitro/LICENSE)
+
+## Requirements
+
+- React Native v0.76.0 or higher
+- Node 18.0.0 or higher
+
+> [!IMPORTANT]  
+> To Support `Nitro Views` you need to install React Native version v0.78.0 or higher.
+
+## Installation
+
+```bash
+pnpm add react-native-webrtc-nitro react-native-nitro-modules
+```
+
+## Credits
+
+Bootstrapped with [create-nitro-module](https://github.com/patrickkabwe/create-nitro-module).
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

package/Webrtc.podspec

@@ -0,0 +1,44 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "Webrtc"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/SingTown/react-native-webrtc-nitro.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{h,m,mm}",
+    # Implementation (C++ objects)
+    "cpp/*.{h,hpp,cpp}",
+    "cpp/FFmpeg/*.{h,hpp,cpp}",
+    "cpp/Hybrid/*.{h,hpp,cpp}",
+  ]
+
+  s.public_header_files = "ios/**/*.h"
+  s.vendored_frameworks = "3rdparty/output/ios/*.xcframework"
+  s.pod_target_xcconfig = {
+    'HEADER_SEARCH_PATHS' => [
+      '$(PODS_TARGET_SRCROOT)/3rdparty/output/ios/ffmpeg.xcframework/ios-arm64/Headers',
+      '$(PODS_TARGET_SRCROOT)/3rdparty/output/ios/libdatachannel.xcframework/ios-arm64/Headers',
+    ].join(' ')
+  }
+  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'VideoToolbox'
+  s.libraries  = 'z'
+
+  load 'nitrogen/generated/ios/Webrtc+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,54 @@
+project(Webrtc)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME Webrtc)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+set(CMAKE_CXX_CLANG_TIDY "${ANDROID_TOOLCHAIN_ROOT}/bin/clang-tidy")
+
+get_filename_component(TOP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/.. ABSOLUTE)
+get_filename_component(LIBDATACHANNEL_PATH ${TOP_PATH}/3rdparty/output/android/libdatachannel/${ANDROID_ABI} ABSOLUTE)
+get_filename_component(FFMPEG_PATH ${TOP_PATH}/3rdparty/output/android/ffmpeg/${ANDROID_ABI} ABSOLUTE)
+
+file(GLOB CPP_SOURCES
+        ${TOP_PATH}/cpp/*.cpp
+        ${TOP_PATH}/cpp/FFmpeg/*.cpp
+        ${TOP_PATH}/cpp/Hybrid/*.cpp
+)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+        ${CPP_SOURCES}
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/Webrtc+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "${TOP_PATH}/cpp"
+        "${TOP_PATH}/cpp/FFmpeg"
+        "${TOP_PATH}/cpp/Hybrid"
+        ${LIBDATACHANNEL_PATH}/include
+        ${FFMPEG_PATH}/include
+)
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+        ${LIBDATACHANNEL_PATH}/lib/libdatachannel.so
+        ${FFMPEG_PATH}/lib/libavformat.so
+        ${FFMPEG_PATH}/lib/libavcodec.so
+        ${FFMPEG_PATH}/lib/libswscale.so
+        ${FFMPEG_PATH}/lib/libswresample.so
+        ${FFMPEG_PATH}/lib/libavutil.so
+)