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

package/src/RTCView.web.tsx

@@ -1,82 +1,82 @@
-import React, { useEffect, useMemo, useRef } from 'react';
+import React, { useEffect, useMemo, useRef } from 'react';
 import { StyleSheet, View, ViewProps } from 'react-native';
-
-import { getStream } from './webStream';
-
-export interface RTCVideoViewProps extends ViewProps {
-  mirror?: boolean;
-  objectFit?: 'contain' | 'cover';
-  streamURL?: string;
-  zOrder?: number;
-  iosPIP?: RTCIOSPIPOptions;
-  onDimensionsChange?: (event: { nativeEvent: { width: number; height: number } }) => void;
-}
-
-export interface RTCIOSPIPOptions {
-  enabled?: boolean;
-  preferredSize?: {
-    width: number;
-    height: number;
-  };
-  startAutomatically?: boolean;
-  stopAutomatically?: boolean;
-}
-
-export default function RTCView({
-    mirror,
-    objectFit = 'cover',
-    streamURL,
-    style,
-    onDimensionsChange,
-}: RTCVideoViewProps) {
-    const ref = useRef<HTMLVideoElement | null>(null);
-    const stream = useMemo(() => getStream(streamURL), [ streamURL ]);
-
-    useEffect(() => {
-        if (!ref.current) {
-            return;
-        }
-
-        ref.current.srcObject = stream;
-    }, [ stream ]);
-
-    const flatStyle = StyleSheet.flatten(style) as React.CSSProperties | undefined;
-
-    return (
-        <View style={[ styles.container, style ]}>
-            {React.createElement('video', {
-                autoPlay: true,
-                muted: true,
-                playsInline: true,
-                ref,
-                onLoadedMetadata: (event: Event) => {
+
+import { getStream } from './webStream';
+
+export interface RTCVideoViewProps extends ViewProps {
+  mirror?: boolean;
+  objectFit?: 'contain' | 'cover';
+  streamURL?: string;
+  zOrder?: number;
+  iosPIP?: RTCIOSPIPOptions;
+  onDimensionsChange?: (event: { nativeEvent: { width: number; height: number } }) => void;
+}
+
+export interface RTCIOSPIPOptions {
+  enabled?: boolean;
+  preferredSize?: {
+    width: number;
+    height: number;
+  };
+  startAutomatically?: boolean;
+  stopAutomatically?: boolean;
+}
+
+export default function RTCView({
+    mirror,
+    objectFit = 'cover',
+    streamURL,
+    style,
+    onDimensionsChange,
+}: RTCVideoViewProps) {
+    const ref = useRef<HTMLVideoElement | null>(null);
+    const stream = useMemo(() => getStream(streamURL), [ streamURL ]);
+
+    useEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+
+        ref.current.srcObject = stream;
+    }, [ stream ]);
+
+    const flatStyle = StyleSheet.flatten(style) as React.CSSProperties | undefined;
+
+    return (
+        <View style={[ styles.container, style ]}>
+            {React.createElement('video', {
+                autoPlay: true,
+                muted: true,
+                playsInline: true,
+                ref,
+                onLoadedMetadata: (event: Event) => {
                     const target = event.currentTarget as HTMLVideoElement | null;
-
-                    if (!target || !onDimensionsChange) {
-                        return;
-                    }
-
-                    onDimensionsChange({
-                        nativeEvent: {
-                            width: target.videoWidth,
-                            height: target.videoHeight,
-                        },
-                    });
-                },
-                style: {
-                    ...flatStyle,
-                    width: '100%',
-                    height: '100%',
-                    objectFit,
-                    transform: mirror ? 'scaleX(-1)' : undefined,
-                },
-            })}
-        </View>
-    );
-}
-
-const styles = StyleSheet.create({
-    container: {
-        overflow: 'hidden',
-    },
-});
+
+                    if (!target || !onDimensionsChange) {
+                        return;
+                    }
+
+                    onDimensionsChange({
+                        nativeEvent: {
+                            width: target.videoWidth,
+                            height: target.videoHeight,
+                        },
+                    });
+                },
+                style: {
+                    ...flatStyle,
+                    width: '100%',
+                    height: '100%',
+                    objectFit,
+                    transform: mirror ? 'scaleX(-1)' : undefined,
+                },
+            })}
+        </View>
+    );
+}
+
+const styles = StyleSheet.create({
+    container: {
+        overflow: 'hidden',
+    },
+});

package/src/ScreenCapturePickerView.ts

@@ -1,4 +1,4 @@
-
-import { requireNativeComponent } from 'react-native';
-
-export default requireNativeComponent('ScreenCapturePickerView');
+
+import { requireNativeComponent } from 'react-native';
+
+export default requireNativeComponent('ScreenCapturePickerView');

package/src/ScreenCapturePickerView.web.tsx

