@pexip/media 17.2.0 → 17.4.0

package/dist/types.js

@@ -0,0 +1,278 @@
+export var UserMediaStatus;
+(function (UserMediaStatus) {
+    /**
+     * The initial status
+     */
+    UserMediaStatus["Initial"] = "initial";
+    /**
+     * When we know the permissions were already granted from permission API
+     */
+    UserMediaStatus["InitialPermissionsGranted"] = "initial-permissions-granted";
+    /**
+     * When we do not know the permissions from permission API
+     */
+    UserMediaStatus["InitialPermissionsNotGranted"] = "initial-permissions-not-granted";
+    /**
+     * When video input permissions are initially denied in the browser and audio input permissions are unknown
+     */
+    UserMediaStatus["InitialPermissionsVideoInputDenied"] = "initial-permissions-videoinput-denied";
+    /**
+     * When audio input permissions are initially denied in the browser and video input permissions are unknown
+     */
+    UserMediaStatus["InitialPermissionsAudioInputDenied"] = "initial-permissions-audioinput-denied";
+    /**
+     * When video input permissions are granted in the browser and audio input permissions are unknown
+     */
+    UserMediaStatus["InitialPermissionsVideoInputGranted"] = "initial-permissions-videoinput-granted";
+    /**
+     * When audio input permissions are granted in the browser and video input permissions are unknown
+     */
+    UserMediaStatus["InitialPermissionsAudioInputGranted"] = "initial-permissions-audioinput-granted";
+    /**
+     * When audio input permissions are granted but video input permissions are initially denied
+     */
+    UserMediaStatus["InitialPermissionsGrantedVideoInputDenied"] = "initial-permissions-audioinput-granted-videoinput-denied";
+    /**
+     * When video input permissions are granted but audio input permissions are initially denied
+     */
+    UserMediaStatus["InitialPermissionsGrantedAudioInputDenied"] = "initial-permissions-videoinput-granted-audioinput-denied";
+    /**
+     * When there is no any kind of input devices
+     */
+    UserMediaStatus["NoDevicesFound"] = "no-devices-found";
+    /**
+     * When there is no any video input devices
+     */
+    UserMediaStatus["NoVideoDevicesFound"] = "no-video-devices-found";
+    /**
+     * When there is no any audio input devices
+     */
+    UserMediaStatus["NoAudioDevicesFound"] = "no-audio-devices-found";
+    /**
+     * Derived from `MediaDeviceFailure.AudioInputDeviceNotFoundError`
+     */
+    UserMediaStatus["AudioDeviceNotFound"] = "audio-device-not-found";
+    /**
+     * Derived from `MediaDeviceFailure.VideoInputDeviceNotFoundError`
+     */
+    UserMediaStatus["VideoDeviceNotFound"] = "video-device-not-found";
+    /**
+     * Derived from `MediaDeviceFailure.AudioAndVideoDeviceNotFoundError`
+     */
+    UserMediaStatus["AudioVideoDevicesNotFound"] = "audio-video-devices-not-found";
+    /**
+     * When Permission is granted by user for both video and audio, and both
+     * devices are exactly matched with the request constraints
+     */
+    UserMediaStatus["PermissionsGranted"] = "permissions-granted";
+    /**
+     * When Permission is granted by user for both video and audio, and both
+     * devices are NOT exactly matched with the request constraints
+     */
+    UserMediaStatus["PermissionsGrantedFallback"] = "permissions-granted-fallback-devices";
+    /**
+     * When Permission is granted by user for both video and audio, and audio
+     * input is NOT exactly matched with the request constraints
+     */
+    UserMediaStatus["PermissionsGrantedFallbackAudioinput"] = "permissions-granted-fallback-audioinput";
+    /**
+     * When Permission is granted by user for both video and audio, and video
+     * input is NOT exactly matched with the request constraints
+     */
+    UserMediaStatus["PermissionsGrantedFallbackVideoinput"] = "permissions-granted-fallback-videoinput";
+    /**
+     * When Permission for using both audio and video devices are rejected by the user
+     * from `PermissionDeniedError`
+     */
+    UserMediaStatus["PermissionsRejected"] = "permissions-rejected";
+    /**
+     * When Permission for using the audio device is rejected by the user
+     * from `PermissionDeniedError`
+     */
+    UserMediaStatus["PermissionsRejectedAudioInput"] = "permissions-rejected-audioinput";
+    /**
+     * When Permission for using the video device is rejected by the user
+     * from `PermissionDeniedError`
+     */
+    UserMediaStatus["PermissionsRejectedVideoInput"] = "permissions-rejected-videoinput";
+    /**
+     * When only request and return exact audio input device
+     */
+    UserMediaStatus["PermissionsOnlyAudioinput"] = "permissions-only-audioinput";
+    /**
+     * When only request audio input device because of no video devices
+     * available and returned exact audio input device
+     */
+    UserMediaStatus["PermissionsOnlyAudioinputNoVideoDevices"] = "permissions-only-audioinput-no-video-devices";
+    /**
+     * When only request and returned NOT exact audio input device
+     */
+    UserMediaStatus["PermissionsOnlyAudioinputFallback"] = "permissions-only-fallback-audioinput";
+    /**
+     * When only request audio input device because of no video devices
+     * available and returned NOT exact audio input device
+     */
+    UserMediaStatus["PermissionsOnlyAudioinputFallbackNoVideoDevices"] = "permissions-only-fallback-audioinput-no-video-devices";
+    /**
+     * When only request and return exact video input device
+     */
+    UserMediaStatus["PermissionsOnlyVideoinput"] = "permissions-only-videoinput";
+    /**
+     * When only request video input device because of no audio devices
+     * available and returned exact video input device
+     */
+    UserMediaStatus["PermissionsOnlyVideoinputNoAudioDevices"] = "permissions-only-videoinput-no-audio-devices";
+    /**
+     * When only request and returned NOT exact video input device
+     */
+    UserMediaStatus["PermissionsOnlyVideoinputFallback"] = "permissions-only-fallback-videoinput";
+    /**
+     * When only request video input device because of no video devices
+     * available and returned NOT exact video input device
+     */
+    UserMediaStatus["PermissionsOnlyVideoinputFallbackNoAudioDevices"] = "permissions-only-fallback-videoinput-no-audio-devices";
+    /**
+     * When requesting the audio device is used by other application
+     */
+    UserMediaStatus["AudioDeviceInUse"] = "audio-device-in-use";
+    /**
+     * When requesting the video device is used by other application
+     */
+    UserMediaStatus["VideoDeviceInUse"] = "video-device-in-use";
+    /**
+     * When requesting both audio and video devices are used by other application
+     */
+    UserMediaStatus["DevicesInUse"] = "devices-in-use";
+    /**
+     * When requesting both audio and video with over-constrained
+     */
+    UserMediaStatus["Overconstrained"] = "overconstrained";
+    /**
+     * When requesting video with over-constrained
+     */
+    UserMediaStatus["VideoOverconstrained"] = "video-overconstrained";
+    /**
+     * When requesting audio with over-constrained
+     */
+    UserMediaStatus["AudioOverconstrained"] = "audio-overconstrained";
+    /**
+     * When requesting both audio and video with invalid constraints
+     */
+    UserMediaStatus["InvalidConstraints"] = "invalid-constraints";
+    /**
+     * When requesting video with invalid constraints
+     */
+    UserMediaStatus["InvalidVideoConstraints"] = "invalid-video-constraints";
+    /**
+     * When requesting audio with invalid constraints
+     */
+    UserMediaStatus["InvalidAudioConstraints"] = "invalid-audio-constraints";
+    /**
+     * When requesting both audio and video with NotSupportedError
+     */
+    UserMediaStatus["NotSupportedError"] = "not-supported-error";
+    /**
+     * When requesting video with NotSupportedError
+     */
+    UserMediaStatus["NotSupportedErrorOnlyVideoInput"] = "not-supported-error-only-video";
+    /**
+     * When requesting audio with NotSupportedError
+     */
+    UserMediaStatus["NotSupportedErrorOnlyAudioInput"] = "not-supported-error-only-audio";
+    /**
+     * Unknown error from both video and audio
+     */
+    UserMediaStatus["UnknownError"] = "unknown-error";
+    /**
+     * Unknown error from audio device
+     */
+    UserMediaStatus["UnknownErrorOnlyAudioinput"] = "unknown-error-only-audioinput";
+    /**
+     * Unknown error from video device
+     */
+    UserMediaStatus["UnknownErrorOnlyVideoinput"] = "unknown-error-only-videoinput";
+})(UserMediaStatus || (UserMediaStatus = {}));
+export var DeniedDevices;
+(function (DeniedDevices) {
+    DeniedDevices["Microphone"] = "microphone";
+    DeniedDevices["Camera"] = "camera";
+    DeniedDevices["Both"] = "microphone-and-camera";
+})(DeniedDevices || (DeniedDevices = {}));
+/**
+ * Audio content hints are only applicable when the MediaStreamTrack contains an
+ * audio track
+ *
+ * {@link https://www.w3.org/TR/mst-content-hint/#audio-content-hints}
+ */
+export const AUDIO_CONTENT_HINTS = {
+    /**
+     * No hint has been provided, the implementation should make its
+     * best-informed guess on how to handle contained audio data. This may be
+     * inferred from how the track was opened or by doing content analysis
+     */
+    NoHint: '',
+    /**
+     * The track should be treated as if it contains speech data. Consuming this
+     * signal it may be appropriate to apply noise suppression or boost
+     * intelligibility of the incoming signal.
+     */
+    Speech: 'speech',
+    /**
+     * The track should be treated as if it contains data for the purpose of
+     * speech recognition by a machine. Consuming this signal it may be
+     * appropriate to boost intelligibility of the incoming signal for
+     * transcription and turn off audio-processing components that are used for
+     * human consumption.
+     */
+    SpeechRecognition: 'speech-recognition',
+    /**
+     * The track should be treated as if it contains music data. Generally this
+     * might imply tuning or turning off audio-processing components that are
+     * used to process speech data to prevent the audio from being distorted.
+     */
+    Music: 'music',
+};
+/**
+ * Video content hints are only applicable when the MediaStreamTrack contains a
+ * video track.
+ *
+ * {@link https://www.w3.org/TR/mst-content-hint/#video-content-hints}
+ */
+export const VIDEO_CONTENT_HINTS = {
+    /**
+     * No hint has been provided, the implementation should make its
+     * best-informed guess on how contained video content should be treated.
+     * This can for example be inferred from how the track was opened or by
+     * doing content analysis.
+     */
+    NoHint: '',
+    /**
+     * The track should be treated as if it contains video where motion is
+     * important. This is normally webcam video, movies or video games.
+     * Quantization artefacts and downscaling are acceptable in order to
+     * preserve motion as well as possible while still retaining target
+     * bitrates. During low bitrates when compromises have to be made, more
+     * effort is spent on preserving frame rate than edge quality and details.
+     */
+    Motion: 'motion',
+    /**
+     * The track should be treated as if video details are extra important.
+     * This is generally applicable to presentations or web pages with text
+     * content, painting or line art. This setting would normally optimize for
+     * detail in the resulting individual frames rather than smooth playback.
+     * Artefacts from quantization or downscaling that make small text or line
+     * art unintelligible should be avoided.
+     */
+    Detail: 'detail',
+    /**
+     * The track should be treated as if video details are extra important, and
+     * that significant sharp edges and areas of consistent color can occur
+     * frequently. This is generally applicable to presentations or web pages
+     * with text content. This setting would normally optimize for detail in the
+     * resulting individual frames rather than smooth playback, and may take
+     * advantage of encoder tools that optimize for text rendering. Artefacts
+     * from quantization or downscaling that make small text or line art
+     * unintelligible should be avoided.
+     */
+    Text: 'text',
+};

