@sbhjt-gr/react-native-webrtc 124.0.0

package/src/RTCDataChannelEvent.ts

@@ -0,0 +1,28 @@
+import { Event } from 'event-target-shim/index';
+
+import type RTCDataChannel from './RTCDataChannel';
+
+type DATA_CHANNEL_EVENTS =  'open'| 'message'| 'bufferedamountlow'| 'closing'| 'close'| 'error' | 'datachannel';
+
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    channel: RTCDataChannel;
+}
+
+
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel has changed in any way.
+ * @param {DATA_CHANNEL_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel#events MDN} for details.
+ */
+export default class RTCDataChannelEvent<
+TEventType extends DATA_CHANNEL_EVENTS
+> extends Event<TEventType> {
+    /** @eventProperty */
+    channel: RTCDataChannel;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict) {
+        super(type, eventInitDict);
+        this.channel = eventInitDict.channel;
+    }
+}

package/src/RTCDataPacketCryptor.ts

@@ -0,0 +1,90 @@
+import * as base64 from 'base64-js';
+import { NativeModules } from 'react-native';
+
+import Logger from './Logger';
+const { WebRTCModule } = NativeModules;
+const log = new Logger('pc');
+
+export interface RTCEncryptedPacket {
+  payload: Uint8Array,
+  iv: Uint8Array,
+  keyIndex: number,
+}
+
+export default class RTCDataPacketCryptor {
+    _id: string;
+
+    constructor(dataPacketCryptorId: string) {
+        this._id = dataPacketCryptorId;
+    }
+
+    async encrypt(participantId: string, keyIndex: number, data: Uint8Array): Promise<RTCEncryptedPacket | null> {
+        const params = {
+            dataPacketCryptorId: this._id,
+            participantId,
+            keyIndex,
+            data: base64.fromByteArray(data)
+        };
+
+        const result = await WebRTCModule.dataPacketCryptorEncrypt(params);
+
+        if (!result) {
+            log.info('encrypt: result null');
+
+            return null;
+        }
+
+        if (result.payload === undefined) {
+            log.info('encrypt: payload null');
+
+            return null;
+        }
+
+        if (result.iv === undefined) {
+            log.info('encrypt: iv null');
+
+            return null;
+        }
+
+        if (result.keyIndex === undefined) {
+            log.info('encrypt: keyIndex null');
+
+            return null;
+        }
+
+        return {
+            payload: base64.toByteArray(result.payload),
+            iv: base64.toByteArray(result.iv),
+            keyIndex: result.keyIndex
+        };
+    }
+
+    async decrypt(participantId: string, packet: RTCEncryptedPacket): Promise<Uint8Array | null> {
+        const params = {
+            dataPacketCryptorId: this._id,
+            participantId,
+            payload: base64.fromByteArray(packet.payload),
+            iv: base64.fromByteArray(packet.iv),
+            keyIndex: packet.keyIndex,
+        };
+
+        const result = await WebRTCModule.dataPacketCryptorDecrypt(params);
+
+        if (!result) {
+            log.info('decrypt: result null');
+
+            return null;
+        }
+
+        return base64.toByteArray(result.data);
+    }
+
+
+    async dispose() {
+        const params = {
+            dataPacketCryptorId: this._id,
+        };
+
+        await WebRTCModule.dataPacketCryptorDispose(params);
+    }
+}

package/src/RTCDataPacketCryptorFactory.ts

@@ -0,0 +1,25 @@
+import { NativeModules } from 'react-native';
+
+import RTCDataPacketCryptor from './RTCDataPacketCryptor';
+import RTCFrameCryptorAlgorithm from './RTCFrameCryptorFactory';
+import RTCKeyProvider from './RTCKeyProvider';
+const { WebRTCModule } = NativeModules;
+
+export default class RTCDataPacketCryptorFactory {
+    static async createDataPacketCryptor(
+        algorithm: RTCFrameCryptorAlgorithm,
+        keyProvider: RTCKeyProvider
+    ): Promise<RTCDataPacketCryptor> {
+        const params = {
+            'algorithm': algorithm,
+            'keyProviderId': keyProvider._id
+        };
+        const result = await WebRTCModule.dataPacketCryptorFactoryCreateDataPacketCryptor(params);
+
+        if (!result) {
+            throw new Error('Error when creating data packet cryptor for sender');
+        }
+
+        return new RTCDataPacketCryptor(result.dataPacketCryptorId);
+    }
+}

