@sbhjt-gr/react-native-webrtc 124.0.0

package/src/RTCRtcpParameters.ts

@@ -0,0 +1,23 @@
+export interface RTCRtcpParametersInit {
+    cname: string;
+    reducedSize: boolean;
+}
+
+export default class RTCRtcpParameters {
+    readonly cname: string;
+    readonly reducedSize: boolean;
+
+    constructor(init: RTCRtcpParametersInit) {
+        this.cname = init.cname;
+        this.reducedSize = init.reducedSize;
+
+        Object.freeze(this);
+    }
+
+    toJSON(): RTCRtcpParametersInit {
+        return {
+            cname: this.cname,
+            reducedSize: this.reducedSize
+        };
+    }
+}

package/src/RTCRtpCapabilities.ts

@@ -0,0 +1,16 @@
+import RTCRtpCodecCapability from './RTCRtpCodecCapability';
+
+/**
+ * @brief represents codec capabilities for senders and receivers.
+ */
+export default class RTCRtpCapabilities {
+    _codecs: RTCRtpCodecCapability[] = [];
+    constructor(codecs: RTCRtpCodecCapability[]) {
+        this._codecs = codecs;
+        Object.freeze(this);
+    }
+
+    get codecs() {
+        return this._codecs;
+    }
+}

package/src/RTCRtpCodecCapability.ts

@@ -0,0 +1,13 @@
+
+export default class RTCRtpCodecCapability {
+    _mimeType: string;
+
+    constructor(init: { mimeType: string }) {
+        this._mimeType = init.mimeType;
+        Object.freeze(this);
+    }
+
+    get mimeType() {
+        return this._mimeType;
+    }
+}

package/src/RTCRtpCodecParameters.ts

