@sbhjt-gr/react-native-webrtc 137.0.2

package/src/Permissions.ts

@@ -0,0 +1,133 @@
+
+import { NativeModules, Permission, PermissionsAndroid, Platform } from 'react-native';
+
+const { WebRTCModule } = NativeModules;
+
+/**
+ * Type declaration for a permissions descriptor.
+ */
+type PermissionDescriptor = {
+    name: string;
+};
+
+/**
+ * Class implementing a subset of W3C's Permissions API as defined by:
+ * https://www.w3.org/TR/permissions/
+ */
+class Permissions {
+    /**
+     * Possible result values for {@link query}, in accordance with:
+     * https://www.w3.org/TR/permissions/#status-of-a-permission
+     */
+    RESULT = {
+        DENIED: 'denied',
+        GRANTED: 'granted',
+        PROMPT: 'prompt'
+    };
+
+    /**
+     * This implementation only supports requesting these permissions, a subset
+     * of: https://www.w3.org/TR/permissions/#permission-registry
+     */
+    VALID_PERMISSIONS = [ 'camera', 'microphone' ];
+
+    _lastReq: Promise<unknown> = Promise.resolve();
+
+    /**
+     * Helper for requesting Android permissions. On Android only one permission
+     * can be requested at a time (unless the multi-permission API is used,
+     * but we are not using that for symmetry with the W3C API for querying)
+     * so we'll queue them up.
+     *
+     * @param perm - The requested permission from
+     * {@link PermissionsAndroid.PERMISSIONS}
+     * https://facebook.github.io/react-native/docs/permissionsandroid#permissions-that-require-prompting-the-user
+     */
+    _requestPermissionAndroid(perm: Permission) {
+        return new Promise(resolve => {
+            PermissionsAndroid.request(perm).then(
+                granted => resolve(granted === PermissionsAndroid.RESULTS.GRANTED),
+                () => resolve(false)
+            );
+        });
+    }
+
+    /**
+     * Validates the given permission descriptor.
+     */
+    _validatePermissionDescriptior(permissionDesc) {
+        if (typeof permissionDesc !== 'object') {
+            throw new TypeError('Argument 1 of Permissions.query is not an object.');
+        }
+
+        if (typeof permissionDesc.name === 'undefined') {
+            throw new TypeError('Missing required \'name\' member of PermissionDescriptor.');
+        }
+
+        if (this.VALID_PERMISSIONS.indexOf(permissionDesc.name) === -1) {
+            throw new TypeError(
+                '\'name\' member of PermissionDescriptor is not a valid value for enumeration PermissionName.'
+            );
+        }
+    }
+
+    /**
+     * Method for querying the status of a permission, according to:
+     * https://www.w3.org/TR/permissions/#permissions-interface
+     */
+    query(permissionDesc: PermissionDescriptor) {
+        try {
+            this._validatePermissionDescriptior(permissionDesc);
+        } catch (e) {
+            return Promise.reject(e);
+        }
+
+        if (Platform.OS === 'android') {
+            const perm =
+                permissionDesc.name === 'camera'
+                    ? PermissionsAndroid.PERMISSIONS.CAMERA
+                    : PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+
+            return new Promise(resolve => {
+                PermissionsAndroid.check(perm).then(
+                    granted => resolve(granted ? this.RESULT.GRANTED : this.RESULT.PROMPT),
+                    () => resolve(this.RESULT.PROMPT)
+                );
+            });
+        } else if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+            return WebRTCModule.checkPermission(permissionDesc.name);
+        } else {
+            return Promise.reject(new TypeError('Unsupported platform.'));
+        }
+    }
+
+    /**
+     * Custom method NOT defined by W3C's permissions API, which allows the
+     * caller to request a permission.
+     */
+    request(permissionDesc: PermissionDescriptor) {
+        try {
+            this._validatePermissionDescriptior(permissionDesc);
+        } catch (e) {
+            return Promise.reject(e);
+        }
+
+        if (Platform.OS === 'android') {
+            const perm =
+                permissionDesc.name === 'camera'
+                    ? PermissionsAndroid.PERMISSIONS.CAMERA
+                    : PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+            const requestPermission = () => this._requestPermissionAndroid(perm);
+
+            this._lastReq = this._lastReq.then(requestPermission, requestPermission);
+
+            return this._lastReq;
+        } else if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+            return WebRTCModule.requestPermission(permissionDesc.name);
+        } else {
+            return Promise.reject(new TypeError('Unsupported platform.'));
+        }
+    }
+}
+
+export default new Permissions();

package/src/RTCAudioSession.ts

@@ -0,0 +1,25 @@
+import { NativeModules, Platform } from 'react-native';
+
+const { WebRTCModule } = NativeModules;
+
+export default class RTCAudioSession {
+    /**
+     * To be called when CallKit activates the audio session.
+     */
+    static audioSessionDidActivate() {
+        // Only valid for iOS
+        if (Platform.OS === 'ios') {
+            WebRTCModule.audioSessionDidActivate();
+        }
+    }
+
+    /**
+     * To be called when CallKit deactivates the audio session.
+     */
+    static audioSessionDidDeactivate() {
+        // Only valid for iOS
+        if (Platform.OS === 'ios') {
+            WebRTCModule.audioSessionDidDeactivate();
+        }
+    }
+}

package/src/RTCDataChannel.ts

