react-native-webrtc-nitro 1.0.0

package/nitrogen/generated/shared/c++/RTCTrackEvent.hpp

@@ -0,0 +1,85 @@
+///
+/// RTCTrackEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridMediaStreamTrackSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamTrackSpec; }
+// Forward declaration of `HybridMediaStreamSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamSpec; }
+
+#include <memory>
+#include "HybridMediaStreamTrackSpec.hpp"
+#include "HybridMediaStreamSpec.hpp"
+#include <vector>
+
+namespace margelo::nitro::webrtc {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RTCTrackEvent).
+   */
+  struct RTCTrackEvent {
+  public:
+    std::shared_ptr<HybridMediaStreamTrackSpec> track     SWIFT_PRIVATE;
+    std::vector<std::shared_ptr<HybridMediaStreamSpec>> streams     SWIFT_PRIVATE;
+
+  public:
+    RTCTrackEvent() = default;
+    explicit RTCTrackEvent(std::shared_ptr<HybridMediaStreamTrackSpec> track, std::vector<std::shared_ptr<HybridMediaStreamSpec>> streams): track(track), streams(streams) {}
+  };
+
+} // namespace margelo::nitro::webrtc
+
+namespace margelo::nitro {
+
+  // C++ RTCTrackEvent <> JS RTCTrackEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::webrtc::RTCTrackEvent> final {
+    static inline margelo::nitro::webrtc::RTCTrackEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::webrtc::RTCTrackEvent(
+        JSIConverter<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamTrackSpec>>::fromJSI(runtime, obj.getProperty(runtime, "track")),
+        JSIConverter<std::vector<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamSpec>>>::fromJSI(runtime, obj.getProperty(runtime, "streams"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::webrtc::RTCTrackEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "track", JSIConverter<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamTrackSpec>>::toJSI(runtime, arg.track));
+      obj.setProperty(runtime, "streams", JSIConverter<std::vector<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamSpec>>>::toJSI(runtime, arg.streams));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamTrackSpec>>::canConvert(runtime, obj.getProperty(runtime, "track"))) return false;
+      if (!JSIConverter<std::vector<std::shared_ptr<margelo::nitro::webrtc::HybridMediaStreamSpec>>>::canConvert(runtime, obj.getProperty(runtime, "streams"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/views/HybridWebrtcViewComponent.cpp

@@ -0,0 +1,99 @@
+///
+/// HybridWebrtcViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridWebrtcViewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::webrtc::views {
+
+  extern const char HybridWebrtcViewComponentName[] = "WebrtcView";
+
+  HybridWebrtcViewProps::HybridWebrtcViewProps(const react::PropsParserContext& context,
+                                               const HybridWebrtcViewProps& sourceProps,
+                                               const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    videoPipeId([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("videoPipeId", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.videoPipeId;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.videoPipeId);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("WebrtcView.videoPipeId: ") + exc.what());
+      }
+    }()),
+    audioPipeId([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("audioPipeId", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.audioPipeId;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.audioPipeId);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("WebrtcView.audioPipeId: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridWebrtcViewSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridWebrtcViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("WebrtcView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridWebrtcViewProps::HybridWebrtcViewProps(const HybridWebrtcViewProps& other):
+    react::ViewProps(),
+    videoPipeId(other.videoPipeId),
+    audioPipeId(other.audioPipeId),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridWebrtcViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("videoPipeId"): return true;
+      case hashString("audioPipeId"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridWebrtcViewComponentDescriptor::HybridWebrtcViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridWebrtcViewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                      const std::shared_ptr<const react::Props>& props,
+                                                                                      react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridWebrtcViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridWebrtcViewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<HybridWebrtcViewShadowNode&>(shadowNode);
+    const HybridWebrtcViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridWebrtcViewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::webrtc::views

package/nitrogen/generated/shared/c++/views/HybridWebrtcViewComponent.hpp

@@ -0,0 +1,109 @@
+///
+/// HybridWebrtcViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include <memory>
+#include "HybridWebrtcViewSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::webrtc::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridWebrtcViewComponentName[];
+
+  /**
+   * Props for the "WebrtcView" View.
+   */
+  class HybridWebrtcViewProps final: public react::ViewProps {
+  public:
+    HybridWebrtcViewProps() = default;
+    HybridWebrtcViewProps(const HybridWebrtcViewProps&);
+    HybridWebrtcViewProps(const react::PropsParserContext& context,
+                          const HybridWebrtcViewProps& sourceProps,
+                          const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::string>> videoPipeId;
+    CachedProp<std::optional<std::string>> audioPipeId;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridWebrtcViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "WebrtcView" View.
+   */
+  class HybridWebrtcViewState final {
+  public:
+    HybridWebrtcViewState() = default;
+
+  public:
+    void setProps(const HybridWebrtcViewProps& props) { _props.emplace(props); }
+    const std::optional<HybridWebrtcViewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridWebrtcViewState(const HybridWebrtcViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridWebrtcViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridWebrtcViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridWebrtcViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "WebrtcView" View.
+   */
+  using HybridWebrtcViewShadowNode = react::ConcreteViewShadowNode<HybridWebrtcViewComponentName /* "HybridWebrtcView" */,
+                                                                   HybridWebrtcViewProps /* custom props */,
+                                                                   react::ViewEventEmitter /* default */,
+                                                                   HybridWebrtcViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "WebrtcView" View.
+   */
+  class HybridWebrtcViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridWebrtcViewShadowNode> {
+  public:
+    HybridWebrtcViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridWebrtcViewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "WebrtcView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::webrtc::views

package/nitrogen/generated/shared/json/WebrtcViewConfig.json

@@ -0,0 +1,11 @@
+{
+  "uiViewClassName": "WebrtcView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "videoPipeId": true,
+    "audioPipeId": true,
+    "hybridRef": true
+  }
+}

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "react-native-webrtc-nitro",
+  "version": "1.0.0",
+  "description": "Nitro WebRTC module for React Native",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "clean": "git clean -dfX",
+    "release": "semantic-release",
+    "build": "pnpm run typecheck && bob build",
+    "codegen": "nitrogen --logLevel=\"debug\" && pnpm run build && node post-script.js",
+    "lint": "pnpm run lint:cpp",
+    "lint:cpp": "find cpp -path cpp/__tests__/build -prune -o \\( -name \"*.cpp\" -o -name \"*.h\" -o -name \"*.hpp\" \\) -type f -print0 | xargs -0 clang-format -n --Werror -style=file",
+    "outtt": "which clang-format"
+  },
+  "keywords": [
+    "react-native",
+    "react-native-webrtc-nitro"
+  ],
+  "files": [
+    "src",
+    "react-native.config.js",
+    "lib",
+    "nitrogen",
+    "cpp",
+    "3rdparty/output",
+    "nitro.json",
+    "android/build.gradle",
+    "android/fix-prefab.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "*.podspec",
+    "README.md"
+  ],
+  "repository": "https://github.com/SingTown/react-native-webrtc-nitro.git",
+  "author": "SingTown",
+  "license": "MIT",
+  "bugs": "https://github.com/SingTown/react-native-webrtc-nitro/issues",
+  "homepage": "https://github.com/SingTown/react-native-webrtc-nitro#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@jamesacarr/eslint-formatter-github-actions": "^0.2.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/react": "19.2.7",
+    "clang-format-node": "^2.0.5",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "nitrogen": "0.31.10",
+    "react": "19.2.0",
+    "react-native": "0.83.0-rc.3",
+    "react-native-builder-bob": "^0.40.16",
+    "react-native-nitro-modules": "0.31.10",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "plugins": [
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "warn",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false,
+    "semi": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.json"
+        }
+      ]
+    ]
+  },
+  "workspaces": [
+    "example"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './views/WebrtcView'
+export * from './specs/MediaDevices.nitro'
+export * from './specs/MediaStream.nitro'
+export * from './specs/MediaStreamTrack.nitro'
+export * from './specs/RTCPeerConnection.nitro'
+export * from './specs/RTCRtpSender.nitro'
+export * from './specs/RTCRtpReceiver.nitro'
+export * from './specs/RTCRtpTransceiver.nitro'

package/src/specs/Camera.nitro.ts

@@ -0,0 +1,8 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+
+export interface Camera extends HybridObject<{
+  ios: 'swift'
+  android: 'kotlin'
+}> {
+  open(pipeId: string): Promise<void>
+}

package/src/specs/MediaDevices.nitro.ts

@@ -0,0 +1,18 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { NitroModules } from 'react-native-nitro-modules'
+import { MediaStream } from './MediaStream.nitro'
+
+export interface MediaStreamConstraints {
+  audio?: boolean
+  video?: boolean
+}
+
+interface MediaDevices extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  getMockMedia(constraints: MediaStreamConstraints): Promise<MediaStream>
+  getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>
+}
+
+const MediaDevicesExport =
+  NitroModules.createHybridObject<MediaDevices>('MediaDevices')
+type MediaDevicesExport = MediaDevices
+export { MediaDevicesExport as MediaDevices }

package/src/specs/MediaStream.nitro.ts

@@ -0,0 +1,17 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { getHybridObjectConstructor } from 'react-native-nitro-modules'
+import { MediaStreamTrack } from './MediaStreamTrack.nitro'
+
+interface MediaStream extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  readonly id: string
+  getTracks(): MediaStreamTrack[]
+  addTrack(track: MediaStreamTrack): void
+  removeTrack(track: MediaStreamTrack): void
+  getAudioTracks(): MediaStreamTrack[]
+  getVideoTracks(): MediaStreamTrack[]
+}
+
+export const MediaStreamExport =
+  getHybridObjectConstructor<MediaStream>('MediaStream')
+export type MediaStreamExport = MediaStream
+export { MediaStreamExport as MediaStream }

package/src/specs/MediaStreamTrack.nitro.ts

@@ -0,0 +1,22 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { getHybridObjectConstructor } from 'react-native-nitro-modules'
+
+export type MediaStreamTrackState = 'ended' | 'live'
+
+interface MediaStreamTrack extends HybridObject<{
+  ios: 'c++'
+  android: 'c++'
+}> {
+  readonly id: string
+  readonly kind: string
+  readonly readyState: MediaStreamTrackState
+  enabled: boolean
+  readonly _srcPipeId: string
+  readonly _dstPipeId: string
+  stop(): void
+}
+
+const MediaStreamTrackExport =
+  getHybridObjectConstructor<MediaStreamTrack>('MediaStreamTrack')
+type MediaStreamTrackExport = MediaStreamTrack
+export { MediaStreamTrackExport as MediaStreamTrack }

package/src/specs/Microphone.nitro.ts

@@ -0,0 +1,8 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+
+export interface Microphone extends HybridObject<{
+  ios: 'swift'
+  android: 'kotlin'
+}> {
+  open(pipeId: string): Promise<void>
+}

package/src/specs/RTCPeerConnection.nitro.ts

@@ -0,0 +1,105 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { getHybridObjectConstructor } from 'react-native-nitro-modules'
+import { MediaStreamTrack } from './MediaStreamTrack.nitro'
+import { RTCRtpTransceiver } from './RTCRtpTransceiver.nitro'
+import { type RTCRtpTransceiverDirection } from './RTCRtpTransceiver.nitro'
+import { MediaStream } from './MediaStream.nitro'
+
+type RTCIceGatheringState = 'complete' | 'gathering' | 'new'
+type RTCPeerConnectionState =
+  | 'closed'
+  | 'connected'
+  | 'connecting'
+  | 'disconnected'
+  | 'failed'
+  | 'new'
+type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback'
+
+export interface Event {
+  readonly NONE: 0
+}
+
+export interface RTCIceServer {
+  credential?: string
+  urls: string[] | string
+  username?: string
+}
+
+export interface RTCConfiguration {
+  iceServers?: RTCIceServer[]
+}
+
+export interface RTCRtpTransceiverInit {
+  direction?: RTCRtpTransceiverDirection
+  streams?: MediaStream[]
+}
+
+export interface RTCIceCandidate {
+  readonly candidate: string
+}
+
+export interface RTCIceCandidateInit {
+  candidate?: string
+  sdpMid?: string | null
+}
+
+export interface RTCPeerConnectionIceEvent {
+  readonly candidate: RTCIceCandidate | null
+}
+
+export interface RTCSessionDescriptionInit {
+  sdp?: string
+  type: RTCSdpType
+}
+
+export interface RTCTrackEvent {
+  track: MediaStreamTrack
+  streams: MediaStream[]
+}
+
+type stateChangeHandler = (event: Event) => void
+type iceCandidateHandler = (event: RTCPeerConnectionIceEvent) => void
+type trackHandler = (event: RTCTrackEvent) => void
+
+interface RTCPeerConnection extends HybridObject<{
+  ios: 'c++'
+  android: 'c++'
+}> {
+  readonly connectionState: RTCPeerConnectionState
+  readonly iceGatheringState: RTCIceGatheringState
+  readonly localDescription: string
+  readonly remoteDescription: string
+
+  onconnectionstatechange?: stateChangeHandler
+  onicegatheringstatechange?: stateChangeHandler
+  onicecandidate?: iceCandidateHandler
+  ontrack?: trackHandler
+
+  setConfiguration(config?: RTCConfiguration): void
+  close(): void
+  setLocalDescription(description?: RTCSessionDescriptionInit): Promise<void>
+  setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>
+  addIceCandidate(candidate?: RTCIceCandidateInit | null): Promise<void>
+
+  addTransceiver(
+    trackOrKind: MediaStreamTrack | string,
+    init?: RTCRtpTransceiverInit
+  ): RTCRtpTransceiver
+  getTransceivers(): RTCRtpTransceiver[]
+
+  createOffer(): Promise<RTCSessionDescriptionInit>
+  createAnswer(): Promise<RTCSessionDescriptionInit>
+}
+
+const RTCPeerConnectionConstructor =
+  getHybridObjectConstructor<RTCPeerConnection>('RTCPeerConnection')
+const RTCPeerConnectionExport = new Proxy(RTCPeerConnectionConstructor, {
+  construct(target, args) {
+    const config = args[0] as RTCConfiguration | undefined
+    const instance = new target()
+    instance.setConfiguration(config)
+    return instance
+  },
+}) as { new (config?: RTCConfiguration): RTCPeerConnection }
+type RTCPeerConnectionExport = RTCPeerConnection
+export { RTCPeerConnectionExport as RTCPeerConnection }

package/src/specs/RTCRtpReceiver.nitro.ts

@@ -0,0 +1,12 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { getHybridObjectConstructor } from 'react-native-nitro-modules'
+import { MediaStreamTrack } from './MediaStreamTrack.nitro.js'
+
+interface RTCRtpReceiver extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  readonly track: MediaStreamTrack | null
+}
+
+const RTCRtpReceiverExport =
+  getHybridObjectConstructor<RTCRtpReceiver>('RTCRtpReceiver')
+type RTCRtpReceiverExport = RTCRtpReceiver
+export { RTCRtpReceiverExport as RTCRtpReceiver }

package/src/specs/RTCRtpSender.nitro.ts

@@ -0,0 +1,12 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+import { getHybridObjectConstructor } from 'react-native-nitro-modules'
+import { MediaStreamTrack } from './MediaStreamTrack.nitro.js'
+
+interface RTCRtpSender extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  readonly track: MediaStreamTrack | null
+}
+
+const RTCRtpSenderExport =
+  getHybridObjectConstructor<RTCRtpSender>('RTCRtpSender')
+type RTCRtpSenderExport = RTCRtpSender
+export { RTCRtpSenderExport as RTCRtpSender }