@@ -0,0 +1,44 @@
+export interface RTCRtpCodecParametersInit {
+    payloadType: number;
+    clockRate: number;
+    mimeType: string;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+
+export default class RTCRtpCodecParameters {
+    readonly payloadType: number;
+    readonly clockRate: number;
+    readonly mimeType: string;
+    readonly channels: number | null;
+    readonly sdpFmtpLine: string | null;
+
+    constructor(init: RTCRtpCodecParametersInit) {
+        this.payloadType = init.payloadType;
+        this.clockRate = init.clockRate;
+        this.mimeType = init.mimeType;
+
+        this.channels = init.channels ? init.channels : null;
+        this.sdpFmtpLine = init.sdpFmtpLine ? init.sdpFmtpLine : null;
+
+        Object.freeze(this);
+    }
+
+    toJSON(): RTCRtpCodecParametersInit {
+        const obj = {
+            payloadType: this.payloadType,
+            clockRate: this.clockRate,
+            mimeType: this.mimeType
+        };
+
+        if (this.channels !== null) {
+            obj['channels'] = this.channels;
+        }
+
+        if (this.sdpFmtpLine !== null) {
+            obj['sdpFmtpLine'] = this.sdpFmtpLine;
+        }
+
+        return obj;
+    }
+}

package/src/RTCRtpEncodingParameters.ts

@@ -0,0 +1,90 @@
+export interface RTCRtpEncodingParametersInit {
+    active: boolean,
+    rid?: string;
+    maxFramerate?: number;
+    maxBitrate?: number;
+    scaleResolutionDownBy?: number;
+}
+
+export default class RTCRtpEncodingParameters {
+    active: boolean;
+    _rid: string | null;
+    _maxFramerate: number | null;
+    _maxBitrate: number | null;
+    _scaleResolutionDownBy: number | null;
+
+    constructor(init: RTCRtpEncodingParametersInit) {
+        this.active = init.active;
+        this._rid = init.rid ?? null;
+        this._maxBitrate = init.maxBitrate ?? null;
+        this._maxFramerate = init.maxFramerate ?? null;
+        this._scaleResolutionDownBy = init.scaleResolutionDownBy ?? null;
+    }
+
+    get rid() {
+        return this._rid;
+    }
+
+    get maxFramerate() {
+        return this._maxFramerate;
+    }
+
+    set maxFramerate(framerate) {
+        // eslint-disable-next-line eqeqeq
+        if (framerate != null && framerate > 0) {
+            this._maxFramerate = framerate;
+        } else {
+            this._maxFramerate = null;
+        }
+    }
+
+    get maxBitrate() {
+        return this._maxBitrate;
+    }
+
+    set maxBitrate(bitrate) {
+        // eslint-disable-next-line eqeqeq
+        if (bitrate != null && bitrate >= 0) {
+            this._maxBitrate = bitrate;
+        } else {
+            this._maxBitrate = null;
+        }
+    }
+
+    get scaleResolutionDownBy() {
+        return this._scaleResolutionDownBy;
+    }
+
+    set scaleResolutionDownBy(resolutionScale) {
+        // eslint-disable-next-line eqeqeq
+        if (resolutionScale != null && resolutionScale >= 1) {
+            this._scaleResolutionDownBy = resolutionScale;
+        } else {
+            this._scaleResolutionDownBy = null;
+        }
+    }
+
+    toJSON(): RTCRtpEncodingParametersInit {
+        const obj = {
+            active: Boolean(this.active),
+        };
+
+        if (this._rid !== null) {
+            obj['rid'] = this._rid;
+        }
+
+        if (this._maxBitrate !== null) {
+            obj['maxBitrate'] = this._maxBitrate;
+        }
+
+        if (this._maxFramerate !== null) {
+            obj['maxFramerate'] = this._maxFramerate;
+        }
+
+        if (this._scaleResolutionDownBy !== null) {
+            obj['scaleResolutionDownBy'] = this._scaleResolutionDownBy;
+        }
+
+        return obj;
+    }
+}

package/src/RTCRtpHeaderExtension.ts

@@ -0,0 +1,27 @@
+export interface RTCRtpHeaderExtensionInit {
+    id: number;
+    uri: string;
+    encrypted: boolean;
+}
+
+export default class RTCRtpHeaderExtension {
+    readonly id: number;
+    readonly uri: string;
+    readonly encrypted: boolean;
+
+    constructor(init: RTCRtpHeaderExtensionInit) {
+        this.id = init.id;
+        this.uri = init.uri;
+        this.encrypted = init.encrypted;
+
+        Object.freeze(this);
+    }
+
+    toJSON(): RTCRtpHeaderExtensionInit {
+        return {
+            id: this.id,
+            uri: this.uri,
+            encrypted: this.encrypted
+        };
+    }
+}

package/src/RTCRtpParameters.ts

@@ -0,0 +1,37 @@
+import RTCRtcpParameters, { RTCRtcpParametersInit } from './RTCRtcpParameters';
+import RTCRtpCodecParameters, { RTCRtpCodecParametersInit } from './RTCRtpCodecParameters';
+import RTCRtpHeaderExtension, { RTCRtpHeaderExtensionInit } from './RTCRtpHeaderExtension';
+import { deepClone } from './RTCUtil';
+
+
+export interface RTCRtpParametersInit {
+    codecs: RTCRtpCodecParametersInit[],
+    headerExtensions: RTCRtpHeaderExtensionInit[],
+    rtcp: RTCRtcpParametersInit
+}
+
+export default class RTCRtpParameters {
+    codecs: (RTCRtpCodecParameters | RTCRtpCodecParametersInit)[] = [];
+    readonly headerExtensions: RTCRtpHeaderExtension[] = [];
+    readonly rtcp: RTCRtcpParameters;
+
+    constructor(init: RTCRtpParametersInit) {
+        for (const codec of init.codecs) {
+            this.codecs.push(new RTCRtpCodecParameters(codec));
+        }
+
+        for (const ext of init.headerExtensions) {
+            this.headerExtensions.push(new RTCRtpHeaderExtension(ext));
+        }
+
+        this.rtcp = new RTCRtcpParameters(init.rtcp);
+    }
+
+    toJSON() {
+        return {
+            codecs: this.codecs.map(c => deepClone(c)),
+            headerExtensions: this.headerExtensions.map(he => deepClone(he)),
+            rtcp: deepClone(this.rtcp)
+        };
+    }
+}

package/src/RTCRtpReceiveParameters.ts

@@ -0,0 +1,7 @@
+import RTCRtpParameters, { RTCRtpParametersInit } from './RTCRtpParameters';
+
+export default class RTCRtpReceiveParameters extends RTCRtpParameters {
+    constructor(init: RTCRtpParametersInit) {
+        super(init);
+    }
+}

package/src/RTCRtpReceiver.ts

@@ -0,0 +1,60 @@
+import { NativeModules } from 'react-native';
+
+import MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpCapabilities from './RTCRtpCapabilities';
+import { RTCRtpParametersInit } from './RTCRtpParameters';
+import RTCRtpReceiveParameters from './RTCRtpReceiveParameters';
+
+const { WebRTCModule } = NativeModules;
+
+export default class RTCRtpReceiver {
+    _id: string;
+    _peerConnectionId: number;
+    _track: MediaStreamTrack | null = null;
+    _rtpParameters: RTCRtpReceiveParameters;
+
+    constructor(info: {
+        peerConnectionId: number,
+        id: string,
+        track?: MediaStreamTrack,
+        rtpParameters: RTCRtpParametersInit
+    }) {
+        this._id = info.id;
+        this._peerConnectionId = info.peerConnectionId;
+        this._rtpParameters = new RTCRtpReceiveParameters(info.rtpParameters);
+
+        if (info.track) {
+            this._track = info.track;
+        }
+    }
+
+    static getCapabilities(kind: 'audio' | 'video'): RTCRtpCapabilities {
+        return WebRTCModule.receiverGetCapabilities(kind);
+    }
+
+    getStats() {
+        return WebRTCModule.receiverGetStats(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))
+        );
+    }
+
+    getParameters(): RTCRtpReceiveParameters {
+        return this._rtpParameters;
+    }
+
+    get id() {
+        return this._id;
+    }
+
+    get track() {
+        return this._track;
+    }
+}

package/src/RTCRtpSendParameters.ts

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

package/src/RTCRtpSender.ts

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

package/src/RTCRtpTransceiver.ts

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

package/src/RTCSessionDescription.ts

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

package/src/RTCTrackEvent.ts

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