@@ -0,0 +1,190 @@
+import * as base64 from 'base64-js';
+import { EventTarget, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import { addListener, removeListener } from './EventEmitter';
+import MessageEvent from './MessageEvent';
+import RTCDataChannelEvent from './RTCDataChannelEvent';
+
+const { WebRTCModule } = NativeModules;
+
+type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+
+type DataChannelEventMap = {
+    bufferedamountlow: RTCDataChannelEvent<'bufferedamountlow'>;
+    close: RTCDataChannelEvent<'close'>;
+    closing: RTCDataChannelEvent<'closing'>;
+    error: RTCDataChannelEvent<'error'>;
+    message: MessageEvent<'message'>;
+    open: RTCDataChannelEvent<'open'>;
+};
+
+export default class RTCDataChannel extends EventTarget<DataChannelEventMap> {
+    _peerConnectionId: number;
+    _reactTag: string;
+
+    _bufferedAmount: number;
+    _id: number;
+    _label: string;
+    _maxPacketLifeTime?: number;
+    _maxRetransmits?: number;
+    _negotiated: boolean;
+    _ordered: boolean;
+    _protocol: string;
+    _readyState: RTCDataChannelState;
+
+    binaryType = 'arraybuffer'; // we only support 'arraybuffer'
+    bufferedAmountLowThreshold = 0;
+
+    constructor(info) {
+        super();
+
+        this._peerConnectionId = info.peerConnectionId;
+        this._reactTag = info.reactTag;
+
+        this._bufferedAmount = 0;
+        this._label = info.label;
+        this._id = info.id === -1 ? null : info.id; // null until negotiated.
+        this._ordered = Boolean(info.ordered);
+        this._maxPacketLifeTime = info.maxPacketLifeTime;
+        this._maxRetransmits = info.maxRetransmits;
+        this._protocol = info.protocol || '';
+        this._negotiated = Boolean(info.negotiated);
+        this._readyState = info.readyState;
+
+        this._registerEvents();
+    }
+
+    get bufferedAmount(): number {
+        return this._bufferedAmount;
+    }
+
+    get label(): string {
+        return this._label;
+    }
+
+    get id(): number {
+        return this._id;
+    }
+
+    get ordered(): boolean {
+        return this._ordered;
+    }
+
+    get maxPacketLifeTime(): number | undefined {
+        return this._maxPacketLifeTime;
+    }
+
+    get maxRetransmits(): number | undefined {
+        return this._maxRetransmits;
+    }
+
+    get protocol(): string {
+        return this._protocol;
+    }
+
+    get negotiated(): boolean {
+        return this._negotiated;
+    }
+
+    get readyState(): string {
+        return this._readyState;
+    }
+
+    send(data: string): void;
+    send(data: ArrayBuffer): void;
+    send(data: ArrayBufferView): void;
+    send(data: string | ArrayBuffer | ArrayBufferView): void {
+        if (typeof data === 'string') {
+            WebRTCModule.dataChannelSend(this._peerConnectionId, this._reactTag, data, 'text');
+
+            return;
+        }
+
+        // Safely convert the buffer object to an Uint8Array for base64-encoding
+        if (ArrayBuffer.isView(data)) {
+            data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        } else if (data instanceof ArrayBuffer) {
+            data = new Uint8Array(data);
+        } else {
+            throw new TypeError('Data must be either string, ArrayBuffer, or ArrayBufferView');
+        }
+
+        const base64data = base64.fromByteArray(data as Uint8Array);
+
+        WebRTCModule.dataChannelSend(this._peerConnectionId, this._reactTag, base64data, 'binary');
+    }
+
+    close(): void {
+        if (this._readyState === 'closing' || this._readyState === 'closed') {
+            return;
+        }
+
+        WebRTCModule.dataChannelClose(this._peerConnectionId, this._reactTag);
+    }
+
+    _registerEvents(): void {
+        addListener(this, 'dataChannelStateChanged', (ev: any) => {
+            if (ev.reactTag !== this._reactTag) {
+                return;
+            }
+
+            this._readyState = ev.state;
+
+            if (this._id === null && ev.id !== -1) {
+                this._id = ev.id;
+            }
+
+            if (this._readyState === 'open') {
+                this.dispatchEvent(new RTCDataChannelEvent('open', { channel: this }));
+            } else if (this._readyState === 'closing') {
+                this.dispatchEvent(new RTCDataChannelEvent('closing', { channel: this }));
+            } else if (this._readyState === 'closed') {
+                this.dispatchEvent(new RTCDataChannelEvent('close', { channel: this }));
+
+                // This DataChannel is done, clean up event handlers.
+                removeListener(this);
+
+                WebRTCModule.dataChannelDispose(this._peerConnectionId, this._reactTag);
+            }
+        });
+
+        addListener(this, 'dataChannelReceiveMessage', (ev: any) => {
+            if (ev.reactTag !== this._reactTag) {
+                return;
+            }
+
+            let data = ev.data;
+
+            if (ev.type === 'binary') {
+                data = base64.toByteArray(ev.data).buffer;
+            }
+
+            this.dispatchEvent(new MessageEvent('message', { data }));
+        });
+
+        addListener(this, 'dataChannelDidChangeBufferedAmount', (ev: any) => {
+            if (ev.reactTag !== this._reactTag) {
+                return;
+            }
+
+            this._bufferedAmount = ev.bufferedAmount;
+
+            if (this._bufferedAmount < this.bufferedAmountLowThreshold) {
+                this.dispatchEvent(new RTCDataChannelEvent('bufferedamountlow', { channel: this }));
+            }
+        });
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = RTCDataChannel.prototype;
+
+defineEventAttribute(proto, 'bufferedamountlow');
+defineEventAttribute(proto, 'close');
+defineEventAttribute(proto, 'closing');
+defineEventAttribute(proto, 'error');
+defineEventAttribute(proto, 'message');
+defineEventAttribute(proto, 'open');

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');