@sbhjt-gr/react-native-webrtc 124.0.0

package/src/MediaStreamTrack.ts

@@ -0,0 +1,284 @@
+import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';
+import { NativeModules } from 'react-native';
+
+import { MediaTrackConstraints } from './Constraints';
+import { addListener, removeListener } from './EventEmitter';
+import Logger from './Logger';
+import { deepClone, normalizeConstraints } from './RTCUtil';
+
+const log = new Logger('pc');
+const { WebRTCModule } = NativeModules;
+
+export type PalabraConfig = {
+    clientId: string;
+    clientSecret: string;
+    sourceLang: string;
+    targetLang: string;
+    apiUrl?: string;
+};
+
+export type PalabraTranscription = {
+    text: string;
+    lang: string;
+    isFinal: boolean;
+};
+
+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.');
+    }
+
+    async startPalabraTranslation(config: PalabraConfig): Promise<void> {
+        if (!this.remote) {
+            throw new Error('only_remote_tracks');
+        }
+
+        if (this.kind !== 'audio') {
+            throw new Error('only_audio_tracks');
+        }
+
+        if (this._readyState === 'ended') {
+            throw new Error('track_ended');
+        }
+
+        return WebRTCModule.startPalabraTranslation(
+            this._peerConnectionId,
+            this.id,
+            config.clientId,
+            config.clientSecret,
+            config.sourceLang,
+            config.targetLang,
+            config.apiUrl || 'https://api.palabra.ai'
+        );
+    }
+
+    async stopPalabraTranslation(): Promise<void> {
+        return WebRTCModule.stopPalabraTranslation();
+    }
+
+    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'));
+        });
+    }
+
+    release(): void {
+        if (this.remote) {
+            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;
+    }
+}

package/src/Permissions.ts

@@ -0,0 +1,133 @@
+
+import { NativeModules, Permission, PermissionsAndroid, Platform } from 'react-native';
+
+const { WebRTCModule } = NativeModules;
+
+/**
+ * Type declaration for a permissions descriptor.
+ */
+type PermissionDescriptor = {
+    name: string;
+};
+
+/**
+ * Class implementing a subset of W3C's Permissions API as defined by:
+ * https://www.w3.org/TR/permissions/
+ */
+class Permissions {
+    /**
+     * Possible result values for {@link query}, in accordance with:
+     * https://www.w3.org/TR/permissions/#status-of-a-permission
+     */
+    RESULT = {
+        DENIED: 'denied',
+        GRANTED: 'granted',
+        PROMPT: 'prompt'
+    };
+
+    /**
+     * This implementation only supports requesting these permissions, a subset
+     * of: https://www.w3.org/TR/permissions/#permission-registry
+     */
+    VALID_PERMISSIONS = [ 'camera', 'microphone' ];
+
+    _lastReq: Promise<unknown> = Promise.resolve();
+
+    /**
+     * Helper for requesting Android permissions. On Android only one permission
+     * can be requested at a time (unless the multi-permission API is used,
+     * but we are not using that for symmetry with the W3C API for querying)
+     * so we'll queue them up.
+     *
+     * @param perm - The requested permission from
+     * {@link PermissionsAndroid.PERMISSIONS}
+     * https://facebook.github.io/react-native/docs/permissionsandroid#permissions-that-require-prompting-the-user
+     */
+    _requestPermissionAndroid(perm: Permission) {
+        return new Promise(resolve => {
+            PermissionsAndroid.request(perm).then(
+                granted => resolve(granted === PermissionsAndroid.RESULTS.GRANTED),
+                () => resolve(false)
+            );
+        });
+    }
+
+    /**
+     * Validates the given permission descriptor.
+     */
+    _validatePermissionDescriptior(permissionDesc) {
+        if (typeof permissionDesc !== 'object') {
+            throw new TypeError('Argument 1 of Permissions.query is not an object.');
+        }
+
+        if (typeof permissionDesc.name === 'undefined') {
+            throw new TypeError('Missing required \'name\' member of PermissionDescriptor.');
+        }
+
+        if (this.VALID_PERMISSIONS.indexOf(permissionDesc.name) === -1) {
+            throw new TypeError(
+                '\'name\' member of PermissionDescriptor is not a valid value for enumeration PermissionName.'
+            );
+        }
+    }
+
+    /**
+     * Method for querying the status of a permission, according to:
+     * https://www.w3.org/TR/permissions/#permissions-interface
+     */
+    query(permissionDesc: PermissionDescriptor) {
+        try {
+            this._validatePermissionDescriptior(permissionDesc);
+        } catch (e) {
+            return Promise.reject(e);
+        }
+
+        if (Platform.OS === 'android') {
+            const perm =
+                permissionDesc.name === 'camera'
+                    ? PermissionsAndroid.PERMISSIONS.CAMERA
+                    : PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+
+            return new Promise(resolve => {
+                PermissionsAndroid.check(perm).then(
+                    granted => resolve(granted ? this.RESULT.GRANTED : this.RESULT.PROMPT),
+                    () => resolve(this.RESULT.PROMPT)
+                );
+            });
+        } else if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+            return WebRTCModule.checkPermission(permissionDesc.name);
+        } else {
+            return Promise.reject(new TypeError('Unsupported platform.'));
+        }
+    }
+
+    /**
+     * Custom method NOT defined by W3C's permissions API, which allows the
+     * caller to request a permission.
+     */
+    request(permissionDesc: PermissionDescriptor) {
+        try {
+            this._validatePermissionDescriptior(permissionDesc);
+        } catch (e) {
+            return Promise.reject(e);
+        }
+
+        if (Platform.OS === 'android') {
+            const perm =
+                permissionDesc.name === 'camera'
+                    ? PermissionsAndroid.PERMISSIONS.CAMERA
+                    : PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+            const requestPermission = () => this._requestPermissionAndroid(perm);
+
+            this._lastReq = this._lastReq.then(requestPermission, requestPermission);
+
+            return this._lastReq;
+        } else if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+            return WebRTCModule.requestPermission(permissionDesc.name);
+        } else {
+            return Promise.reject(new TypeError('Unsupported platform.'));
+        }
+    }
+}
+
+export default new Permissions();

package/src/RTCAudioSession.ts

@@ -0,0 +1,25 @@
+import { NativeModules, Platform } from 'react-native';
+
+const { WebRTCModule } = NativeModules;
+
+export default class RTCAudioSession {
+    /**
+     * To be called when CallKit activates the audio session.
+     */
+    static audioSessionDidActivate() {
+        // Only valid for iOS
+        if (Platform.OS === 'ios') {
+            WebRTCModule.audioSessionDidActivate();
+        }
+    }
+
+    /**
+     * To be called when CallKit deactivates the audio session.
+     */
+    static audioSessionDidDeactivate() {
+        // Only valid for iOS
+        if (Platform.OS === 'ios') {
+            WebRTCModule.audioSessionDidDeactivate();
+        }
+    }
+}

package/src/RTCDataChannel.ts

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