@@ -1,3 +1,3 @@
-export default function ScreenCapturePickerView() {
-    return null;
-}
+export default function ScreenCapturePickerView() {
+    return null;
+}

package/src/getDisplayMedia.ts

@@ -1,30 +1,30 @@
-
-import { NativeModules } from 'react-native';
-
-import MediaStream from './MediaStream';
-import MediaStreamError from './MediaStreamError';
-
-const { WebRTCModule } = NativeModules;
-
-export default function getDisplayMedia(): Promise<MediaStream> {
-    return new Promise((resolve, reject) => {
-        WebRTCModule.getDisplayMedia().then(
-            data => {
-                const { streamId, track } = data;
-
-                const info = {
-                    streamId: streamId,
-                    streamReactTag: streamId,
-                    tracks: [ track ]
-                };
-
-                const stream = new MediaStream(info);
-
-                resolve(stream);
-            },
-            error => {
-                reject(new MediaStreamError(error));
-            }
-        );
-    });
-}
+
+import { NativeModules } from 'react-native';
+
+import MediaStream from './MediaStream';
+import MediaStreamError from './MediaStreamError';
+
+const { WebRTCModule } = NativeModules;
+
+export default function getDisplayMedia(): Promise<MediaStream> {
+    return new Promise((resolve, reject) => {
+        WebRTCModule.getDisplayMedia().then(
+            data => {
+                const { streamId, track } = data;
+
+                const info = {
+                    streamId: streamId,
+                    streamReactTag: streamId,
+                    tracks: [ track ]
+                };
+
+                const stream = new MediaStream(info);
+
+                resolve(stream);
+            },
+            error => {
+                reject(new MediaStreamError(error));
+            }
+        );
+    });
+}

package/src/getUserMedia.ts

