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

package/src/RTCRtpSendParameters.ts

@@ -1,63 +1,63 @@
-import RTCRtpEncodingParameters, { RTCRtpEncodingParametersInit } from './RTCRtpEncodingParameters';
-import RTCRtpParameters, { RTCRtpParametersInit } from './RTCRtpParameters';
-import { deepClone } from './RTCUtil';
-
-type DegradationPreferenceType = 'maintain-framerate'
-    | 'maintain-resolution'
-    | 'balanced'
-    | 'disabled'
-
-
-/**
- * Class to convert degradation preference format. Native has a format such as
- * MAINTAIN_FRAMERATE whereas the web APIs expect maintain-framerate
- */
-class DegradationPreference {
-    static fromNative(nativeFormat: string): DegradationPreferenceType {
-        const stringFormat = nativeFormat.toLowerCase().replace('_', '-');
-
-        return stringFormat as DegradationPreferenceType;
-    }
-
-    static toNative(format: DegradationPreferenceType): string {
-        return format.toUpperCase().replace('-', '_');
-    }
-}
-
-export interface RTCRtpSendParametersInit extends RTCRtpParametersInit {
-    transactionId: string;
-    encodings: RTCRtpEncodingParametersInit[];
-    degradationPreference?: string;
-}
-
-export default class RTCRtpSendParameters extends RTCRtpParameters {
-    readonly transactionId: string;
-    encodings: (RTCRtpEncodingParameters | RTCRtpEncodingParametersInit)[];
-    degradationPreference: DegradationPreferenceType | null;
-
-    constructor(init: RTCRtpSendParametersInit) {
-        super(init);
-
-        this.transactionId = init.transactionId;
-        this.encodings = [];
-        this.degradationPreference = init.degradationPreference ?
-            DegradationPreference.fromNative(init.degradationPreference) : null;
-
-        for (const enc of init.encodings) {
-            this.encodings.push(new RTCRtpEncodingParameters(enc));
-        }
-    }
-
-    toJSON() {
-        const obj = super.toJSON();
-
-        obj['transactionId'] = this.transactionId;
-        obj['encodings'] = this.encodings.map(e => deepClone(e));
-
-        if (this.degradationPreference !== null) {
-            obj['degradationPreference'] = DegradationPreference.toNative(this.degradationPreference);
-        }
-
-        return obj;
-    }
-}
+import RTCRtpEncodingParameters, { RTCRtpEncodingParametersInit } from './RTCRtpEncodingParameters';
+import RTCRtpParameters, { RTCRtpParametersInit } from './RTCRtpParameters';
+import { deepClone } from './RTCUtil';
+
+type DegradationPreferenceType = 'maintain-framerate'
+    | 'maintain-resolution'
+    | 'balanced'
+    | 'disabled'
+
+
+/**
+ * Class to convert degradation preference format. Native has a format such as
+ * MAINTAIN_FRAMERATE whereas the web APIs expect maintain-framerate
+ */
+class DegradationPreference {
+    static fromNative(nativeFormat: string): DegradationPreferenceType {
+        const stringFormat = nativeFormat.toLowerCase().replace('_', '-');
+
+        return stringFormat as DegradationPreferenceType;
+    }
+
+    static toNative(format: DegradationPreferenceType): string {
+        return format.toUpperCase().replace('-', '_');
+    }
+}
+
+export interface RTCRtpSendParametersInit extends RTCRtpParametersInit {
+    transactionId: string;
+    encodings: RTCRtpEncodingParametersInit[];
+    degradationPreference?: string;
+}
+
+export default class RTCRtpSendParameters extends RTCRtpParameters {
+    readonly transactionId: string;
+    encodings: (RTCRtpEncodingParameters | RTCRtpEncodingParametersInit)[];
+    degradationPreference: DegradationPreferenceType | null;
+
+    constructor(init: RTCRtpSendParametersInit) {
+        super(init);
+
+        this.transactionId = init.transactionId;
+        this.encodings = [];
+        this.degradationPreference = init.degradationPreference ?
+            DegradationPreference.fromNative(init.degradationPreference) : null;
+
+        for (const enc of init.encodings) {
+            this.encodings.push(new RTCRtpEncodingParameters(enc));
+        }
+    }
+
+    toJSON() {
+        const obj = super.toJSON();
+
+        obj['transactionId'] = this.transactionId;
+        obj['encodings'] = this.encodings.map(e => deepClone(e));
+
+        if (this.degradationPreference !== null) {
+            obj['degradationPreference'] = DegradationPreference.toNative(this.degradationPreference);
+        }
+
+        return obj;
+    }
+}

