@cloudflare/realtimekit-react-native 0.0.0 → 0.0.1-staging.3

package/lib/LocalMediaHandler.js

@@ -0,0 +1,853 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LocalMediaHandler_localMediaUtils, _LocalMediaHandler_appState, _LocalMediaHandler_appStateSubscription, _LocalMediaHandler_interval;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { EventEmitter } from 'events';
+import LocalMediaUtils from './LocalMediaUtils';
+import { AppState, NativeEventEmitter, NativeModules, Platform, } from 'react-native';
+import BackgroundTimer from './BackgroundHandler';
+import InCallManger from './NativeAudioManager';
+import { setupPermissions } from './PermissionHandler';
+const { DyteHelper, BroadcastEventEmitter } = NativeModules;
+const broadcastEmitter = new NativeEventEmitter(BroadcastEventEmitter);
+export var MediaEvents;
+(function (MediaEvents) {
+    MediaEvents[MediaEvents["AUDIO_TRACK_CHANGE"] = 0] = "AUDIO_TRACK_CHANGE";
+    MediaEvents[MediaEvents["VIDEO_TRACK_CHANGE"] = 1] = "VIDEO_TRACK_CHANGE";
+    MediaEvents[MediaEvents["SCREENSHARE_TRACK_CHANGE"] = 2] = "SCREENSHARE_TRACK_CHANGE";
+    MediaEvents[MediaEvents["SCREENSHARE_ENDED"] = 3] = "SCREENSHARE_ENDED";
+    MediaEvents[MediaEvents["DEVICE_CHANGE"] = 4] = "DEVICE_CHANGE";
+    MediaEvents[MediaEvents["SCREENSHARE_STARTED"] = 5] = "SCREENSHARE_STARTED";
+    MediaEvents[MediaEvents["MEDIA_PERMISSION_UPDATE"] = 6] = "MEDIA_PERMISSION_UPDATE";
+    MediaEvents[MediaEvents["DEVICE_LIST_UPDATED"] = 7] = "DEVICE_LIST_UPDATED";
+})(MediaEvents || (MediaEvents = {}));
+function checkIfAudioTrackIsSilent(track) {
+    //TODO
+    return !!track;
+}
+class LocalMediaHandler extends EventEmitter {
+    configureForeground() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = yield DyteHelper.isForegroundServiceRunning();
+            if (Platform.Version >= 26) {
+                yield DyteHelper.createNotificationChannel();
+            }
+            if (!val)
+                yield DyteHelper.startService();
+        });
+    }
+    constructor(localMediaUtils) {
+        super();
+        _LocalMediaHandler_localMediaUtils.set(this, void 0);
+        _LocalMediaHandler_appState.set(this, void 0);
+        _LocalMediaHandler_appStateSubscription.set(this, void 0);
+        _LocalMediaHandler_interval.set(this, void 0);
+        this._handleAppStateChange = (nextAppState) => {
+            // console.log('App state changed to : ', nextAppState);
+            if (__classPrivateFieldGet(this, _LocalMediaHandler_appState, "f").match(/inactive|background/) &&
+                nextAppState === 'active') {
+                BackgroundTimer.clearInterval(__classPrivateFieldGet(this, _LocalMediaHandler_interval, "f"));
+                __classPrivateFieldSet(this, _LocalMediaHandler_interval, null, "f");
+                if (this.videoTrack) {
+                    this.videoTrack.enabled = false;
+                    setTimeout(() => {
+                        if (this.videoTrack) {
+                            this.videoTrack.enabled = true;
+                        }
+                    }, 100);
+                }
+            }
+            else {
+                if (__classPrivateFieldGet(this, _LocalMediaHandler_interval, "f") === null) {
+                    this.configureForeground();
+                }
+                __classPrivateFieldSet(this, _LocalMediaHandler_interval, BackgroundTimer.setInterval(() => { }, 1000), "f");
+                __classPrivateFieldSet(this, _LocalMediaHandler_appState, nextAppState, "f");
+            }
+        };
+        __classPrivateFieldSet(this, _LocalMediaHandler_localMediaUtils, localMediaUtils, "f");
+        __classPrivateFieldSet(this, _LocalMediaHandler_appState, '', "f");
+        this.audioEnabled = true;
+        this.videoEnabled = true;
+        this.screenShareEnabled = false;
+        this.permissions = { audio: 'NOT_REQUESTED', video: 'NOT_REQUESTED' };
+        this.screenShareTracks = {
+            audio: undefined,
+            video: undefined,
+        };
+        this.currentDevices = {
+            audio: undefined,
+            video: undefined,
+            speaker: undefined,
+        };
+        // NOTE(roerohan): The arrow function is required so that the reference to "this" is proper.
+        //if (Platform.OS === 'android')
+        __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").onDeviceChange((changedDevices) => __awaiter(this, void 0, void 0, function* () {
+            yield this.onDeviceChange(changedDevices, false);
+        }));
+        if (Platform.OS === 'ios') {
+            broadcastEmitter.addListener('iOS_BroadcastStarted', () => {
+                this.oniOSBroadcastStart();
+            });
+            broadcastEmitter.addListener('iOS_BroadcastStopped', () => {
+                this.oniOSBroadcastStop();
+            });
+        }
+        InCallManger.start({});
+    }
+    destructor() {
+        __classPrivateFieldGet(this, _LocalMediaHandler_appStateSubscription, "f").remove();
+        broadcastEmitter.removeAllListeners('iOS_BroadcastStarted');
+        broadcastEmitter.removeAllListeners('iOS_BroadcastStopped');
+        BackgroundTimer.stop();
+    }
+    handlePermissionErrors(kind, err) {
+        // pass
+    }
+    conditionallyRestartAudio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.currentDevices.audio || !this.audioEnabled) {
+                return;
+            }
+            // log.info('maybe_restart_audio: ');
+            yield Promise.race([
+                new Promise((resolve) => {
+                    var _a;
+                    return (_a = this.audioTrack) === null || _a === void 0 ? void 0 : _a.addEventListener('unmute', (e) => {
+                        resolve(e);
+                    });
+                }),
+                new Promise((resolve) => setTimeout(resolve, 50)),
+            ]);
+            const reacquireTrack = yield this.shouldReacquireTrack('audio');
+            if (reacquireTrack) {
+                this.removeMediaStreamTrackListeners(this.audioTrack);
+                yield this.setupAudioStream((_a = this.currentDevices.audio) === null || _a === void 0 ? void 0 : _a.deviceId);
+                this.addMediaStreamTrackListeners(this.audioTrack);
+                this.emit('AUDIO_TRACK_CHANGE');
+            }
+        });
+    }
+    conditionallyRestartVideo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.currentDevices.video || !this.videoEnabled)
+                return;
+            // log.info('maybe_restart_video');
+            yield Promise.race([
+                new Promise((resolve) => { var _a; return (_a = this.videoTrack) === null || _a === void 0 ? void 0 : _a.addEventListener('unmute', resolve); }),
+                new Promise((resolve) => setTimeout(resolve, 50)),
+            ]);
+            const reacquireTrack = yield this.shouldReacquireTrack('video');
+            if (reacquireTrack) {
+                this.removeMediaStreamTrackListeners(this.videoTrack);
+                yield this.setupVideoStream(this.currentDevices.video.deviceId);
+                this.addMediaStreamTrackListeners(this.videoTrack);
+                this.emit('VIDEO_TRACK_CHANGE');
+            }
+        });
+    }
+    shouldReacquireTrack(kind) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workaroundWebKitBug1208516 = false;
+            let mediaStreamTrack;
+            let wasEnabled = false;
+            if (kind === 'audio') {
+                mediaStreamTrack = this.audioTrack;
+                wasEnabled = this.audioEnabled;
+            }
+            else if (kind === 'video') {
+                mediaStreamTrack = this.videoTrack;
+                wasEnabled = this.videoEnabled;
+            }
+            if (!mediaStreamTrack)
+                return false;
+            if (!this.rawAudioTrack || !this.audioTrack)
+                return true;
+            if (!this.rawVideoTrack || !this.videoTrack)
+                return true;
+            const isStopped = mediaStreamTrack.readyState === 'ended';
+            const isInadvertentlyStopped = isStopped && wasEnabled && workaroundWebKitBug1208516;
+            let isSilentAudio = false;
+            if (kind === 'audio') {
+                isSilentAudio = yield checkIfAudioTrackIsSilent(this.audioTrack);
+            }
+            return mediaStreamTrack.muted || isInadvertentlyStopped || isSilentAudio;
+        });
+    }
+    removeDocumentEventListeners() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    onUnmute(ev) {
+        // log.info('Track unmuted', ev);
+    }
+    removeMediaStreamTrackListeners(mediaStreamTrack) {
+        if (!mediaStreamTrack) {
+            return undefined;
+        }
+        const conditionallyRestart = mediaStreamTrack.kind === 'audio'
+            ? this.conditionallyRestartAudio
+            : this.conditionallyRestartVideo;
+        mediaStreamTrack.removeEventListener('ended', conditionallyRestart);
+        mediaStreamTrack.removeEventListener('mute', conditionallyRestart);
+        mediaStreamTrack.removeEventListener('unmute', this.onUnmute);
+        return mediaStreamTrack;
+    }
+    addMediaStreamTrackListeners(mediaStreamTrack) {
+        if (!mediaStreamTrack) {
+            return null;
+        }
+        const conditionallyRestart = mediaStreamTrack.kind === 'audio'
+            ? this.conditionallyRestartAudio
+            : this.conditionallyRestartVideo;
+        mediaStreamTrack.addEventListener('ended', conditionallyRestart);
+        mediaStreamTrack.addEventListener('mute', conditionallyRestart);
+        mediaStreamTrack.addEventListener('unmute', this.onUnmute);
+        return mediaStreamTrack;
+    }
+    setupAudioStream(deviceId_1) {
+        return __awaiter(this, arguments, void 0, function* (deviceId, forceStopTrack = false) {
+            var _a, _b, _c;
+            const audioDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getAudioDevices();
+            if (!audioDevices.length) {
+                return;
+            }
+            let audioDeviceId = deviceId;
+            if (!audioDeviceId) {
+                audioDeviceId = (yield this.getOperationalMicDeviceId()).deviceId;
+            }
+            if (((_a = this.currentDevices.audio) === null || _a === void 0 ? void 0 : _a.deviceId) !== audioDeviceId) {
+                this.currentDevices.audio = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(audioDeviceId, 'audioinput');
+            }
+            if (forceStopTrack) {
+                (_b = this.audioTrack) === null || _b === void 0 ? void 0 : _b.stop();
+                (_c = this.rawAudioTrack) === null || _c === void 0 ? void 0 : _c.stop();
+            }
+            this.rawAudioTrack = yield LocalMediaUtils.getAudioTrack();
+            this.setAudioTrack(this.rawAudioTrack);
+            this.addMediaStreamTrackListeners(this.audioTrack);
+            this.setDevice(this.currentDevices.audio);
+            // await InCallManger.chooseAudioRoute(audioDeviceId);
+            // console.log('Device selected: ', audioDeviceId);
+            /**
+             * NOTE(roerohan): Firefox does not show device labels until permissions are granted.
+             * So, we need to repopulate the devices once permission is granted.
+             */
+            if (this.audioTrack && this.permissions.audio === 'NOT_REQUESTED') {
+                yield __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").repopulateAvailableDevices();
+            }
+            this.permissions.audio = 'ACCEPTED';
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'audio',
+                message: this.permissions.audio,
+            });
+            this.emit('DEVICE_CHANGE', {
+                device: this.currentDevices.audio,
+            });
+            /*
+              TODO
+              callStats.mediaPermission('AUDIO', CallStatsPermissionEnum.ACCEPTED);
+              callStats.selectedDevice('AUDIO', this.currentDevices.audio); */
+        });
+    }
+    onVisibilityChange() {
+        // pass
+    }
+    setupVideoStream(deviceId_1) {
+        return __awaiter(this, arguments, void 0, function* (deviceId, forceStopTrack = false) {
+            var _a, _b, _c;
+            const videoDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getVideoDevices();
+            if (!videoDevices.length) {
+                return;
+            }
+            let videoDeviceId = deviceId;
+            if (!videoDeviceId) {
+                videoDeviceId = (yield this.getOperationalWebcamDeviceId()).deviceId;
+            }
+            if (((_a = this.currentDevices.video) === null || _a === void 0 ? void 0 : _a.deviceId) !== videoDeviceId) {
+                this.currentDevices.video = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(videoDeviceId, 'videoinput');
+            }
+            /**
+             * NOTE(roerohan): this.videoEnabled is checked, so that upon device change,
+             * the video track is not set when the user has turned off his camera.
+             */
+            if (this.videoEnabled) {
+                const videoConstraints = LocalMediaUtils.getVideoConstraints({
+                    videoDeviceId,
+                });
+                if (!this.rawVideoTrack) {
+                    this.rawVideoTrack = yield LocalMediaUtils.getVideoTrack(videoConstraints);
+                }
+                this.setVideoTrack(this.rawVideoTrack);
+                this.addMediaStreamTrackListeners(this.rawVideoTrack);
+            }
+            if (forceStopTrack) {
+                (_b = this.videoTrack) === null || _b === void 0 ? void 0 : _b.stop();
+                (_c = this.rawVideoTrack) === null || _c === void 0 ? void 0 : _c.stop();
+            }
+            /**
+             * NOTE(roerohan): Firefox does not show device labels until permissions are granted.
+             * So, we need to repopulate the devices once permission is granted.
+             */
+            if (this.videoTrack && this.permissions.video === 'NOT_REQUESTED') {
+                yield __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").repopulateAvailableDevices();
+            }
+            this.permissions.video = 'ACCEPTED';
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'video',
+                message: this.permissions.video,
+            });
+            this.emit('DEVICE_CHANGE', {
+                device: this.currentDevices.video,
+            });
+        });
+    }
+    setupSpeaker(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const speakerDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getSpeakerDevices();
+            if (!speakerDevices.length) {
+                return;
+            }
+            const speakerDeviceId = deviceId !== null && deviceId !== void 0 ? deviceId : speakerDevices[0].deviceId;
+            if (((_a = this.currentDevices.speaker) === null || _a === void 0 ? void 0 : _a.deviceId) !== speakerDeviceId) {
+                this.currentDevices.speaker = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(speakerDeviceId, 'audiooutput');
+            }
+            this.emit('DEVICE_CHANGE', {
+                device: this.currentDevices.speaker,
+            });
+            /*
+            TODO
+            const speakerDeviceId = deviceId ?? speakerDevices[0].deviceId;
+            if (this.currentDevices.speaker?.deviceId !== speakerDeviceId) {
+              this.currentDevices.speaker = this.#localMediaUtils.getDeviceById(
+                speakerDeviceId,
+                'audiooutput'
+              );
+              callStats.selectedDevice('SPEAKER', this.currentDevices.speaker);
+            } */
+        });
+    }
+    getOperationalWebcamDeviceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let videoDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getVideoDevices();
+            if (!videoDevices.length) {
+                return { isOperational: false, deviceId: null };
+            }
+            /*
+                    NOTE(ravindra-dyte): Usually external devices come at the bottom,
+                    By reversing the deviceList and breaking on first operational device
+                    We are giving preference to external device
+                */
+            videoDevices = [...videoDevices].reverse();
+            let operationalDeviceId = null;
+            for (let deviceIndex = 0; deviceIndex < videoDevices.length; deviceIndex += 1) {
+                try {
+                    operationalDeviceId = videoDevices[deviceIndex].deviceId;
+                    break;
+                }
+                catch (err) { }
+            }
+            return operationalDeviceId
+                ? { isOperational: true, deviceId: operationalDeviceId }
+                : { isOperational: false, deviceId: videoDevices[0].deviceId };
+        });
+    }
+    getOperationalMicDeviceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let audioDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getAudioDevices();
+            // console.log(
+            //   'getOperationalMicDeviceId: ',
+            //   JSON.stringify(audioDevices, null, 2)
+            // );
+            if (!audioDevices.length) {
+                return { isOperational: false, deviceId: null };
+            }
+            /*
+                    NOTE(ravindra-dyte): Usually external devices come at the bottom,
+                    By reversing the deviceList and breaking on first operational device
+                    We are giving preference to external device
+                */
+            audioDevices = [...audioDevices].reverse();
+            // console.log(
+            //   'getOperationalMicDeviceId Reverse: ',
+            //   JSON.stringify(audioDevices, null, 2)
+            // );
+            let operationalDeviceId = null;
+            for (let deviceIndex = 0; deviceIndex < audioDevices.length; deviceIndex += 1) {
+                try {
+                    const audioTrack = yield LocalMediaUtils.getAudioTrack();
+                    const isSilent = yield checkIfAudioTrackIsSilent(audioTrack);
+                    audioTrack.stop();
+                    audioTrack.release();
+                    if (!isSilent) {
+                        operationalDeviceId = audioDevices[deviceIndex].deviceId;
+                        break;
+                    }
+                }
+                catch (err) { }
+            }
+            return operationalDeviceId
+                ? { isOperational: true, deviceId: operationalDeviceId }
+                : { isOperational: false, deviceId: audioDevices[0].deviceId };
+        });
+    }
+    setupStreams(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ audio, video, }) {
+            var _b, _c, _d;
+            try {
+                const permResult = yield setupPermissions(audio, video);
+                this.permissions.video = permResult.camera;
+                this.permissions.audio = permResult.microphone;
+            }
+            catch (val) {
+                this.permissions.video = (_b = val.camera) !== null && _b !== void 0 ? _b : false;
+                this.permissions.audio = (_c = val.microphone) !== null && _c !== void 0 ? _c : false;
+            }
+            const constraints = {};
+            if (!this.currentDevices) {
+                this.currentDevices = {
+                    audio: undefined,
+                    video: undefined,
+                    speaker: undefined,
+                };
+            }
+            if (audio) {
+                const audioDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getAudioDevices();
+                if (audioDevices.length !== 0) {
+                    const audioDeviceId = (yield this.getOperationalMicDeviceId()).deviceId;
+                    this.currentDevices.audio = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(audioDeviceId, 'audioinput');
+                    constraints.audio = true;
+                }
+            }
+            if (video) {
+                const videoDevices = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getVideoDevices();
+                if (videoDevices.length !== 0) {
+                    const videoDeviceId = (yield this.getOperationalWebcamDeviceId())
+                        .deviceId;
+                    this.currentDevices.video = __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(videoDeviceId, 'videoinput');
+                    const videoConstraints = LocalMediaUtils.getVideoConstraints({
+                        videoDeviceId,
+                    });
+                    constraints.video = videoConstraints.video;
+                }
+            }
+            const { audioTrack, videoTrack } = yield LocalMediaUtils.getAudioAndVideoTrack(constraints);
+            if (audio && audioTrack) {
+                this.rawAudioTrack = audioTrack;
+                this.permissions.audio = 'ACCEPTED';
+            }
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'audio',
+                message: this.permissions.audio,
+            });
+            if (video && videoTrack) {
+                this.rawVideoTrack = videoTrack;
+                this.permissions.video = 'ACCEPTED';
+            }
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'video',
+                message: this.permissions.video,
+            });
+            if (((_d = Object.keys(constraints)) === null || _d === void 0 ? void 0 : _d.length) === 0) {
+                this.audioEnabled = false;
+                this.videoEnabled = false;
+                return;
+            }
+            if (audio)
+                yield this.setupAudioStream();
+            if (video)
+                yield this.setupVideoStream();
+            if (audioTrack)
+                this.audioEnabled = true;
+            if (videoTrack)
+                this.videoEnabled = true;
+            this.screenShareEnabled = false;
+            yield this.setupSpeaker();
+            // Setup Foreground Service after handling permissions
+            if (Platform.OS === 'android') {
+                __classPrivateFieldSet(this, _LocalMediaHandler_appStateSubscription, AppState.addEventListener('change', this._handleAppStateChange), "f");
+            }
+        });
+    }
+    stopAudioTrack() {
+        var _a, _b;
+        (_a = this.audioTrack) === null || _a === void 0 ? void 0 : _a.stop();
+        (_b = this.audioTrack) === null || _b === void 0 ? void 0 : _b.release();
+        this.audioEnabled = false;
+    }
+    stopVideoTrack() {
+        var _a, _b, _c, _d;
+        (_a = this.rawVideoTrack) === null || _a === void 0 ? void 0 : _a.stop();
+        (_b = this.videoTrack) === null || _b === void 0 ? void 0 : _b.stop();
+        (_c = this.rawVideoTrack) === null || _c === void 0 ? void 0 : _c.release();
+        (_d = this.videoTrack) === null || _d === void 0 ? void 0 : _d.release();
+    }
+    stopScreenShareTracks(tracks = {}) {
+        var _a, _b, _c, _d;
+        const { audio = true, video = true } = tracks;
+        if (audio) {
+            (_b = (_a = this.screenShareTracks) === null || _a === void 0 ? void 0 : _a.audio) === null || _b === void 0 ? void 0 : _b.stop();
+        }
+        if (video) {
+            (_d = (_c = this.screenShareTracks) === null || _c === void 0 ? void 0 : _c.video) === null || _d === void 0 ? void 0 : _d.stop();
+        }
+        if (audio && video) {
+            this.screenShareEnabled = false;
+        }
+    }
+    removeAudioTrack() {
+        this.stopAudioTrack();
+        this.audioTrack = undefined;
+        this.rawAudioTrack = undefined;
+    }
+    removeVideoTrack() {
+        this.stopVideoTrack();
+        this.videoTrack = undefined;
+        this.rawVideoTrack = undefined;
+    }
+    removeScreenShareTracks(tracks) {
+        var _a;
+        (_a = this.screenShareTracks.video) === null || _a === void 0 ? void 0 : _a.removeEventListener('ended', this.onScreenShareEnded);
+        this.stopScreenShareTracks(tracks);
+        this.screenShareTracks = {
+            audio: undefined,
+            video: undefined,
+        };
+    }
+    removeAllTracks() {
+        this.removeAudioTrack();
+        this.removeVideoTrack();
+        this.removeScreenShareTracks();
+    }
+    setAudioTrack(audioTrack) {
+        if (audioTrack === this.audioTrack) {
+            return;
+        }
+        if (audioTrack === undefined) {
+            this.stopAudioTrack();
+        }
+        this.audioTrack = audioTrack;
+    }
+    setVideoTrack(videoTrack) {
+        if (videoTrack === this.videoTrack) {
+            return;
+        }
+        if (videoTrack === undefined) {
+            this.stopVideoTrack();
+        }
+        this.videoTrack = videoTrack;
+    }
+    setScreenShareTracks(tracks) {
+        var _a;
+        const { audio, video } = tracks;
+        // console.log('SetScreenshare called');
+        if (!audio || !video) {
+            this.stopScreenShareTracks({ audio: !!audio, video: !!video });
+        }
+        this.screenShareTracks = tracks;
+        (_a = this.screenShareTracks.video) === null || _a === void 0 ? void 0 : _a.addEventListener('ended', this.onScreenShareEnded.bind(this));
+    }
+    onScreenShareEnded() {
+        this.emit('SCREENSHARE_ENDED');
+    }
+    disableAudio() {
+        this.audioEnabled = false;
+        if (this.audioTrack) {
+            this.audioTrack.enabled = this.audioEnabled;
+        }
+    }
+    enableAudio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.permissions.audio !== 'ACCEPTED') {
+                try {
+                    const permResult = yield setupPermissions(true, false);
+                    this.permissions.audio = permResult.microphone;
+                }
+                catch (val) {
+                    this.permissions.audio = (_a = val.microphone) !== null && _a !== void 0 ? _a : false;
+                }
+            }
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'audio',
+                message: this.permissions.audio,
+            });
+            if (this.permissions.audio === 'DENIED') {
+                this.audioEnabled = false;
+                return;
+            }
+            try {
+                /**
+                 * NOTE (@madhugb): We need to setup new stream,
+                 * if the audio track is not preset or it has ended
+                 */
+                if (!this.audioTrack || this.audioTrack.readyState === 'ended') {
+                    yield this.setupAudioStream((_b = this.currentDevices.audio) === null || _b === void 0 ? void 0 : _b.deviceId);
+                }
+                // if we still can't get a track after setting up audio stream
+                // do not toggle the audio state
+                if (!this.audioTrack) {
+                    this.audioEnabled = false;
+                    return;
+                }
+                this.audioEnabled = true;
+            }
+            catch (ex) {
+                this.audioEnabled = false;
+                this.audioTrack = undefined;
+                this.rawAudioTrack = undefined;
+            }
+            if (this.audioTrack) {
+                this.audioTrack.enabled = true;
+            }
+        });
+    }
+    enableVideo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.toggleVideo();
+        });
+    }
+    disableVideo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.toggleVideo();
+        });
+    }
+    toggleAudio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.permissions.audio === 'DENIED') {
+                this.audioEnabled = false;
+                return;
+            }
+            if (!this.audioTrack) {
+                yield this.setupAudioStream((_a = this.currentDevices.audio) === null || _a === void 0 ? void 0 : _a.deviceId);
+            }
+            this.audioEnabled = !this.audioEnabled;
+            this.audioTrack.enabled = this.audioEnabled;
+        });
+    }
+    toggleVideo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.permissions.video !== 'ACCEPTED') {
+                try {
+                    const permResult = yield setupPermissions(false, true);
+                    this.permissions.video = permResult.camera;
+                }
+                catch (val) {
+                    this.permissions.video = (_a = val.camera) !== null && _a !== void 0 ? _a : false;
+                }
+            }
+            this.emit('MEDIA_PERMISSION_UPDATE', {
+                kind: 'video',
+                message: this.permissions.video,
+            });
+            if (this.permissions.video === 'DENIED') {
+                this.videoEnabled = false;
+                return;
+            }
+            if (this.videoEnabled) {
+                this.removeVideoTrack();
+                this.videoEnabled = false;
+                return;
+            }
+            /**
+             * NOTE(roerohan): The videoEnabled flag is used inside the setupVideoStream method
+             * hence it must be set to true first.
+             */
+            this.videoEnabled = true;
+            yield this.setupVideoStream((_b = this.currentDevices.video) === null || _b === void 0 ? void 0 : _b.deviceId);
+        });
+    }
+    setAudioDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").chooseAudioRoute(device.deviceId);
+            this.setupAudioStream(device.deviceId);
+            this.emit('AUDIO_TRACK_CHANGE');
+            this.emit('DEVICE_CHANGE', { device });
+        });
+    }
+    setVideoDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.videoEnabled) {
+                this.removeVideoTrack();
+            }
+            yield this.setupVideoStream(device.deviceId);
+            this.emit('VIDEO_TRACK_CHANGE');
+            this.emit('DEVICE_CHANGE', { device });
+        });
+    }
+    setSpeakerDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupSpeaker(device.deviceId);
+        });
+    }
+    setDevice(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").chooseAudioRoute(route.deviceId);
+        });
+    }
+    oniOSBroadcastStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setScreenShareTracks(yield LocalMediaUtils.getScreenShareTracks());
+            this.screenShareEnabled = true;
+            this.emit('SCREENSHARE_TRACK_CHANGE');
+        });
+    }
+    oniOSBroadcastStop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.screenShareEnabled) {
+                this.removeScreenShareTracks();
+                this.emit('SCREENSHARE_TRACK_CHANGE');
+                return;
+            }
+        });
+    }
+    toggleScreenShare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.screenShareEnabled && Platform.OS !== 'ios') {
+                this.removeScreenShareTracks();
+                return;
+            }
+            if (Platform.OS === 'ios' && this.screenShareEnabled) {
+                NativeModules.DyteScreensharePickerView.showScreenSharePickerView();
+                return;
+            }
+            if (Platform.OS === 'android') {
+                /* getDisplayMedia() needs to be called before configureForeground()
+                  This is because we need to get user permission starting foreground service in Android >=14
+                  1. createScreenCaptureIntent() -> startForeground()
+                */
+                this.setScreenShareTracks(yield LocalMediaUtils.getScreenShareTracks());
+                yield this.configureForeground();
+                this.screenShareEnabled = true;
+            }
+            if (Platform.OS === 'ios') {
+                NativeModules.DyteScreensharePickerView.showScreenSharePickerView();
+            }
+        });
+    }
+    enableScreenShare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.toggleScreenShare();
+        });
+    }
+    disableScreenShare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.toggleScreenShare();
+        });
+    }
+    destruct() {
+        this.removeAllTracks();
+        this.removeAllListeners();
+        InCallManger.stop(undefined);
+    }
+    getAllDevices() {
+        return __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").availableDevices;
+    }
+    getCurrentDevices() {
+        return this.currentDevices;
+    }
+    getDeviceById(deviceId, kind) {
+        return __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getDeviceById(deviceId, kind);
+    }
+    getAudioDevices() {
+        return __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getAudioDevices();
+    }
+    getVideoDevices() {
+        return __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getVideoDevices();
+    }
+    getSpeakerDevices() {
+        return __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").getSpeakerDevices();
+    }
+    onDeviceChange(changedDevices, forceDeviceChange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let addedDevice;
+            let removedDevice;
+            if (changedDevices.added.length)
+                [addedDevice] = changedDevices.added;
+            if (changedDevices.removed.length)
+                [removedDevice] = changedDevices.removed;
+            /**
+             * NOTE(roerohan): forceStopTrack is set required to be set to true for firefox.
+             * https://stackoverflow.com/questions/59068146/navigator-mediadevices-getusermedia-api-rejecting-with-error-notreadableerror
+             * forceStopTrack is the second argument of setupAudioStream and setupVideoStream.
+             */
+            if (addedDevice) {
+                if (addedDevice.kind === 'audioinput') {
+                    yield this.setupAudioStream(addedDevice.deviceId);
+                    this.emit('DEVICE_CHANGE', this.currentDevices.audio);
+                }
+                else if (addedDevice.kind === 'videoinput') {
+                    yield this.setupVideoStream(addedDevice.deviceId);
+                    this.emit('DEVICE_CHANGE', this.currentDevices.video);
+                }
+                else if (addedDevice.kind === 'audiooutput') {
+                    yield this.setupSpeaker(addedDevice.deviceId);
+                }
+                this.emit('AUDIO_TRACK_CHANGE');
+            }
+            if (removedDevice) {
+                if (removedDevice.kind === 'audioinput') {
+                    yield this.setupAudioStream();
+                }
+                else if (removedDevice.kind === 'videoinput') {
+                    yield this.setupVideoStream();
+                }
+                else if (removedDevice.kind === 'audiooutput') {
+                    yield this.setupSpeaker();
+                }
+                this.emit('AUDIO_TRACK_CHANGE');
+            }
+            this.emit('DEVICE_LIST_UPDATED', changedDevices);
+        });
+    }
+    cleanUpTracks() {
+        var _a, _b, _c, _d;
+        (_a = this.audioTrack) === null || _a === void 0 ? void 0 : _a.stop();
+        (_b = this.rawAudioTrack) === null || _b === void 0 ? void 0 : _b.stop();
+        (_c = this.videoTrack) === null || _c === void 0 ? void 0 : _c.stop();
+        (_d = this.rawVideoTrack) === null || _d === void 0 ? void 0 : _d.stop();
+        this.destructor();
+    }
+    destructMediaHandler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _LocalMediaHandler_localMediaUtils, "f").destruct();
+            return this.destruct();
+        });
+    }
+    static init(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield setupPermissions(true, true);
+            const localMediaUtils = yield LocalMediaUtils.init();
+            return new LocalMediaHandler(localMediaUtils);
+        });
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+}
+_LocalMediaHandler_localMediaUtils = new WeakMap(), _LocalMediaHandler_appState = new WeakMap(), _LocalMediaHandler_appStateSubscription = new WeakMap(), _LocalMediaHandler_interval = new WeakMap();
+export default LocalMediaHandler;