package/dist/userMedia.d.ts

@@ -0,0 +1,38 @@
+import type { MediaDeviceRequest, MediaDeviceInfoLike } from '@pexip/media-control';
+import type { Process, Media } from './types';
+import { UserMediaStatus } from './types';
+import { makeDeriveDeviceStatus } from './utils';
+export type UserMedia = [MediaStream | undefined, UserMediaStatus];
+export type GetUserMedia<T extends Promise<Iterable<unknown>> = Promise<UserMedia>> = (constraints: MediaDeviceRequest) => T;
+export declare const toErrorDeviceStatus: (error: Error, deriveDeviceStatus: ReturnType<typeof makeDeriveDeviceStatus>) => UserMediaStatus;
+export declare const mapErrorStatus: (status: UserMediaStatus) => (constraints: MediaDeviceRequest) => UserMediaStatus;
+export declare const toSameDeviceStatus: ({ audio, video, }: {
+    audio: boolean;
+    video: boolean;
+}) => UserMediaStatus.PermissionsGranted | UserMediaStatus.PermissionsGrantedFallback | UserMediaStatus.PermissionsGrantedFallbackAudioinput | UserMediaStatus.PermissionsGrantedFallbackVideoinput;
+export declare const toOnlyDeviceStatus: (kind: Extract<MediaDeviceKind, 'audioinput' | 'videoinput'>, matched: boolean, devices: MediaDeviceInfoLike[]) => UserMediaStatus.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+/**
+ * Try to come up with an error level according to provided UserMediaStatus and
+ * MediaDeviceRequest
+ *
+ * @param error - The error thrown from media request
+ * @param status - The status in result
+ * @param constraints - The constraints used for the request
+ */
+export declare const deriveErrorLevel: (error: Error, status: UserMediaStatus, constraints: MediaDeviceRequest) => "error" | "warn";
+export declare const requestUserMedia: (currentDevices?: MediaDeviceInfoLike[], getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia;
+export declare const mergeNoDeviceStatus: (constraints: MediaDeviceRequest, anyDevices: {
+    audio: boolean;
+    video: boolean;
+}, status: UserMediaStatus) => UserMediaStatus;
+export declare const requestUserMediaWithRetry: (currentDevices?: MediaDeviceInfoLike[], createRequestUserMedia?: (currentDevices?: MediaDeviceInfoLike[], getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia) => GetUserMedia;
+interface Options {
+    initialMedia: Media;
+    scope?: string;
+}
+type CreateGetUserMediaProcess = (getUserMedia: GetUserMedia, getCurrentDevices: () => MediaDeviceInfoLike[], options: Options) => Process<MediaDeviceRequest>;
+/**
+ * A process to get user media
+ */
+export declare const createGetUserMediaProcess: CreateGetUserMediaProcess;
+export {};

package/dist/userMedia.js

@@ -0,0 +1,333 @@
+import { MediaDeviceFailure, applyConstraints, findMediaInputFromMediaStreamTrack, getDevices, getUserMedia, isExactDeviceConstraint, isRequestedResolution, isStreamingRequestedDevices, muteStreamTrack, stopMediaStream, isAudioInput, isVideoInput, hasAnyInputs, hasAnyGrantedInput, } from '@pexip/media-control';
+import { isEmpty } from '@pexip/utils';
+import { UserMediaStatus } from './types';
+import { shallowCopy, makeDeriveDeviceStatus, createMemorizedGetExpectedInput, isMuted, wrapToJSON, } from './utils';
+import { logger } from './logger';
+import { isUnknownError } from './status';
+export const toErrorDeviceStatus = (error, deriveDeviceStatus) => {
+    switch (error.message) {
+        case MediaDeviceFailure.AudioInputDeviceNotFoundError:
+            return UserMediaStatus.AudioDeviceNotFound;
+        case MediaDeviceFailure.VideoInputDeviceNotFoundError:
+            return UserMediaStatus.VideoDeviceNotFound;
+        case MediaDeviceFailure.AudioAndVideoDeviceNotFoundError:
+            return UserMediaStatus.AudioVideoDevicesNotFound;
+        case MediaDeviceFailure.NotAllowedError:
+        case MediaDeviceFailure.NotFoundError:
+        case MediaDeviceFailure.SecurityError:
+        case MediaDeviceFailure.PermissionDeniedError:
+            return deriveDeviceStatus(UserMediaStatus.PermissionsRejectedAudioInput, UserMediaStatus.PermissionsRejectedVideoInput, UserMediaStatus.PermissionsRejected);
+        case MediaDeviceFailure.NotReadableError:
+        case MediaDeviceFailure.TrackStartError:
+        case MediaDeviceFailure.AbortError:
+            return deriveDeviceStatus(UserMediaStatus.AudioDeviceInUse, UserMediaStatus.VideoDeviceInUse, UserMediaStatus.DevicesInUse);
+        case MediaDeviceFailure.MissingConstraintsError:
+            return deriveDeviceStatus(UserMediaStatus.NoAudioDevicesFound, UserMediaStatus.NoVideoDevicesFound, UserMediaStatus.NoDevicesFound);
+        case MediaDeviceFailure.OverconstrainedError:
+            return deriveDeviceStatus(UserMediaStatus.AudioOverconstrained, UserMediaStatus.VideoOverconstrained, UserMediaStatus.Overconstrained);
+        case MediaDeviceFailure.TypeError:
+            return deriveDeviceStatus(UserMediaStatus.InvalidAudioConstraints, UserMediaStatus.InvalidVideoConstraints, UserMediaStatus.InvalidConstraints);
+        case MediaDeviceFailure.NotSupportedError:
+            return deriveDeviceStatus(UserMediaStatus.NotSupportedErrorOnlyAudioInput, UserMediaStatus.NotSupportedErrorOnlyVideoInput, UserMediaStatus.NotSupportedError);
+        default:
+            return deriveDeviceStatus(UserMediaStatus.UnknownErrorOnlyAudioinput, UserMediaStatus.UnknownErrorOnlyVideoinput, UserMediaStatus.UnknownError);
+    }
+};
+export const mapErrorStatus = (status) => (constraints) => {
+    const toStatus = makeDeriveDeviceStatus(constraints);
+    switch (status) {
+        case UserMediaStatus.AudioVideoDevicesNotFound:
+            return toStatus(UserMediaStatus.AudioDeviceNotFound, UserMediaStatus.VideoDeviceNotFound, status);
+        case UserMediaStatus.DevicesInUse:
+            return toStatus(UserMediaStatus.AudioDeviceInUse, UserMediaStatus.VideoDeviceInUse, status);
+        case UserMediaStatus.InvalidConstraints:
+            return toStatus(UserMediaStatus.InvalidAudioConstraints, UserMediaStatus.InvalidVideoConstraints, status);
+        case UserMediaStatus.NoDevicesFound:
+            return toStatus(UserMediaStatus.NoAudioDevicesFound, UserMediaStatus.NoVideoDevicesFound, status);
+        case UserMediaStatus.NotSupportedError:
+            return toStatus(UserMediaStatus.NotSupportedErrorOnlyAudioInput, UserMediaStatus.NotSupportedErrorOnlyVideoInput, status);
+        case UserMediaStatus.Overconstrained:
+            return toStatus(UserMediaStatus.AudioOverconstrained, UserMediaStatus.VideoOverconstrained, status);
+        case UserMediaStatus.PermissionsRejected:
+            return toStatus(UserMediaStatus.PermissionsRejectedAudioInput, UserMediaStatus.PermissionsRejectedVideoInput, status);
+        case UserMediaStatus.UnknownError:
+            return toStatus(UserMediaStatus.UnknownErrorOnlyAudioinput, UserMediaStatus.UnknownErrorOnlyVideoinput, status);
+        default:
+            return status;
+    }
+};
+export const toSameDeviceStatus = ({ audio, video, }) => {
+    if (audio) {
+        if (video) {
+            return UserMediaStatus.PermissionsGranted;
+        }
+        return UserMediaStatus.PermissionsGrantedFallbackVideoinput;
+    }
+    if (video) {
+        return UserMediaStatus.PermissionsGrantedFallbackAudioinput;
+    }
+    return UserMediaStatus.PermissionsGrantedFallback;
+};
+export const toOnlyDeviceStatus = (kind, matched, devices) => {
+    const hasRelatedDevices = devices.some(d => {
+        if (kind === 'audioinput') {
+            return d.kind === 'videoinput';
+        }
+        return d.kind === 'audioinput';
+    });
+    if (matched) {
+        if (hasRelatedDevices) {
+            return kind === 'audioinput'
+                ? UserMediaStatus.PermissionsOnlyAudioinput
+                : UserMediaStatus.PermissionsOnlyVideoinput;
+        }
+        return kind === 'audioinput'
+            ? UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices
+            : UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices;
+    }
+    if (hasRelatedDevices) {
+        return kind === 'audioinput'
+            ? UserMediaStatus.PermissionsOnlyAudioinputFallback
+            : UserMediaStatus.PermissionsOnlyVideoinputFallback;
+    }
+    return kind === 'audioinput'
+        ? UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices
+        : UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+};
+/**
+ * Try to come up with an error level according to provided UserMediaStatus and
+ * MediaDeviceRequest
+ *
+ * @param error - The error thrown from media request
+ * @param status - The status in result
+ * @param constraints - The constraints used for the request
+ */
+export const deriveErrorLevel = (error, status, constraints) => {
+    // Only log to error level when we should pay attention, e.g.
+    // UnknownError
+    const errorMsg = error.message;
+    return [
+        (errorMessage) => MediaDeviceFailure.TypeError === errorMessage,
+        (errorMessage) => MediaDeviceFailure.NotSupportedError === errorMessage,
+        (errorMessage) => MediaDeviceFailure.OverconstrainedError ===
+            errorMessage &&
+            ![constraints.audio, constraints.video].some(constraint => isExactDeviceConstraint(constraint)),
+        () => isUnknownError(status),
+    ].some(shouldUseError => shouldUseError(errorMsg))
+        ? 'error'
+        : 'warn';
+};
+export const requestUserMedia = (currentDevices, getMedia = getUserMedia) => async (constraints) => {
+    const deriveDeviceStatus = makeDeriveDeviceStatus(constraints);
+    const devices = currentDevices ?? (await getDevices());
+    try {
+        const stream = await getMedia(constraints);
+        const grantedDevices = hasAnyGrantedInput(devices)
+            ? devices
+            : await getDevices();
+        const { audio, video } = isStreamingRequestedDevices(constraints, stream, grantedDevices);
+        const onlyAudioStatus = toOnlyDeviceStatus('audioinput', audio, grantedDevices);
+        const onlyVideoStatus = toOnlyDeviceStatus('videoinput', video, grantedDevices);
+        const status = deriveDeviceStatus(onlyAudioStatus, onlyVideoStatus, toSameDeviceStatus({ audio, video }));
+        return [stream, status];
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            const status = toErrorDeviceStatus(error, deriveDeviceStatus);
+            return [undefined, status];
+        }
+        throw error;
+    }
+};
+export const mergeNoDeviceStatus = (constraints, anyDevices, status) => {
+    if (status !== UserMediaStatus.NoDevicesFound ||
+        (!anyDevices.audio &&
+            !anyDevices.video &&
+            constraints.audio &&
+            constraints.video)) {
+        return status;
+    }
+    if (!anyDevices.audio && constraints.audio) {
+        return UserMediaStatus.NoAudioDevicesFound;
+    }
+    if (!anyDevices.video && constraints.video) {
+        return UserMediaStatus.NoVideoDevicesFound;
+    }
+    return status;
+};
+export const requestUserMediaWithRetry = (currentDevices, createRequestUserMedia = requestUserMedia) => async (constraints) => {
+    const devices = isEmpty(currentDevices)
+        ? await getDevices()
+        : currentDevices;
+    const [anyAudioDevices, anyVideoDevices] = hasAnyInputs(devices);
+    const request = (constraints, devices) => createRequestUserMedia(devices)(constraints);
+    if (anyAudioDevices && anyVideoDevices) {
+        const [stream, status] = await request(constraints, devices);
+        if (stream) {
+            return [stream, status];
+        }
+        const mapStatus = mapErrorStatus(status);
+        if (constraints.video) {
+            const [audioStream] = await request({
+                ...constraints,
+                video: false,
+            }, devices);
+            if (audioStream) {
+                // When success, we know it is video related error
+                const videoStatus = mapStatus({ video: true });
+                return [audioStream, videoStatus];
+            }
+        }
+        if (constraints.audio) {
+            const [videoStream] = await request({
+                ...constraints,
+                audio: false,
+            }, devices);
+            if (videoStream) {
+                // When success, we know it is audio related error
+                return [videoStream, mapStatus({ audio: true })];
+            }
+        }
+        return [stream, status];
+    }
+    else {
+        const [stream, status] = await request({
+            audio: anyAudioDevices && constraints.audio,
+            video: anyVideoDevices && constraints.video,
+        }, devices);
+        return [
+            stream,
+            mergeNoDeviceStatus(constraints, { audio: anyAudioDevices, video: anyVideoDevices }, status),
+        ];
+    }
+};
+/**
+ * A process to get user media
+ */
+export const createGetUserMediaProcess = (getUserMedia, getCurrentDevices, { initialMedia, scope = 'media' }) => {
+    const props = {
+        unsubscribe: undefined,
+        currentDevices: getCurrentDevices(),
+        cachedAudioTrackId: '',
+        cachedVideoTrackId: '',
+        cachedAudioInput: undefined,
+        cachedVideoInput: undefined,
+    };
+    const getExpectedAudioInput = createMemorizedGetExpectedInput();
+    const getExpectedVideoInput = createMemorizedGetExpectedInput();
+    /**
+     * Memorized get media input
+     */
+    const getInput = ([track] = []) => {
+        if (!track) {
+            return undefined;
+        }
+        const isAudio = track.kind === 'audio';
+        const cacheKey = isAudio ? 'cachedAudioInput' : 'cachedVideoInput';
+        const cachedTrackId = isAudio
+            ? 'cachedAudioTrackId'
+            : 'cachedVideoTrackId';
+        const trackId = track.label;
+        const { width, height } = track.getSettings();
+        if (trackId === props[cachedTrackId] &&
+            track.readyState === 'live' &&
+            (isAudio ||
+                (!isAudio &&
+                    isRequestedResolution({ width, height }, props[cacheKey])))) {
+            return props[cacheKey];
+        }
+        const devices = getCurrentDevices();
+        const findTrack = findMediaInputFromMediaStreamTrack(devices);
+        const input = findTrack(track);
+        // Update cache
+        props[cacheKey] = input;
+        props[cachedTrackId] = trackId;
+        return input;
+    };
+    return async (constraints) => {
+        const [stream, status] = await getUserMedia(constraints);
+        logger.debug({ scope, stream, status }, 'getUserMedia');
+        props.currentDevices = await getDevices();
+        const deriveDeviceStatus = makeDeriveDeviceStatus(constraints);
+        const muteTrack = muteStreamTrack(stream);
+        const muteAudio = (mute) => muteTrack(mute, 'audio');
+        const muteVideo = (mute) => muteTrack(mute, 'video');
+        return wrapToJSON(shallowCopy(initialMedia ?? {}, {
+            constraints,
+            rawStream: stream,
+            stream,
+            status,
+            get devices() {
+                return props.currentDevices;
+            },
+            set devices(newDevices) {
+                props.currentDevices = newDevices;
+            },
+            get audioInput() {
+                return getInput(stream?.getAudioTracks());
+            },
+            get videoInput() {
+                return getInput(stream?.getVideoTracks());
+            },
+            get expectedAudioInput() {
+                return getExpectedAudioInput(constraints.audio, () => ({
+                    devices: getCurrentDevices().filter(isAudioInput),
+                    input: getInput(stream?.getAudioTracks()),
+                }));
+            },
+            get expectedVideoInput() {
+                return getExpectedVideoInput(constraints.video, () => ({
+                    devices: getCurrentDevices().filter(isVideoInput),
+                    input: getInput(stream?.getVideoTracks()),
+                }));
+            },
+            muteAudio,
+            muteVideo,
+            get audioMuted() {
+                return isMuted(stream?.getAudioTracks());
+            },
+            get videoMuted() {
+                return isMuted(stream?.getVideoTracks());
+            },
+            applyConstraints: async (constraints) => {
+                try {
+                    logger.debug({ scope, constraints: constraints }, 'apply native constraints');
+                    return await applyConstraints(stream?.getTracks(), constraints);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        const status = toErrorDeviceStatus(error, deriveDeviceStatus);
+                        logger.error({
+                            scope,
+                            status,
+                            error,
+                            constraints: constraints,
+                        }, 'fail to apply native constraints');
+                        initialMedia.status = status;
+                    }
+                    throw error;
+                }
+            },
+            getSettings: () => {
+                const settings = {
+                    audio: stream
+                        ?.getAudioTracks()
+                        .map(track => track.getSettings()) ?? [],
+                    video: stream
+                        ?.getVideoTracks()
+                        .map(track => track.getSettings()) ?? [],
+                };
+                logger.debug({ settings, scope }, 'get native settings');
+                return settings;
+            },
+            release: () => {
+                stopMediaStream(stream);
+                if (props.unsubscribe) {
+                    props.unsubscribe();
+                    props.unsubscribe = undefined;
+                }
+                return Promise.resolve();
+            },
+        }));
+    };
+};