@sbhjt-gr/react-native-webrtc 124.0.0

package/metro.config.js

@@ -0,0 +1,7 @@
+const blacklist = require('metro-config/src/defaults/blacklist');
+
+module.exports = {
+    resolver: {
+        blacklistRE: blacklist([/node_modules\/react-native-macos\/.*/])
+    }
+};

package/metro.config.macos.js

@@ -0,0 +1,14 @@
+const path = require('path');
+const blacklist = require('metro-config/src/defaults/blacklist');
+
+const rnmPath = path.resolve(__dirname, 'node_modules/react-native-macos');
+
+module.exports = {
+    resolver: {
+        extraNodeModules: {
+            'react-native': rnmPath
+        },
+        platforms: ['macos', 'ios', 'android'],
+        blacklistRE: blacklist([/node_modules\/react-native\/.*/])
+    }
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@sbhjt-gr/react-native-webrtc",
+  "version": "124.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livekit/react-native-webrtc.git"
+  },
+  "description": "WebRTC for React Native",
+  "license": "MIT",
+  "homepage": "https://github.com/livekit/react-native-webrtc",
+  "keywords": [
+    "react-component",
+    "react-native",
+    "ios",
+    "android",
+    "webrtc"
+  ],
+  "react-native": "src/index",
+  "browser": "src/index.web.ts",
+  "types": "lib/typescript/index.d.ts",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "dependencies": {
+    "base64-js": "1.5.1",
+    "debug": "4.3.4",
+    "event-target-shim": "6.0.2"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.60.0"
+  },
+  "scripts": {
+    "lint": "eslint --max-warnings 0 . && tsc --noEmit",
+    "lintfix": "eslint --max-warnings 0 --fix . && tsc --noEmit",
+    "prepare": "husky install && bob build",
+    "format": "tools/format.sh"
+  },
+  "bugs": {
+    "url": "https://github.com/livekit/react-native-webrtc/issues"
+  },
+  "devDependencies": {
+    "@types/debug": "4.1.7",
+    "@types/react": "17.0.40",
+    "@types/react-native": "0.67.3",
+    "@typescript-eslint/eslint-plugin": "^5.39.0",
+    "@typescript-eslint/parser": "^5.39.0",
+    "eslint": "^8.24.0",
+    "eslint-plugin-import": "^2.26.0",
+    "husky": "7.0.2",
+    "lint-staged": "11.2.3",
+    "prettier": "2.4.1",
+    "react-native-builder-bob": "0.18.2",
+    "typescript": "4.6.2"
+  },
+  "lint-staged": {
+    "**/*": "prettier --write --ignore-unknown"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      "typescript"
+    ]
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const macSwitch = '--use-react-native-macos';
+
+if (process.argv.includes(macSwitch)) {
+    process.argv = process.argv.filter(arg => arg !== macSwitch);
+    process.argv.push('--config=metro.config.macos.js');
+    module.exports = {
+        reactNativePath: 'node_modules/react-native-macos'
+    };
+}

package/src/.eslintrc.cjs

@@ -0,0 +1,67 @@
+/* eslint-disable no-undef */
+
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint', 'eslint-plugin-import'],
+    root: true,
+    overrides: [
+        {
+            files: [ '*.ts', '*.tsx' ],
+            rules: {
+                '@typescript-eslint/ban-ts-comment': 'off',
+                '@typescript-eslint/no-explicit-any': 'off',
+            }
+        }
+    ],
+    rules: {
+        'arrow-body-style': [
+            'error',
+            'as-needed',
+            { requireReturnForObjectLiteral: true }
+        ],
+        'array-bracket-spacing': [
+            'error',
+            'always',
+            { 'objectsInArrays': true }
+        ],
+        'arrow-parens': [ 'error', 'as-needed' ],
+        'block-spacing': [ 'error', 'always' ],
+        'brace-style': 'error',
+        'curly': 'error',
+        'eqeqeq': 'error',
+        'import/no-duplicates': 'error',
+        'import/order': [ 'error', {
+            'alphabetize': {
+                'order': 'asc'
+            },
+            'groups': [ [ 'builtin', 'external' ], 'parent', 'sibling', 'index' ],
+            'newlines-between': 'always'
+        } ],
+        'indent': [
+            'error',
+            4,
+            { 'SwitchCase': 1 }
+        ],
+        'keyword-spacing': 'error',
+        'max-len': [ 'error', 120 ],
+        'no-mixed-spaces-and-tabs': 'error',
+        'no-multiple-empty-lines': 'error',
+        'no-nested-ternary': 'error',
+        'no-trailing-spaces': 'error',
+        'object-curly-spacing': [ 'error', 'always' ],
+        'padded-blocks': [ 'error', 'never' ],
+        'padding-line-between-statements': [
+            'error',
+            { blankLine: 'always', prev: [ 'const', 'let', 'var' ], next: '*' },
+            { blankLine: 'any', prev: [ 'const', 'let', 'var' ], next: [ 'const', 'let', 'var' ] },
+            { blankLine: 'always', prev: '*', next: 'return' },
+            { blankLine: 'always', prev: '*', next: 'block-like' },
+            { blankLine: 'always', prev: 'block-like', next: '*' },
+        ],
+        'quotes': [ 'error', 'single' ],
+        'semi': [ 'error', 'always' ],
+        'space-before-blocks': 'error',
+        'spaced-comment': 'error',
+    }
+};