package/src/RTCRtpSender.ts

@@ -1,78 +1,78 @@
-import { NativeModules } from 'react-native';
-
-import MediaStreamTrack from './MediaStreamTrack';
-import RTCRtpCapabilities from './RTCRtpCapabilities';
-import RTCRtpSendParameters, { RTCRtpSendParametersInit } from './RTCRtpSendParameters';
-
-const { WebRTCModule } = NativeModules;
-
-
-export default class RTCRtpSender {
-    _id: string;
-    _track: MediaStreamTrack | null = null;
-    _peerConnectionId: number;
-    _rtpParameters: RTCRtpSendParameters;
-
-    constructor(info: {
-        peerConnectionId: number,
-        id: string,
-        track?: MediaStreamTrack,
-        rtpParameters: RTCRtpSendParametersInit
-    }) {
-        this._peerConnectionId = info.peerConnectionId;
-        this._id = info.id;
-        this._rtpParameters = new RTCRtpSendParameters(info.rtpParameters);
-
-        if (info.track) {
-            this._track = info.track;
-        }
-    }
-
-    async replaceTrack(track: MediaStreamTrack | null): Promise<void> {
-        try {
-            await WebRTCModule.senderReplaceTrack(this._peerConnectionId, this._id, track ? track.id : null);
-        } catch (e) {
-            return;
-        }
-
-        this._track = track;
-    }
-
-    static getCapabilities(kind: 'audio' | 'video'): RTCRtpCapabilities {
-        return WebRTCModule.senderGetCapabilities(kind);
-    }
-
-    getParameters(): RTCRtpSendParameters {
-        return this._rtpParameters;
-    }
-
-    async setParameters(parameters: RTCRtpSendParameters): Promise<void> {
-        // This allows us to get rid of private "underscore properties"
-        const _params = JSON.parse(JSON.stringify(parameters));
-        const newParameters = await WebRTCModule.senderSetParameters(this._peerConnectionId, this._id, _params);
-
-        this._rtpParameters = new RTCRtpSendParameters(newParameters);
-    }
-
-    getStats() {
-        return WebRTCModule.senderGetStats(this._peerConnectionId, this._id).then(data =>
-            /* On both Android and iOS it is faster to construct a single
-            JSON string representing the Map of StatsReports and have it
-            pass through the React Native bridge rather than the Map of
-            StatsReports. While the implementations do try to be faster in
-            general, the stress is on being faster to pass through the React
-            Native bridge which is a bottleneck that tends to be visible in
-            the UI when there is congestion involving UI-related passing.
-            */
-            new Map(JSON.parse(data))
-        );
-    }
-
-    get track() {
-        return this._track;
-    }
-
-    get id() {
-        return this._id;
-    }
-}
+import { NativeModules } from 'react-native';
+
+import MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpCapabilities from './RTCRtpCapabilities';
+import RTCRtpSendParameters, { RTCRtpSendParametersInit } from './RTCRtpSendParameters';
+
+const { WebRTCModule } = NativeModules;
+
+
+export default class RTCRtpSender {
+    _id: string;
+    _track: MediaStreamTrack | null = null;
+    _peerConnectionId: number;
+    _rtpParameters: RTCRtpSendParameters;
+
+    constructor(info: {
+        peerConnectionId: number,
+        id: string,
+        track?: MediaStreamTrack,
+        rtpParameters: RTCRtpSendParametersInit
+    }) {
+        this._peerConnectionId = info.peerConnectionId;
+        this._id = info.id;
+        this._rtpParameters = new RTCRtpSendParameters(info.rtpParameters);
+
+        if (info.track) {
+            this._track = info.track;
+        }
+    }
+
+    async replaceTrack(track: MediaStreamTrack | null): Promise<void> {
+        try {
+            await WebRTCModule.senderReplaceTrack(this._peerConnectionId, this._id, track ? track.id : null);
+        } catch (e) {
+            return;
+        }
+
+        this._track = track;
+    }
+
+    static getCapabilities(kind: 'audio' | 'video'): RTCRtpCapabilities {
+        return WebRTCModule.senderGetCapabilities(kind);
+    }
+
+    getParameters(): RTCRtpSendParameters {
+        return this._rtpParameters;
+    }
+
+    async setParameters(parameters: RTCRtpSendParameters): Promise<void> {
+        // This allows us to get rid of private "underscore properties"
+        const _params = JSON.parse(JSON.stringify(parameters));
+        const newParameters = await WebRTCModule.senderSetParameters(this._peerConnectionId, this._id, _params);
+
+        this._rtpParameters = new RTCRtpSendParameters(newParameters);
+    }
+
+    getStats() {
+        return WebRTCModule.senderGetStats(this._peerConnectionId, this._id).then(data =>
+            /* On both Android and iOS it is faster to construct a single
+            JSON string representing the Map of StatsReports and have it
+            pass through the React Native bridge rather than the Map of
+            StatsReports. While the implementations do try to be faster in
+            general, the stress is on being faster to pass through the React
+            Native bridge which is a bottleneck that tends to be visible in
+            the UI when there is congestion involving UI-related passing.
+            */
+            new Map(JSON.parse(data))
+        );
+    }
+
+    get track() {
+        return this._track;
+    }
+
+    get id() {
+        return this._id;
+    }
+}