package/src/RTCErrorEvent.ts

@@ -0,0 +1,21 @@
+import { Event } from 'event-target-shim/index';
+
+type RTCPeerConnectionErrorFunc =
+    | 'addTransceiver'
+    | 'getTransceivers'
+    | 'addTrack'
+    | 'removeTrack';
+
+/**
+ * @brief This class Represents internal error happening on the native side as
+ * part of asynchronous invocations to synchronous web APIs.
+ */
+export default class RTCErrorEvent<TEventType extends RTCPeerConnectionErrorFunc> extends Event<TEventType> {
+    readonly func: RTCPeerConnectionErrorFunc;
+    readonly message: string;
+    constructor(type: TEventType, func: RTCPeerConnectionErrorFunc, message: string) {
+        super(type);
+        this.func = func;
+        this.message = message;
+    }
+}

package/src/RTCFrameCryptor.ts

@@ -0,0 +1,163 @@
+import { Event, EventTarget, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import { addListener, removeListener } from './EventEmitter';
+import Logger from './Logger';
+const { WebRTCModule } = NativeModules;
+
+const log = new Logger('pc');
+
+type FRAME_CRYPTOR_EVENTS =  'onframecryptorstatechanged';
+
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    frameCryptor: RTCFrameCryptor;
+    state: RTCFrameCryptorState;
+}
+
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel has changed in any way.
+ * @param {FRAME_CRYPTOR_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel#events MDN} for details.
+ */
+export class RTCFrameCryptorStateEvent<
+TEventType extends FRAME_CRYPTOR_EVENTS
+> extends Event<TEventType> {
+    /** @eventProperty */
+    frameCryptor: RTCFrameCryptor;
+    /** @eventProperty */
+    state: RTCFrameCryptorState;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict) {
+        super(type, eventInitDict);
+        this.frameCryptor = eventInitDict.frameCryptor;
+        this.state = eventInitDict.state;
+    }
+}
+
+type RTCFrameCryptorEventMap = {
+    onframecryptorstatechanged: RTCFrameCryptorStateEvent<'onframecryptorstatechanged'>;
+}
+
+export enum RTCFrameCryptorState {
+    FrameCryptorStateNew,
+    FrameCryptorStateOk,
+    FrameCryptorStateEncryptionFailed,
+    FrameCryptorStateDecryptionFailed,
+    FrameCryptorStateMissingKey,
+    FrameCryptorStateKeyRatcheted,
+    FrameCryptorStateInternalError,
+}
+
+export default class RTCFrameCryptor extends EventTarget<RTCFrameCryptorEventMap> {
+    private _frameCryptorId: string;
+    private _participantId: string;
+
+    constructor(frameCryptorId: string, participantId: string) {
+        super();
+        this._frameCryptorId = frameCryptorId;
+        this._participantId = participantId;
+        this._registerEvents();
+    }
+
+    get id() {
+        return this._frameCryptorId;
+    }
+
+    get participantId() {
+        return this._participantId;
+    }
+
+    _cryptorStateFromString(str: string): RTCFrameCryptorState {
+        switch (str) {
+            case 'new':
+                return RTCFrameCryptorState.FrameCryptorStateNew;
+            case 'ok':
+                return RTCFrameCryptorState.FrameCryptorStateOk;
+            case 'decryptionFailed':
+                return RTCFrameCryptorState.FrameCryptorStateDecryptionFailed;
+            case 'encryptionFailed':
+                return RTCFrameCryptorState.FrameCryptorStateEncryptionFailed;
+            case 'internalError':
+                return RTCFrameCryptorState.FrameCryptorStateInternalError;
+            case 'keyRatcheted':
+                return RTCFrameCryptorState.FrameCryptorStateKeyRatcheted;
+            case 'missingKey':
+                return RTCFrameCryptorState.FrameCryptorStateMissingKey;
+            default:
+                throw 'Unknown FrameCryptorState: $str';
+        }
+    }
+
+    async setKeyIndex(keyIndex: number): Promise<boolean> {
+        const params = {
+            frameCryptorId: this._frameCryptorId,
+            keyIndex,
+        };
+
+        return WebRTCModule.frameCryptorSetKeyIndex(params)
+            .then(data => data['result']);
+    }
+
+    async getKeyIndex(): Promise<number> {
+        const params = {
+            frameCryptorId: this._frameCryptorId,
+        };
+
+        return WebRTCModule.frameCryptorGetKeyIndex(params)
+            .then(data => data['keyIndex']);
+    }
+
+    async setEnabled(enabled: boolean): Promise<boolean> {
+        const params = {
+            frameCryptorId: this._frameCryptorId,
+            enabled,
+        };
+
+        return WebRTCModule.frameCryptorSetEnabled(params)
+            .then(data => data['result']);
+    }
+
+    async getEnabled(): Promise<boolean> {
+        const params = {
+            frameCryptorId: this._frameCryptorId,
+        };
+
+        return WebRTCModule.frameCryptorGetEnabled(params)
+            .then(data => data['enabled']);
+    }
+
+    async dispose(): Promise<void> {
+        const params = {
+            frameCryptorId: this._frameCryptorId,
+        };
+
+        await WebRTCModule.frameCryptorDispose(params);
+        removeListener(this);
+    }
+
+
+    _registerEvents(): void {
+        addListener(this, 'frameCryptionStateChanged', (ev: any) => {
+            if (ev.participantId !== this._participantId || ev.frameCryptorId !== this._frameCryptorId) {
+                return;
+            }
+
+            log.debug(`${this.id} frameCryptionStateChanged ${ev.state}`);
+
+            const initDict = {
+                frameCryptor: this,
+                state: ev.state,
+            };
+
+            this.dispatchEvent(new RTCFrameCryptorStateEvent('onframecryptorstatechanged', initDict));
+        });
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = RTCFrameCryptor.prototype;
+
+defineEventAttribute(proto, 'onframecryptorstatechanged');

package/src/RTCFrameCryptorFactory.ts

@@ -0,0 +1,102 @@
+import * as base64 from 'base64-js';
+import { NativeModules } from 'react-native';
+
+import RTCFrameCryptor from './RTCFrameCryptor';
+import RTCKeyProvider from './RTCKeyProvider';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+const { WebRTCModule } = NativeModules;
+
+export enum RTCFrameCryptorAlgorithm {
+  kAesGcm = 0,
+  // kAesCbc = 1,
+}
+
+export type RTCKeyProviderOptions = {
+  sharedKey: boolean,
+  ratchetSalt: string | Uint8Array,
+  ratchetWindowSize: number,
+  uncryptedMagicBytes?: Uint8Array,
+  failureTolerance?: number,
+  keyRingSize?: number,
+  discardFrameWhenCryptorNotReady?: boolean
+}
+
+export default class RTCFrameCryptorFactory {
+    static createFrameCryptorForRtpSender(
+        participantId: string,
+        sender: RTCRtpSender,
+        algorithm: RTCFrameCryptorAlgorithm,
+        keyProvider: RTCKeyProvider
+    ): RTCFrameCryptor {
+        const params = {
+            'peerConnectionId': sender._peerConnectionId,
+            'rtpSenderId': sender._id,
+            participantId,
+            'keyProviderId': keyProvider._id,
+            'type': 'sender',
+            'algorithm': algorithm
+        };
+        const result = WebRTCModule.frameCryptorFactoryCreateFrameCryptor(params);
+
+        if (!result) {
+            throw new Error('Error when creating frame cryptor for sender');
+        }
+
+        return new RTCFrameCryptor(result, participantId);
+    }
+    static createFrameCryptorForRtpReceiver(
+        participantId: string,
+        receiver: RTCRtpReceiver,
+        algorithm: RTCFrameCryptorAlgorithm,
+        keyProvider: RTCKeyProvider
+    ): RTCFrameCryptor {
+        const params = {
+            'peerConnectionId': receiver._peerConnectionId,
+            'rtpReceiverId': receiver._id,
+            participantId,
+            'keyProviderId': keyProvider._id,
+            'type': 'receiver',
+            'algorithm': algorithm
+        };
+        const result = WebRTCModule.frameCryptorFactoryCreateFrameCryptor(params);
+
+        if (!result) {
+            throw new Error('Error when creating frame cryptor for receiver');
+        }
+
+        return new RTCFrameCryptor(result, participantId);
+    }
+
+    static createDefaultKeyProvider(options: RTCKeyProviderOptions): RTCKeyProvider {
+        const params = {
+            'sharedKey': options.sharedKey,
+            'ratchetWindowSize': options.ratchetWindowSize,
+            'failureTolerance': options.failureTolerance ?? -1,
+            'keyRingSize': options.keyRingSize ?? 16,
+            'discardFrameWhenCryptorNotReady': options.discardFrameWhenCryptorNotReady ?? false
+        };
+
+        if (typeof options.ratchetSalt === 'string') {
+            params['ratchetSalt'] = options.ratchetSalt;
+            params['ratchetSaltIsBase64'] = false;
+        } else {
+            const bytes = options.ratchetSalt as Uint8Array;
+
+            params['ratchetSalt'] = base64.fromByteArray(bytes);
+            params['ratchetSaltIsBase64'] = true;
+        }
+
+        if (options.uncryptedMagicBytes) {
+            params['uncryptedMagicBytes'] = base64.fromByteArray(options.uncryptedMagicBytes);
+        }
+
+        const result = WebRTCModule.frameCryptorFactoryCreateKeyProvider(params);
+
+        if (!result) {
+            throw new Error('Error when creating key provider!');
+        }
+
+        return new RTCKeyProvider(result);
+    }
+}

package/src/RTCIceCandidate.ts

@@ -0,0 +1,29 @@
+interface RTCIceCandidateInfo {
+    candidate?: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+}
+
+export default class RTCIceCandidate {
+    candidate: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+
+    constructor({ candidate = '', sdpMLineIndex = null, sdpMid = null }: RTCIceCandidateInfo) {
+        if (sdpMLineIndex === null && sdpMid === null) {
+            throw new TypeError('`sdpMLineIndex` and `sdpMid` must not be both null');
+        }
+
+        this.candidate = candidate;
+        this.sdpMLineIndex = sdpMLineIndex;
+        this.sdpMid = sdpMid;
+    }
+
+    toJSON() {
+        return {
+            candidate: this.candidate,
+            sdpMLineIndex: this.sdpMLineIndex,
+            sdpMid: this.sdpMid
+        };
+    }
+}

package/src/RTCIceCandidateEvent.ts

@@ -0,0 +1,26 @@
+import { Event } from 'event-target-shim/index';
+
+import type RTCIceCandidate from './RTCIceCandidate';
+
+type RTC_ICECANDIDATE_EVENTS = 'icecandidate' | 'icecandidateerror'
+
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    candidate: RTCIceCandidate | null
+}
+
+/**
+ * @eventClass
+ * This event is fired whenever the icecandidate related RTC_EVENTS changed.
+ * @type {RTCIceCandidateEvent} for icecandidate related.
+ * @param {RTC_ICECANDIDATE_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection#events MDN} for details.
+ */
+export default class RTCIceCandidateEvent<TEventType extends RTC_ICECANDIDATE_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    candidate: RTCIceCandidate | null;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict) {
+        super(type, eventInitDict);
+        this.candidate = eventInitDict?.candidate ?? null;
+    }
+}