package/src/Constraints.ts

@@ -0,0 +1,21 @@
+
+export type MediaTrackConstraints = {
+    width?: ConstrainNumber;
+    height?: ConstrainNumber;
+    frameRate?: ConstrainNumber;
+    facingMode?: ConstrainString;
+    deviceId?: ConstrainString;
+    groupId?: ConstrainString;
+}
+
+type ConstrainNumber = number | {
+    exact?: number,
+    ideal?: number,
+    max?: number,
+    min?: number,
+}
+
+type ConstrainString = string | {
+    exact?: string,
+    ideal?: string,
+}

package/src/EventEmitter.ts

@@ -0,0 +1,65 @@
+import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native';
+// @ts-ignore
+import EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter';
+
+const { WebRTCModule } = NativeModules;
+
+// This emitter is going to be used to listen to all the native events (once) and then
+// re-emit them on a JS-only emitter.
+const nativeEmitter = new NativeEventEmitter(WebRTCModule);
+
+const NATIVE_EVENTS = [
+    'peerConnectionSignalingStateChanged',
+    'peerConnectionStateChanged',
+    'peerConnectionOnRenegotiationNeeded',
+    'peerConnectionIceConnectionChanged',
+    'peerConnectionIceGatheringChanged',
+    'peerConnectionGotICECandidate',
+    'peerConnectionDidOpenDataChannel',
+    'peerConnectionOnRemoveTrack',
+    'peerConnectionOnTrack',
+    'dataChannelStateChanged',
+    'dataChannelReceiveMessage',
+    'dataChannelDidChangeBufferedAmount',
+    'mediaStreamTrackMuteChanged',
+    'mediaStreamTrackEnded',
+    'frameCryptionStateChanged',
+    'palabraTranscription',
+    'palabraConnectionState',
+    'palabraError',
+];
+
+const eventEmitter = new EventEmitter();
+
+export function setupNativeEvents() {
+    for (const eventName of NATIVE_EVENTS) {
+        nativeEmitter.addListener(eventName, (...args) => {
+            eventEmitter.emit(eventName, ...args);
+        });
+    }
+}
+
+type EventHandler = (event: unknown) => void;
+type Listener = unknown;
+
+const _subscriptions: Map<Listener, EmitterSubscription[]> = new Map();
+
+export function addListener(listener: Listener, eventName: string, eventHandler: EventHandler): void {
+    if (!NATIVE_EVENTS.includes(eventName)) {
+        throw new Error(`Invalid event: ${eventName}`);
+    }
+
+    if (!_subscriptions.has(listener)) {
+        _subscriptions.set(listener, []);
+    }
+
+    _subscriptions.get(listener)?.push(eventEmitter.addListener(eventName, eventHandler));
+}
+
+export function removeListener(listener: Listener): void {
+    _subscriptions.get(listener)?.forEach(sub => {
+        sub.remove();
+    });
+
+    _subscriptions.delete(listener);
+}

package/src/Logger.ts