@@ -1,136 +1,136 @@
-
-import { NativeModules } from 'react-native';
-
-
-import { MediaTrackConstraints } from './Constraints';
-import MediaStream from './MediaStream';
-import MediaStreamError from './MediaStreamError';
-import permissions from './Permissions';
-import * as RTCUtil from './RTCUtil';
-
-const { WebRTCModule } = NativeModules;
-
-export interface Constraints {
-    audio?: boolean | MediaTrackConstraints;
-    video?: boolean | MediaTrackConstraints;
-}
-
-export default function getUserMedia(constraints: Constraints = {}): Promise<MediaStream> {
-    // According to
-    // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia,
-    // the constraints argument is a dictionary of type MediaStreamConstraints.
-    if (typeof constraints !== 'object') {
-        return Promise.reject(new TypeError('constraints is not a dictionary'));
-    }
-
-    if (
-        (typeof constraints.audio === 'undefined' || !constraints.audio) &&
-        (typeof constraints.video === 'undefined' || !constraints.video)
-    ) {
-        return Promise.reject(new TypeError('audio and/or video is required'));
-    }
-
-    console.log('[RNWebRTC] get_user_media_start', {
-        audio: !!constraints.audio,
-        video: !!constraints.video,
-    });
-
-    // Normalize constraints.
-    constraints = RTCUtil.normalizeConstraints(constraints);
-
-    // Request required permissions
-    const reqPermissions: Promise<boolean>[] = [];
-
-    if (constraints.audio) {
-        console.log('[RNWebRTC] requesting_mic_permission');
-        reqPermissions.push(permissions.request({ name: 'microphone' }));
-    } else {
-        reqPermissions.push(Promise.resolve(false));
-    }
-
-    if (constraints.video) {
-        console.log('[RNWebRTC] requesting_camera_permission');
-        reqPermissions.push(permissions.request({ name: 'camera' }));
-    } else {
-        reqPermissions.push(Promise.resolve(false));
-    }
-
-    const _t0 = Date.now();
-
-    return new Promise((resolve, reject) => {
-        Promise.all(reqPermissions).then(results => {
-            const [ audioPerm, videoPerm ] = results;
-
-            console.log('[RNWebRTC] permission_results', { audioPerm, videoPerm });
-
-            // Check permission results and remove unneeded permissions.
-
-            if (!audioPerm && !videoPerm) {
-                // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
-                // step 4
-                console.log('[RNWebRTC] permission_denied_both');
-                const error = {
-                    message: 'Permission denied.',
-                    name: 'SecurityError'
-                };
-
-                reject(new MediaStreamError(error));
-
-                return;
-            }
-
-            audioPerm || delete constraints.audio;
-            videoPerm || delete constraints.video;
-
-            const success = (id, tracks) => {
-                // Store initial constraints.
-                for (const trackInfo of tracks) {
-                    const c = constraints[trackInfo.kind];
-
-                    if (typeof c === 'object') {
-                        trackInfo.constraints = RTCUtil.deepClone(c);
-                    }
-                }
-
-                console.log('[RNWebRTC] get_user_media_success', {
-                    durationMs: Date.now() - _t0,
-                    streamId: id,
-                    trackCount: tracks.length,
-                    trackKinds: tracks.map(t => t.kind),
-                });
-
-                const info = {
-                    streamId: id,
-                    streamReactTag: id,
-                    tracks
-                };
-
-                resolve(new MediaStream(info));
-            };
-
-            const failure = (type, message) => {
-                console.log('[RNWebRTC] get_user_media_error', {
-                    durationMs: Date.now() - _t0,
-                    type,
-                    message,
-                });
-
-                let error;
-
-                switch (type) {
-                    case 'TypeError':
-                        error = new TypeError(message);
-                        break;
-                }
-
-                if (!error) {
-                    error = new MediaStreamError({ message, name: type });
-                }
-
-                reject(error);
-            };
-
-            WebRTCModule.getUserMedia(constraints, success, failure);
-        });
-    });
-}
+
+import { NativeModules } from 'react-native';
+
+
+import { MediaTrackConstraints } from './Constraints';
+import MediaStream from './MediaStream';
+import MediaStreamError from './MediaStreamError';
+import permissions from './Permissions';
+import * as RTCUtil from './RTCUtil';
+
+const { WebRTCModule } = NativeModules;
+
+export interface Constraints {
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+}
+
+export default function getUserMedia(constraints: Constraints = {}): Promise<MediaStream> {
+    // According to
+    // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia,
+    // the constraints argument is a dictionary of type MediaStreamConstraints.
+    if (typeof constraints !== 'object') {
+        return Promise.reject(new TypeError('constraints is not a dictionary'));
+    }
+
+    if (
+        (typeof constraints.audio === 'undefined' || !constraints.audio) &&
+        (typeof constraints.video === 'undefined' || !constraints.video)
+    ) {
+        return Promise.reject(new TypeError('audio and/or video is required'));
+    }
+
+    console.log('[RNWebRTC] get_user_media_start', {
+        audio: !!constraints.audio,
+        video: !!constraints.video,
+    });
+
+    // Normalize constraints.
+    constraints = RTCUtil.normalizeConstraints(constraints);
+
+    // Request required permissions
+    const reqPermissions: Promise<boolean>[] = [];
+
+    if (constraints.audio) {
+        console.log('[RNWebRTC] requesting_mic_permission');
+        reqPermissions.push(permissions.request({ name: 'microphone' }));
+    } else {
+        reqPermissions.push(Promise.resolve(false));
+    }
+
+    if (constraints.video) {
+        console.log('[RNWebRTC] requesting_camera_permission');
+        reqPermissions.push(permissions.request({ name: 'camera' }));
+    } else {
+        reqPermissions.push(Promise.resolve(false));
+    }
+
+    const _t0 = Date.now();
+
+    return new Promise((resolve, reject) => {
+        Promise.all(reqPermissions).then(results => {
+            const [ audioPerm, videoPerm ] = results;
+
+            console.log('[RNWebRTC] permission_results', { audioPerm, videoPerm });
+
+            // Check permission results and remove unneeded permissions.
+
+            if (!audioPerm && !videoPerm) {
+                // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
+                // step 4
+                console.log('[RNWebRTC] permission_denied_both');
+                const error = {
+                    message: 'Permission denied.',
+                    name: 'SecurityError'
+                };
+
+                reject(new MediaStreamError(error));
+
+                return;
+            }
+
+            audioPerm || delete constraints.audio;
+            videoPerm || delete constraints.video;
+
+            const success = (id, tracks) => {
+                // Store initial constraints.
+                for (const trackInfo of tracks) {
+                    const c = constraints[trackInfo.kind];
+
+                    if (typeof c === 'object') {
+                        trackInfo.constraints = RTCUtil.deepClone(c);
+                    }
+                }
+
+                console.log('[RNWebRTC] get_user_media_success', {
+                    durationMs: Date.now() - _t0,
+                    streamId: id,
+                    trackCount: tracks.length,
+                    trackKinds: tracks.map(t => t.kind),
+                });
+
+                const info = {
+                    streamId: id,
+                    streamReactTag: id,
+                    tracks
+                };
+
+                resolve(new MediaStream(info));
+            };
+
+            const failure = (type, message) => {
+                console.log('[RNWebRTC] get_user_media_error', {
+                    durationMs: Date.now() - _t0,
+                    type,
+                    message,
+                });
+
+                let error;
+
+                switch (type) {
+                    case 'TypeError':
+                        error = new TypeError(message);
+                        break;
+                }
+
+                if (!error) {
+                    error = new MediaStreamError({ message, name: type });
+                }
+
+                reject(error);
+            };
+
+            WebRTCModule.getUserMedia(constraints, success, failure);
+        });
+    });
+}