@sbhjt-gr/react-native-webrtc 137.0.2

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;