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

package/src/RTCDataChannel.ts

@@ -1,190 +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');
+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

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

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

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