package/src/RTCRtpTransceiver.ts

@@ -1,107 +1,107 @@
-import { NativeModules } from 'react-native';
-
-import RTCRtpCodecCapability from './RTCRtpCodecCapability';
-import RTCRtpReceiver from './RTCRtpReceiver';
-import RTCRtpSender from './RTCRtpSender';
-
-const { WebRTCModule } = NativeModules;
-
-export default class RTCRtpTransceiver {
-    _peerConnectionId: number;
-    _sender: RTCRtpSender;
-    _receiver: RTCRtpReceiver;
-
-    _mid: string | null = null;
-    _direction: string;
-    _currentDirection: string;
-    _stopped: boolean;
-
-    constructor(args: {
-        peerConnectionId: number,
-        isStopped: boolean,
-        direction: string,
-        currentDirection: string,
-        mid?: string,
-        sender: RTCRtpSender,
-        receiver: RTCRtpReceiver,
-    }) {
-        this._peerConnectionId = args.peerConnectionId;
-        this._mid = args.mid ?? null;
-        this._direction = args.direction;
-        this._currentDirection = args.currentDirection ?? null;
-        this._stopped = Boolean(args.isStopped);
-        this._sender = args.sender;
-        this._receiver = args.receiver;
-    }
-
-    get mid() {
-        return this._mid;
-    }
-
-    get stopped() {
-        return this._stopped;
-    }
-
-    get direction() {
-        return this._direction;
-    }
-
-    set direction(val) {
-        if (![ 'sendonly', 'recvonly', 'sendrecv', 'inactive' ].includes(val)) {
-            throw new TypeError('Invalid direction provided');
-        }
-
-        if (this._stopped) {
-            throw new Error('Transceiver Stopped');
-        }
-
-        if (this._direction === val) {
-            return;
-        }
-
-        const oldDirection = this._direction;
-
-        WebRTCModule.transceiverSetDirection(this._peerConnectionId, this.sender.id, val)
-            .catch(() => {
-                this._direction = oldDirection;
-            });
-
-        this._direction = val;
-    }
-
-    get currentDirection() {
-        return this._currentDirection;
-    }
-
-    get sender() {
-        return this._sender;
-    }
-
-    get receiver() {
-        return this._receiver;
-    }
-
-    stop() {
-        if (this._stopped) {
-            return;
-        }
-
-        WebRTCModule.transceiverStop(this._peerConnectionId, this.sender.id)
-            .then(() => this._setStopped());
-    }
-
-    setCodecPreferences(codecs: RTCRtpCodecCapability[]) {
-        WebRTCModule.transceiverSetCodecPreferences(
-            this._peerConnectionId,
-            this.sender.id,
-            codecs
-        );
-    }
-
-    _setStopped() {
-        this._stopped = true;
-        this._direction = 'stopped';
-        this._currentDirection = 'stopped';
-        this._mid = null;
-    }
-}
+import { NativeModules } from 'react-native';
+
+import RTCRtpCodecCapability from './RTCRtpCodecCapability';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+
+const { WebRTCModule } = NativeModules;
+
+export default class RTCRtpTransceiver {
+    _peerConnectionId: number;
+    _sender: RTCRtpSender;
+    _receiver: RTCRtpReceiver;
+
+    _mid: string | null = null;
+    _direction: string;
+    _currentDirection: string;
+    _stopped: boolean;
+
+    constructor(args: {
+        peerConnectionId: number,
+        isStopped: boolean,
+        direction: string,
+        currentDirection: string,
+        mid?: string,
+        sender: RTCRtpSender,
+        receiver: RTCRtpReceiver,
+    }) {
+        this._peerConnectionId = args.peerConnectionId;
+        this._mid = args.mid ?? null;
+        this._direction = args.direction;
+        this._currentDirection = args.currentDirection ?? null;
+        this._stopped = Boolean(args.isStopped);
+        this._sender = args.sender;
+        this._receiver = args.receiver;
+    }
+
+    get mid() {
+        return this._mid;
+    }
+
+    get stopped() {
+        return this._stopped;
+    }
+
+    get direction() {
+        return this._direction;
+    }
+
+    set direction(val) {
+        if (![ 'sendonly', 'recvonly', 'sendrecv', 'inactive' ].includes(val)) {
+            throw new TypeError('Invalid direction provided');
+        }
+
+        if (this._stopped) {
+            throw new Error('Transceiver Stopped');
+        }
+
+        if (this._direction === val) {
+            return;
+        }
+
+        const oldDirection = this._direction;
+
+        WebRTCModule.transceiverSetDirection(this._peerConnectionId, this.sender.id, val)
+            .catch(() => {
+                this._direction = oldDirection;
+            });
+
+        this._direction = val;
+    }
+
+    get currentDirection() {
+        return this._currentDirection;
+    }
+
+    get sender() {
+        return this._sender;
+    }
+
+    get receiver() {
+        return this._receiver;
+    }
+
+    stop() {
+        if (this._stopped) {
+            return;
+        }
+
+        WebRTCModule.transceiverStop(this._peerConnectionId, this.sender.id)
+            .then(() => this._setStopped());
+    }
+
+    setCodecPreferences(codecs: RTCRtpCodecCapability[]) {
+        WebRTCModule.transceiverSetCodecPreferences(
+            this._peerConnectionId,
+            this.sender.id,
+            codecs
+        );
+    }
+
+    _setStopped() {
+        this._stopped = true;
+        this._direction = 'stopped';
+        this._currentDirection = 'stopped';
+        this._mid = null;
+    }
+}

