@sbhjt-gr/react-native-webrtc 137.0.2

package/src/MediaDevices.ts

@@ -0,0 +1,53 @@
+import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import getDisplayMedia from './getDisplayMedia';
+import getUserMedia, { Constraints } from './getUserMedia';
+
+const { WebRTCModule } = NativeModules;
+
+type MediaDevicesEventMap = {
+    devicechange: Event<'devicechange'>
+}
+
+class MediaDevices extends EventTarget<MediaDevicesEventMap> {
+    /**
+     * W3C "Media Capture and Streams" compatible {@code enumerateDevices}
+     * implementation.
+     */
+    enumerateDevices() {
+        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));
+    }
+
+    /**
+     * W3C "Screen Capture" compatible {@code getDisplayMedia} implementation.
+     * See: https://w3c.github.io/mediacapture-screen-share/
+     *
+     * @returns {Promise}
+     */
+    getDisplayMedia() {
+        return getDisplayMedia();
+    }
+
+    /**
+     * W3C "Media Capture and Streams" compatible {@code getUserMedia}
+     * implementation.
+     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices
+     *
+     * @param {*} constraints
+     * @returns {Promise}
+     */
+    getUserMedia(constraints: Constraints) {
+        return getUserMedia(constraints);
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = MediaDevices.prototype;
+
+defineEventAttribute(proto, 'devicechange');
+
+
+export default new MediaDevices();

package/src/MediaStream.ts

@@ -0,0 +1,161 @@
+import { EventTarget, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import MediaStreamTrack, { MediaStreamTrackInfo } from './MediaStreamTrack';
+import MediaStreamTrackEvent from './MediaStreamTrackEvent';
+import { uniqueID } from './RTCUtil';
+
+const { WebRTCModule } = NativeModules;
+
+type MediaStreamEventMap = {
+    addtrack: MediaStreamTrackEvent<'addtrack'>
+    removetrack: MediaStreamTrackEvent<'removetrack'>
+}
+
+export default class MediaStream extends EventTarget<MediaStreamEventMap> {
+    _tracks: MediaStreamTrack[] = [];
+    _id: string;
+
+    /**
+     * The identifier of this MediaStream unique within the associated
+     * WebRTCModule instance. As the id of a remote MediaStream instance is unique
+     * only within the associated RTCPeerConnection, it is not sufficiently unique
+     * to identify this MediaStream across multiple RTCPeerConnections and to
+     * unambiguously differentiate it from a local MediaStream instance not added
+     * to an RTCPeerConnection.
+     */
+    _reactTag: string;
+
+    /**
+     * A MediaStream can be constructed in several ways, depending on the parameters
+     * that are passed here.
+     *
+     * - undefined: just a new stream, with no tracks.
+     * - MediaStream instance: a new stream, with a copy of the tracks of the passed stream.
+     * - Array of MediaStreamTrack: a new stream with a copy of the tracks in the array.
+     * - object: a new stream instance, represented by the passed info object, this is always
+     *   done internally, when the stream is first created in native and the JS wrapper is
+     *   built afterwards.
+     */
+    constructor(arg?:
+        MediaStream |
+        MediaStreamTrack[] |
+        { streamId: string, streamReactTag: string, tracks: MediaStreamTrackInfo[] }
+    ) {
+        super();
+
+        // Assign a UUID to start with. It will get overridden for remote streams.
+        this._id = uniqueID();
+
+        // Local MediaStreams are created by WebRTCModule to have their id and
+        // reactTag equal because WebRTCModule follows the respective standard's
+        // recommendation for id generation i.e. uses UUID which is unique enough
+        // for the purposes of reactTag.
+        this._reactTag = this._id;
+
+        if (typeof arg === 'undefined') {
+            WebRTCModule.mediaStreamCreate(this.id);
+        } else if (arg instanceof MediaStream) {
+            WebRTCModule.mediaStreamCreate(this.id);
+
+            for (const track of arg.getTracks()) {
+                this.addTrack(track);
+            }
+        } else if (Array.isArray(arg)) {
+            WebRTCModule.mediaStreamCreate(this.id);
+
+            for (const track of arg) {
+                this.addTrack(track);
+            }
+        } else if (typeof arg === 'object' && arg.streamId && arg.streamReactTag && arg.tracks) {
+            this._id = arg.streamId;
+            this._reactTag = arg.streamReactTag;
+
+            for (const trackInfo of arg.tracks) {
+                // We are not using addTrack here because the track is already part of the
+                // stream, so there is no need to add it on the native side.
+                this._tracks.push(new MediaStreamTrack(trackInfo));
+            }
+        } else {
+            throw new TypeError(`invalid type: ${typeof arg}`);
+        }
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get active(): boolean {
+        // TODO: can we reliably report this value?
+
+        return true;
+    }
+
+    addTrack(track: MediaStreamTrack): void {
+        const index = this._tracks.indexOf(track);
+
+        if (index !== -1) {
+            return;
+        }
+
+        this._tracks.push(track);
+        WebRTCModule.mediaStreamAddTrack(this._reactTag, track.remote ? track._peerConnectionId : -1, track.id);
+    }
+
+    removeTrack(track: MediaStreamTrack): void {
+        const index = this._tracks.indexOf(track);
+
+        if (index === -1) {
+            return;
+        }
+
+        this._tracks.splice(index, 1);
+        WebRTCModule.mediaStreamRemoveTrack(this._reactTag, track.remote ? track._peerConnectionId : -1, track.id);
+    }
+
+    getTracks(): MediaStreamTrack[] {
+        return this._tracks.slice();
+    }
+
+    getTrackById(trackId): MediaStreamTrack | undefined {
+        return this._tracks.find(track => track.id === trackId);
+    }
+
+    getAudioTracks(): MediaStreamTrack[] {
+        return this._tracks.filter(track => track.kind === 'audio');
+    }
+
+    getVideoTracks(): MediaStreamTrack[] {
+        return this._tracks.filter(track => track.kind === 'video');
+    }
+
+    clone(): never {
+        throw new Error('Not implemented.');
+    }
+
+    toURL(): string {
+        return this._reactTag;
+    }
+
+    release(releaseTracks = true): void {
+        const tracks = [ ...this._tracks ];
+
+        for (const track of tracks) {
+            this.removeTrack(track);
+
+            if (releaseTracks) {
+                track.release();
+            }
+        }
+
+        WebRTCModule.mediaStreamRelease(this._reactTag);
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = MediaStream.prototype;
+
+defineEventAttribute(proto, 'addtrack');
+defineEventAttribute(proto, 'removetrack');

package/src/MediaStreamError.ts

@@ -0,0 +1,12 @@
+
+export default class MediaStreamError {
+    name: string;
+    message?: string;
+    constraintName?: string;
+
+    constructor(error) {
+        this.name = error.name;
+        this.message = error.message;
+        this.constraintName = error.constraintName;
+    }
+}

package/src/MediaStreamErrorEvent.ts

@@ -0,0 +1,11 @@
+
+import type MediaStreamError from './MediaStreamError';
+
+export default class MediaStreamErrorEvent {
+    type: string;
+    error?: MediaStreamError;
+    constructor(type, eventInitDict) {
+        this.type = type.toString();
+        Object.assign(this, eventInitDict);
+    }
+}

package/src/MediaStreamTrack.ts

@@ -0,0 +1,331 @@
+import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+import { MediaTrackConstraints } from './Constraints';
+import { addListener, removeListener, removeListenerForEvent } from './EventEmitter';
+import Logger from './Logger';
+import { deepClone, normalizeConstraints } from './RTCUtil';
+
+const log = new Logger('pc');
+const { WebRTCModule } = NativeModules;
+
+export type AudioSampleData = {
+    trackId: string;
+    samples: number[];
+    sampleRate: number;
+    channels: number;
+    timestamp: number;
+}
+
+export type AudioSinkCallback = (data: AudioSampleData) => void;
+
+
+type MediaStreamTrackState = 'live' | 'ended';
+
+export type MediaStreamTrackInfo = {
+    id: string;
+    kind: string;
+    remote: boolean;
+    constraints: object;
+    enabled: boolean;
+    settings: object;
+    peerConnectionId: number;
+    readyState: MediaStreamTrackState;
+}
+
+export type MediaTrackSettings = {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    facingMode?: string;
+    deviceId?: string;
+    groupId?: string;
+}
+
+type MediaStreamTrackEventMap = {
+    ended: Event<'ended'>;
+    mute: Event<'mute'>;
+    unmute: Event<'unmute'>;
+}
+
+export default class MediaStreamTrack extends EventTarget<MediaStreamTrackEventMap> {
+    _constraints: MediaTrackConstraints;
+    _enabled: boolean;
+    _settings: MediaTrackSettings;
+    _muted: boolean;
+    _peerConnectionId: number;
+    _readyState: MediaStreamTrackState;
+
+    readonly id: string;
+    readonly kind: string;
+    readonly label: string = '';
+    readonly remote: boolean;
+
+    constructor(info: MediaStreamTrackInfo) {
+        super();
+
+        this._constraints = info.constraints || {};
+        this._enabled = info.enabled;
+        this._settings = info.settings || {};
+        this._muted = false;
+        this._peerConnectionId = info.peerConnectionId;
+        this._readyState = info.readyState;
+
+        this.id = info.id;
+        this.kind = info.kind;
+        this.remote = info.remote;
+
+        if (!this.remote) {
+            this._registerEvents();
+        }
+    }
+
+    get enabled(): boolean {
+        return this._enabled;
+    }
+
+    set enabled(enabled: boolean) {
+        if (enabled === this._enabled) {
+            return;
+        }
+
+        this._enabled = Boolean(enabled);
+
+        if (this._readyState === 'ended') {
+            return;
+        }
+
+        WebRTCModule.mediaStreamTrackSetEnabled(this.remote ? this._peerConnectionId : -1, this.id, this._enabled);
+    }
+
+    get muted(): boolean {
+        return this._muted;
+    }
+
+    get readyState(): string {
+        return this._readyState;
+    }
+
+    stop(): void {
+        this.enabled = false;
+        this._readyState = 'ended';
+    }
+
+    /**
+     * Private / custom API for switching the cameras on the fly, without the
+     * need for adding / removing tracks or doing any SDP renegotiation.
+     *
+     * This is how the reference application (AppRTCMobile) implements camera
+     * switching.
+     *
+     * @deprecated Use applyConstraints instead.
+     */
+    _switchCamera(): void {
+        if (this.remote) {
+            throw new Error('Not implemented for remote tracks');
+        }
+
+        if (this.kind !== 'video') {
+            throw new Error('Only implemented for video tracks');
+        }
+
+        const constraints = deepClone(this._settings);
+
+        delete constraints.deviceId;
+        constraints.facingMode = this._settings.facingMode === 'user' ? 'environment' : 'user';
+
+        this.applyConstraints(constraints);
+    }
+
+    _setVideoEffects(names: string[]) {
+        if (this.remote) {
+            throw new Error('Not implemented for remote tracks');
+        }
+
+        if (this.kind !== 'video') {
+            throw new Error('Only implemented for video tracks');
+        }
+
+        WebRTCModule.mediaStreamTrackSetVideoEffects(this.id, names);
+    }
+
+    _setVideoEffect(name: string) {
+        this._setVideoEffects([ name ]);
+    }
+
+    /**
+     * Internal function which is used to set the muted state on remote tracks and
+     * emit the mute / unmute event.
+     *
+     * @param muted Whether the track should be marked as muted / unmuted.
+     */
+    _setMutedInternal(muted: boolean) {
+        if (!this.remote) {
+            throw new Error('Track is not remote!');
+        }
+
+        this._muted = muted;
+        this.dispatchEvent(new Event(muted ? 'mute' : 'unmute'));
+    }
+
+    /**
+     * Custom API for setting the volume on an individual audio track.
+     *
+     * @param volume a gain value in the range of 0-10. defaults to 1.0
+     */
+    _setVolume(volume: number) {
+        if (this.kind !== 'audio') {
+            throw new Error('Only implemented for audio tracks');
+        }
+
+        WebRTCModule.mediaStreamTrackSetVolume(this.remote ? this._peerConnectionId : -1, this.id, volume);
+    }
+
+    /**
+     * Applies a new set of constraints to the track.
+     *
+     * @param constraints An object listing the constraints
+     * to apply to the track's constrainable properties; any existing
+     * constraints are replaced with the new values specified, and any
+     * constrainable properties not included are restored to their default
+     * constraints. If this parameter is omitted, all currently set custom
+     * constraints are cleared.
+     */
+    async applyConstraints(constraints?: MediaTrackConstraints): Promise<void> {
+        if (this.kind !== 'video') {
+            log.info(`Only implemented for video tracks, ignoring applyConstraints for ${this.id}`);
+
+            return;
+        }
+
+        const normalized = normalizeConstraints({ video: constraints ?? true });
+
+        this._settings = await WebRTCModule.mediaStreamTrackApplyConstraints(this.id, normalized.video);
+        this._constraints = constraints ?? {};
+    }
+
+    clone(): never {
+        throw new Error('Not implemented.');
+    }
+
+    getCapabilities(): never {
+        throw new Error('Not implemented.');
+    }
+
+    getConstraints() {
+        return deepClone(this._constraints);
+    }
+
+    getSettings(): MediaTrackSettings {
+        return deepClone(this._settings);
+    }
+
+    _registerEvents(): void {
+        addListener(this, 'mediaStreamTrackEnded', (ev: any) => {
+            if (ev.trackId !== this.id || this._readyState === 'ended') {
+                return;
+            }
+
+            log.debug(`${this.id} mediaStreamTrackEnded`);
+            this._readyState = 'ended';
+
+            this.dispatchEvent(new Event('ended'));
+        });
+    }
+
+    private _audioSinkCallback: AudioSinkCallback | null = null;
+    private _audioSinkListenerActive: boolean = false;
+    private _playbackEnabled: boolean = true;
+
+    _setAudioSinkCallback(callback: AudioSinkCallback | null): void {
+        this._audioSinkCallback = callback;
+    }
+
+    _handleAudioSamples(data: AudioSampleData): void {
+        if (this._audioSinkCallback) {
+            this._audioSinkCallback(data);
+        }
+    }
+
+    setAudioSink(callback: AudioSinkCallback | null): void {
+        if (this.kind !== 'audio') {
+            throw new Error('Audio sink only available for audio tracks');
+        }
+
+        if (!this.remote) {
+            throw new Error('Audio sink only available for remote tracks');
+        }
+
+        this._setAudioSinkCallback(callback);
+
+        if (callback && !this._audioSinkListenerActive) {
+            this._audioSinkListenerActive = true;
+            WebRTCModule.mediaStreamTrackEnableAudioSink(
+                this._peerConnectionId,
+                this.id,
+                true
+            );
+            addListener(this, 'audioSamples', (ev: any) => {
+                if (ev.trackId === this.id) {
+                    this._handleAudioSamples(ev);
+                }
+            });
+        } else if (!callback && this._audioSinkListenerActive) {
+            this._audioSinkListenerActive = false;
+            WebRTCModule.mediaStreamTrackEnableAudioSink(
+                this._peerConnectionId,
+                this.id,
+                false
+            );
+            removeListenerForEvent(this, 'audioSamples');
+        }
+    }
+
+    setPlaybackEnabled(enabled: boolean): void {
+        if (this.kind !== 'audio') {
+            throw new Error('Playback control only available for audio tracks');
+        }
+
+        if (!this.remote) {
+            throw new Error('Playback control only available for remote tracks');
+        }
+
+        this._playbackEnabled = enabled;
+        WebRTCModule.mediaStreamTrackSetPlaybackEnabled(
+            this._peerConnectionId,
+            this.id,
+            enabled
+        );
+    }
+
+    isPlaybackEnabled(): boolean {
+        return this._playbackEnabled;
+    }
+
+    release(): void {
+        if (this.remote) {
+            if (this._audioSinkListenerActive) {
+                this._audioSinkListenerActive = false;
+                WebRTCModule.mediaStreamTrackEnableAudioSink(
+                    this._peerConnectionId,
+                    this.id,
+                    false
+                );
+                removeListenerForEvent(this, 'audioSamples');
+            }
+            return;
+        }
+
+        removeListener(this);
+        WebRTCModule.mediaStreamTrackRelease(this.id);
+    }
+}
+
+/**
+ * Define the `onxxx` event handlers.
+ */
+const proto = MediaStreamTrack.prototype;
+
+defineEventAttribute(proto, 'ended');
+defineEventAttribute(proto, 'mute');
+defineEventAttribute(proto, 'unmute');

package/src/MediaStreamTrackEvent.ts

@@ -0,0 +1,25 @@
+import { Event } from 'event-target-shim/index';
+
+import type MediaStreamTrack from './MediaStreamTrack';
+
+type MEDIA_STREAM_EVENTS = 'addtrack'| 'removetrack'
+
+interface IMediaStreamTrackEventInitDict extends Event.EventInit {
+  track: MediaStreamTrack;
+}
+
+/**
+ * @eventClass
+ * This event is fired whenever the MediaStreamTrack has changed in any way.
+ * @param {MEDIA_STREAM_EVENTS} type - The type of event.
+ * @param {IMediaStreamTrackEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStream#events MDN} for details.
+ */
+export default class MediaStreamTrackEvent<TEventType extends MEDIA_STREAM_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    track: MediaStreamTrack;
+    constructor(type: TEventType, eventInitDict: IMediaStreamTrackEventInitDict) {
+        super(type, eventInitDict);
+        this.track = eventInitDict.track;
+    }
+}

package/src/MessageEvent.ts

@@ -0,0 +1,26 @@
+import { Event } from 'event-target-shim/index';
+
+export type MessageEventData = string | ArrayBuffer | Blob;
+
+type MESSAGE_EVENTS = 'message' | 'messageerror';
+
+interface IMessageEventInitDict extends Event.EventInit {
+    data: MessageEventData;
+}
+
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel send message.
+ * @param {MESSAGE_EVENTS} type - The type of event.
+ * @param {IMessageEventInitDict} eventInitDict - The event init properties.
+ * @see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/message_event#event_type MDN} for details.
+ */
+export default class MessageEvent<TEventType extends MESSAGE_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    data: MessageEventData;
+    constructor(type: TEventType, eventInitDict: IMessageEventInitDict) {
+        super(type, eventInitDict);
+        this.data = eventInitDict.data;
+    }
+}