@sbhjt-gr/react-native-webrtc 124.0.0 → 124.0.2

package/src/RTCErrorEvent.ts

@@ -1,21 +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;
-    }
+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

@@ -1,163 +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;
-
+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

@@ -1,102 +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);
-    }
+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

@@ -1,29 +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
-        };
-    }
-}
+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
+        };
+    }
+}