package/src/RTCKeyProvider.ts

@@ -0,0 +1,117 @@
+import * as base64 from 'base64-js';
+import { NativeModules } from 'react-native';
+const { WebRTCModule } = NativeModules;
+
+export enum FrameCryptorState {
+  FrameCryptorStateNew,
+  FrameCryptorStateOk,
+  FrameCryptorStateEncryptionFailed,
+  FrameCryptorStateDecryptionFailed,
+  FrameCryptorStateMissingKey,
+  FrameCryptorStateKeyRatcheted,
+  FrameCryptorStateInternalError,
+}
+
+export default class RTCKeyProvider {
+    _id: string;
+
+    constructor(keyProviderId: string) {
+        this._id = keyProviderId;
+    }
+
+    async setSharedKey(key: string | Uint8Array, keyIndex = 0) {
+        const params = {
+            keyProviderId: this._id,
+            keyIndex,
+        };
+
+        if (typeof key === 'string') {
+            params['key'] = key;
+            params['keyIsBase64'] = false;
+        } else {
+            params['key'] = base64.fromByteArray(key as Uint8Array);
+            params['keyIsBase64'] = true;
+        }
+
+        return WebRTCModule.keyProviderSetSharedKey(params)
+            .then(data => data['result']);
+    }
+
+    async ratchetSharedKey(keyIndex = 0): Promise<Uint8Array> {
+        const params = {
+            keyProviderId: this._id,
+            keyIndex,
+        };
+
+        return WebRTCModule.keyProviderRatchetSharedKey(params)
+            .then(data => base64.toByteArray(data['result']));
+    }
+
+    async exportSharedKey(keyIndex = 0): Promise<Uint8Array> {
+        const params = {
+            keyProviderId: this._id,
+            keyIndex,
+        };
+
+        return WebRTCModule.keyProviderExportSharedKey(params)
+            .then(data => base64.toByteArray(data['result']));
+    }
+
+    async setKey(participantId: string, key: string | Uint8Array, keyIndex = 0): Promise<boolean> {
+        const params = {
+            keyProviderId: this._id,
+            participantId,
+            keyIndex,
+        };
+
+        if (typeof key === 'string') {
+            params['key'] = key;
+            params['keyIsBase64'] = false;
+        } else {
+            params['key'] = base64.fromByteArray(key as Uint8Array);
+            params['keyIsBase64'] = true;
+        }
+
+        return WebRTCModule.keyProviderSetKey(params)
+            .then(data => data['result']);
+    }
+
+    async ratchetKey(participantId: string, keyIndex = 0): Promise<Uint8Array> {
+        const params = {
+            keyProviderId: this._id,
+            participantId,
+            keyIndex,
+        };
+
+        return WebRTCModule.keyProviderRatchetKey(params)
+            .then(data => base64.toByteArray(data['result']));
+    }
+
+    async exportKey(participantId: string, keyIndex = 0): Promise<Uint8Array> {
+        const params = {
+            keyProviderId: this._id,
+            participantId,
+            keyIndex,
+        };
+
+        return WebRTCModule.keyProviderExportKey(params)
+            .then(data => base64.toByteArray(data['result']));
+    }
+
+    async setSifTrailer(trailer: Uint8Array) {
+        const params = {
+            keyProviderId: this._id,
+            'sifTrailer': base64.fromByteArray(trailer),
+        };
+
+        return WebRTCModule.keyProviderSetSifTrailer(params);
+    }
+
+    async dispose() {
+        const params = {
+            keyProviderId: this._id,
+        };
+
+        return WebRTCModule.keyProviderDispose(params);
+    }
+}