@@ -0,0 +1,49 @@
+import debug from 'debug';
+
+
+export default class Logger {
+    static ROOT_PREFIX = 'rn-webrtc';
+
+    private _debug: debug.Debugger;
+    private _info: debug.Debugger;
+    private _warn: debug.Debugger;
+    private _error: debug.Debugger;
+
+    static enable(ns: string): void {
+        debug.enable(ns);
+    }
+
+    constructor(prefix: string) {
+        const _prefix = `${Logger.ROOT_PREFIX}:${prefix}`;
+
+        this._debug = debug(`${_prefix}:DEBUG`);
+        this._info = debug(`${_prefix}:INFO`);
+        this._warn = debug(`${_prefix}:WARN`);
+        this._error = debug(`${_prefix}:ERROR`);
+
+        const log = console.log.bind(console);
+
+        this._debug.log = log;
+        this._info.log = log;
+        this._warn.log = log;
+        this._error.log = log;
+    }
+
+    debug(msg: string): void {
+        this._debug(msg);
+    }
+
+    info(msg: string): void {
+        this._info(msg);
+    }
+
+    warn(msg: string): void {
+        this._warn(msg);
+    }
+
+    error(msg: string, err?: Error): void {
+        const trace = err?.stack ?? 'N/A';
+
+        this._error(`${msg} Trace: ${trace}`);
+    }
+}

package/src/MediaDevices.ts