package/src/RTCSessionDescription.ts

@@ -1,30 +1,30 @@
-
-export interface RTCSessionDescriptionInit {
-    sdp: string;
-    type: string | null;
-}
-
-export default class RTCSessionDescription {
-    _sdp: string;
-    _type: string | null;
-
-    constructor(info: RTCSessionDescriptionInit = { type: null, sdp: '' }) {
-        this._sdp = info.sdp;
-        this._type = info.type;
-    }
-
-    get sdp(): string {
-        return this._sdp;
-    }
-
-    get type(): string | null {
-        return this._type;
-    }
-
-    toJSON(): RTCSessionDescriptionInit {
-        return {
-            sdp: this._sdp,
-            type: this._type
-        };
-    }
-}
+
+export interface RTCSessionDescriptionInit {
+    sdp: string;
+    type: string | null;
+}
+
+export default class RTCSessionDescription {
+    _sdp: string;
+    _type: string | null;
+
+    constructor(info: RTCSessionDescriptionInit = { type: null, sdp: '' }) {
+        this._sdp = info.sdp;
+        this._type = info.type;
+    }
+
+    get sdp(): string {
+        return this._sdp;
+    }
+
+    get type(): string | null {
+        return this._type;
+    }
+
+    toJSON(): RTCSessionDescriptionInit {
+        return {
+            sdp: this._sdp,
+            type: this._type
+        };
+    }
+}