package/src/RTCPIPView.tsx

@@ -0,0 +1,47 @@
+import { Component, forwardRef } from 'react';
+import ReactNative, { UIManager } from 'react-native';
+
+import RTCView, { RTCIOSPIPOptions, RTCVideoViewProps } from './RTCView';
+
+export interface RTCPIPViewProps extends RTCVideoViewProps {
+  iosPIP?: RTCIOSPIPOptions & {
+    fallbackView?: Component;
+  };
+}
+
+type RTCViewInstance = InstanceType<typeof RTCView>;
+
+/**
+ * A convenience wrapper around RTCView to handle the fallback view as a prop.
+ */
+const RTCPIPView = forwardRef<RTCViewInstance, RTCPIPViewProps>((props, ref) => {
+    const rtcViewProps = { ...props };
+    const fallbackView = rtcViewProps.iosPIP?.fallbackView;
+
+    delete rtcViewProps.iosPIP?.fallbackView;
+
+    return (
+        <RTCView ref={ref}
+            {...rtcViewProps}>
+            {fallbackView}
+        </RTCView>
+    );
+});
+
+export function startIOSPIP(ref) {
+    UIManager.dispatchViewManagerCommand(
+        ReactNative.findNodeHandle(ref.current),
+        UIManager.getViewManagerConfig('RTCVideoView').Commands.startIOSPIP,
+        []
+    );
+}
+
+export function stopIOSPIP(ref) {
+    UIManager.dispatchViewManagerCommand(
+        ReactNative.findNodeHandle(ref.current),
+        UIManager.getViewManagerConfig('RTCVideoView').Commands.stopIOSPIP,
+        []
+    );
+}
+
+export default RTCPIPView;

package/src/RTCPIPView.web.tsx

@@ -0,0 +1,18 @@
+import React, { forwardRef } from 'react';
+
+import RTCView, { RTCIOSPIPOptions, RTCVideoViewProps } from './RTCView.web';
+
+export type RTCPIPViewProps = RTCVideoViewProps & {
+  fallbackView?: React.ReactNode;
+  iosPIP?: RTCIOSPIPOptions;
+};
+
+const RTCPIPView = forwardRef<unknown, RTCPIPViewProps>(props => <RTCView {...props} />);
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function startIOSPIP() {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function stopIOSPIP() {}
+
+export default RTCPIPView;