@@ -0,0 +1,53 @@
+import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import getDisplayMedia from './getDisplayMedia';
+import getUserMedia, { Constraints } from './getUserMedia';
+
+const { WebRTCModule } = NativeModules;
+
+type MediaDevicesEventMap = {
+    devicechange: Event<'devicechange'>
+}
+
+class MediaDevices extends EventTarget<MediaDevicesEventMap> {
+    /**
+     * W3C "Media Capture and Streams" compatible {@code enumerateDevices}
+     * implementation.
+     */
+    enumerateDevices() {
+        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));
+    }
+
+    /**
+     * W3C "Screen Capture" compatible {@code getDisplayMedia} implementation.
+     * See: https://w3c.github.io/mediacapture-screen-share/
+     *
+     * @returns {Promise}
+     */
+    getDisplayMedia() {
+        return getDisplayMedia();
+    }
+
+    /**
+     * W3C "Media Capture and Streams" compatible {@code getUserMedia}
+     * implementation.
+     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices
+     *
+     * @param {*} constraints
+     * @returns {Promise}
+     */
+    getUserMedia(constraints: Constraints) {
+        return getUserMedia(constraints);
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = MediaDevices.prototype;
+
+defineEventAttribute(proto, 'devicechange');
+
+
+export default new MediaDevices();

package/src/MediaStream.ts

@@ -0,0 +1,161 @@
+import { EventTarget, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import MediaStreamTrack, { MediaStreamTrackInfo } from './MediaStreamTrack';
+import MediaStreamTrackEvent from './MediaStreamTrackEvent';
+import { uniqueID } from './RTCUtil';
+
+const { WebRTCModule } = NativeModules;
+
+type MediaStreamEventMap = {
+    addtrack: MediaStreamTrackEvent<'addtrack'>
+    removetrack: MediaStreamTrackEvent<'removetrack'>
+}
+
+export default class MediaStream extends EventTarget<MediaStreamEventMap> {
+    _tracks: MediaStreamTrack[] = [];
+    _id: string;
+
+    /**
+     * The identifier of this MediaStream unique within the associated
+     * WebRTCModule instance. As the id of a remote MediaStream instance is unique
+     * only within the associated RTCPeerConnection, it is not sufficiently unique
+     * to identify this MediaStream across multiple RTCPeerConnections and to
+     * unambiguously differentiate it from a local MediaStream instance not added
+     * to an RTCPeerConnection.
+     */
+    _reactTag: string;
+
+    /**
+     * A MediaStream can be constructed in several ways, depending on the parameters
+     * that are passed here.
+     *
+     * - undefined: just a new stream, with no tracks.
+     * - MediaStream instance: a new stream, with a copy of the tracks of the passed stream.
+     * - Array of MediaStreamTrack: a new stream with a copy of the tracks in the array.
+     * - object: a new stream instance, represented by the passed info object, this is always
+     *   done internally, when the stream is first created in native and the JS wrapper is
+     *   built afterwards.
+     */
+    constructor(arg?:
+        MediaStream |
+        MediaStreamTrack[] |
+        { streamId: string, streamReactTag: string, tracks: MediaStreamTrackInfo[] }
+    ) {
+        super();
+
+        // Assign a UUID to start with. It will get overridden for remote streams.
+        this._id = uniqueID();
+
+        // Local MediaStreams are created by WebRTCModule to have their id and
+        // reactTag equal because WebRTCModule follows the respective standard's
+        // recommendation for id generation i.e. uses UUID which is unique enough
+        // for the purposes of reactTag.
+        this._reactTag = this._id;
+
+        if (typeof arg === 'undefined') {
+            WebRTCModule.mediaStreamCreate(this.id);
+        } else if (arg instanceof MediaStream) {
+            WebRTCModule.mediaStreamCreate(this.id);
+
+            for (const track of arg.getTracks()) {
+                this.addTrack(track);
+            }
+        } else if (Array.isArray(arg)) {
+            WebRTCModule.mediaStreamCreate(this.id);
+
+            for (const track of arg) {
+                this.addTrack(track);
+            }
+        } else if (typeof arg === 'object' && arg.streamId && arg.streamReactTag && arg.tracks) {
+            this._id = arg.streamId;
+            this._reactTag = arg.streamReactTag;
+
+            for (const trackInfo of arg.tracks) {
+                // We are not using addTrack here because the track is already part of the
+                // stream, so there is no need to add it on the native side.
+                this._tracks.push(new MediaStreamTrack(trackInfo));
+            }
+        } else {
+            throw new TypeError(`invalid type: ${typeof arg}`);
+        }
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get active(): boolean {
+        // TODO: can we reliably report this value?
+
+        return true;
+    }
+
+    addTrack(track: MediaStreamTrack): void {
+        const index = this._tracks.indexOf(track);
+
+        if (index !== -1) {
+            return;
+        }
+
+        this._tracks.push(track);
+        WebRTCModule.mediaStreamAddTrack(this._reactTag, track.remote ? track._peerConnectionId : -1, track.id);
+    }
+
+    removeTrack(track: MediaStreamTrack): void {
+        const index = this._tracks.indexOf(track);
+
+        if (index === -1) {
+            return;
+        }
+
+        this._tracks.splice(index, 1);
+        WebRTCModule.mediaStreamRemoveTrack(this._reactTag, track.remote ? track._peerConnectionId : -1, track.id);
+    }
+
+    getTracks(): MediaStreamTrack[] {
+        return this._tracks.slice();
+    }
+
+    getTrackById(trackId): MediaStreamTrack | undefined {
+        return this._tracks.find(track => track.id === trackId);
+    }
+
+    getAudioTracks(): MediaStreamTrack[] {
+        return this._tracks.filter(track => track.kind === 'audio');
+    }
+
+    getVideoTracks(): MediaStreamTrack[] {
+        return this._tracks.filter(track => track.kind === 'video');
+    }
+
+    clone(): never {
+        throw new Error('Not implemented.');
+    }
+
+    toURL(): string {
+        return this._reactTag;
+    }
+
+    release(releaseTracks = true): void {
+        const tracks = [ ...this._tracks ];
+
+        for (const track of tracks) {
+            this.removeTrack(track);
+
+            if (releaseTracks) {
+                track.release();
+            }
+        }
+
+        WebRTCModule.mediaStreamRelease(this._reactTag);
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = MediaStream.prototype;
+
+defineEventAttribute(proto, 'addtrack');
+defineEventAttribute(proto, 'removetrack');

package/src/MediaStreamError.ts

@@ -0,0 +1,12 @@
+
+export default class MediaStreamError {
+    name: string;
+    message?: string;
+    constraintName?: string;
+
+    constructor(error) {
+        this.name = error.name;
+        this.message = error.message;
+        this.constraintName = error.constraintName;
+    }
+}

package/src/MediaStreamErrorEvent.ts

@@ -0,0 +1,11 @@
+
+import type MediaStreamError from './MediaStreamError';
+
+export default class MediaStreamErrorEvent {
+    type: string;
+    error?: MediaStreamError;
+    constructor(type, eventInitDict) {
+        this.type = type.toString();
+        Object.assign(this, eventInitDict);
+    }
+}