package/src/RTCTrackEvent.ts

@@ -1,42 +1,42 @@
-import { Event } from 'event-target-shim/index';
-
-import MediaStream from './MediaStream';
-import type MediaStreamTrack from './MediaStreamTrack';
-import RTCRtpReceiver from './RTCRtpReceiver';
-import RTCRtpTransceiver from './RTCRtpTransceiver';
-
-type TRACK_EVENTS = 'track'
-
-interface IRTCTrackEventInitDict extends Event.EventInit {
-    streams: MediaStream[]
-    transceiver: RTCRtpTransceiver
-}
-
-/**
- * @eventClass
- * This event is fired whenever the Track is changed in PeerConnection.
- * @param {TRACK_EVENTS} type - The type of event.
- * @param {IRTCTrackEventInitDict} eventInitDict - The event init properties.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/track_event MDN} for details.
- */
-export default class RTCTrackEvent<TEventType extends TRACK_EVENTS> extends Event<TEventType> {
-    /** @eventProperty */
-    readonly streams: MediaStream[] = [];
-
-    /** @eventProperty */
-    readonly transceiver: RTCRtpTransceiver;
-
-    /** @eventProperty */
-    readonly receiver: RTCRtpReceiver | null;
-
-    /** @eventProperty */
-    readonly track: MediaStreamTrack | null;
-
-    constructor(type: TEventType, eventInitDict: IRTCTrackEventInitDict) {
-        super(type, eventInitDict);
-        this.streams = eventInitDict.streams;
-        this.transceiver = eventInitDict.transceiver;
-        this.receiver = eventInitDict.transceiver.receiver;
-        this.track = eventInitDict.transceiver.receiver ? eventInitDict.transceiver.receiver.track : null;
-    }
-}
+import { Event } from 'event-target-shim/index';
+
+import MediaStream from './MediaStream';
+import type MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpTransceiver from './RTCRtpTransceiver';
+
+type TRACK_EVENTS = 'track'
+
+interface IRTCTrackEventInitDict extends Event.EventInit {
+    streams: MediaStream[]
+    transceiver: RTCRtpTransceiver
+}
+
+/**
+ * @eventClass
+ * This event is fired whenever the Track is changed in PeerConnection.
+ * @param {TRACK_EVENTS} type - The type of event.
+ * @param {IRTCTrackEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/track_event MDN} for details.
+ */
+export default class RTCTrackEvent<TEventType extends TRACK_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    readonly streams: MediaStream[] = [];
+
+    /** @eventProperty */
+    readonly transceiver: RTCRtpTransceiver;
+
+    /** @eventProperty */
+    readonly receiver: RTCRtpReceiver | null;
+
+    /** @eventProperty */
+    readonly track: MediaStreamTrack | null;
+
+    constructor(type: TEventType, eventInitDict: IRTCTrackEventInitDict) {
+        super(type, eventInitDict);
+        this.streams = eventInitDict.streams;
+        this.transceiver = eventInitDict.transceiver;
+        this.receiver = eventInitDict.transceiver.receiver;
+        this.track = eventInitDict.transceiver.receiver ? eventInitDict.transceiver.receiver.track : null;
+    }
+}