@wazo/sdk 0.43.6 → 1.0.0-alpha.1

package/lib/voice/call.js

@@ -0,0 +1,577 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_TRACK_UPDATED = exports.MESSAGE_TYPE_SIGNAL = exports.MESSAGE_TYPE_CHAT = exports.EVENT_TERMINATE_SOUND = exports.EVENT_CAMERA_DISABLED = exports.EVENT_CAMERA_RESUMED = exports.EVENT_WEB_RTC_STATS = exports.EVENT_SHARE_SCREEN_ENDED = exports.EVENT_SHARE_SCREEN_STARTED = exports.EVENT_SHARE_SCREEN_ENDING = exports.EVENT_REMOVE_STREAM = exports.EVENT_VIDEO_STREAM = exports.EVENT_AUDIO_STREAM = exports.EVENT_TRACK = exports.EVENT_REINVITE = exports.EVENT_CALL_RESUMED = exports.EVENT_CALL_HELD = exports.EVENT_CALL_UN_MUTED = exports.EVENT_CALL_MUTED = exports.EVENT_CALL_ENDED = exports.EVENT_CALL_TERMINATING = exports.EVENT_CALL_REJECTED = exports.EVENT_CALL_ERROR = exports.EVENT_EARLY_MEDIA = exports.EVENT_PROGRESS = exports.EVENT_CALL_CANCELED = exports.EVENT_CALL_ACCEPTED = void 0;
+/* eslint-disable no-underscore-dangle */
+const events_1 = require("events");
+const xstate_1 = require("xstate");
+const invitation_1 = require("sip.js/lib/api/invitation");
+const session_state_1 = require("sip.js/lib/api/session-state");
+const call_state_machine_1 = __importStar(require("../state-machine/call-state-machine"));
+const IssueReporter_1 = __importDefault(require("../service/IssueReporter"));
+const sdp_1 = require("../utils/sdp");
+const utils_1 = require("../state-machine/utils");
+const webrtc_1 = require("../utils/webrtc");
+const logger = IssueReporter_1.default.loggerFor('call');
+// Events
+exports.EVENT_CALL_ACCEPTED = 'accepted';
+exports.EVENT_CALL_CANCELED = 'canceled';
+exports.EVENT_PROGRESS = 'progress';
+exports.EVENT_EARLY_MEDIA = 'earlyMedia';
+exports.EVENT_CALL_ERROR = 'error';
+exports.EVENT_CALL_REJECTED = 'rejected';
+exports.EVENT_CALL_TERMINATING = 'terminating';
+exports.EVENT_CALL_ENDED = 'ended';
+exports.EVENT_CALL_MUTED = 'muted';
+exports.EVENT_CALL_UN_MUTED = 'unMuted';
+exports.EVENT_CALL_HELD = 'held';
+exports.EVENT_CALL_RESUMED = 'resumed';
+exports.EVENT_REINVITE = 'reinvite';
+exports.EVENT_TRACK = 'track';
+exports.EVENT_AUDIO_STREAM = 'onAudioStream';
+exports.EVENT_VIDEO_STREAM = 'onVideoStream';
+exports.EVENT_REMOVE_STREAM = 'onRemoveStream';
+exports.EVENT_SHARE_SCREEN_ENDING = 'onScreenShareEnding';
+exports.EVENT_SHARE_SCREEN_STARTED = 'onScreenShareStarted';
+exports.EVENT_SHARE_SCREEN_ENDED = 'onScreenShareEnded';
+exports.EVENT_WEB_RTC_STATS = 'webRtcStats';
+exports.EVENT_CAMERA_RESUMED = 'onCameraResumed';
+exports.EVENT_CAMERA_DISABLED = 'onCameraDisabled';
+exports.EVENT_TERMINATE_SOUND = 'terminateSound';
+exports.MESSAGE_TYPE_CHAT = 'message/TYPE_CHAT';
+exports.MESSAGE_TYPE_SIGNAL = 'message/TYPE_SIGNAL';
+exports.MESSAGE_TRACK_UPDATED = 'onTrackUpdated';
+class Call extends events_1.EventEmitter {
+    constructor(sipCall, phone) {
+        super();
+        this.shouldSendReinvite = false;
+        this.callActor = (0, xstate_1.createActor)(call_state_machine_1.default);
+        this.callActor.start();
+        this.creationTime = new Date();
+        this.phone = phone;
+        this.sipCall = sipCall;
+        this._bindEvents();
+    }
+    accept() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            (0, utils_1.assertCan)(this.callActor, call_state_machine_1.Actions.ACCEPT);
+            logger.info('call - accept', Object.assign({ id: this.id }, options));
+            this._sendAction(call_state_machine_1.Actions.ACCEPT);
+            this.phone.holdAllCalls(this);
+            this.shouldSendReinvite = false;
+            this.answerTime = new Date();
+            return this.phone.client.answer(this.sipCall, options.withCamera).then(() => {
+                logger.info('call - accepted', Object.assign({ id: this.id }, options));
+                return this.id;
+            }).catch(e => {
+                logger.error(e);
+                this.hangup();
+                throw e;
+            });
+        });
+    }
+    reject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertCan)(this.callActor, call_state_machine_1.Actions.REJECT);
+            logger.info('call - reject', { id: this.id });
+            this.eventEmitter.emit(exports.EVENT_TERMINATE_SOUND, 'call rejected locally');
+            this.shouldSendReinvite = false;
+            return this.hangup();
+        });
+    }
+    hangup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertCan)(this.callActor, call_state_machine_1.Actions.HANGUP);
+            logger.info('call - hangup', { id: this.id });
+            yield this.phone.client.hangup(this.sipCall);
+            // Remove this call from softphone's calls
+            this.phone.removeCall(this);
+            return true;
+        });
+    }
+    forceCancel() {
+        try {
+            // @ts-ignore: private
+            this.sipCall.outgoingInviteRequest.cancel();
+        }
+        catch (e) {
+            logger.info('call - force cancel, error', e);
+        }
+    }
+    startConference(withCalls) {
+        // @TODO
+        // const participants = [this, ...withCalls].reduce((acc: Record<string, any>, call: Call) => {
+        //   acc[call.talkingToIds[0]] = call;
+        //   return acc;
+        // }, {});
+        // const adHocConference = new AdHocAPIConference({
+        //   phone: this.phone,
+        //   host,
+        //   participants,
+        // });
+        // return adHocConference.start();
+    }
+    mute() {
+        (0, utils_1.assertCan)(this.callActor, call_state_machine_1.EstablishedActions.MUTE);
+        logger.info('call - mute', { id: this.id });
+        this._sendAction(call_state_machine_1.EstablishedActions.MUTE);
+        this.phone.client.mute(this.sipCall);
+        this.eventEmitter.emit(exports.EVENT_CALL_MUTED);
+    }
+    unMute() {
+        (0, utils_1.assertCan)(this.callActor, call_state_machine_1.EstablishedActions.UN_MUTE);
+        logger.info('call - un-mute', { id: this.id });
+        this._sendAction(call_state_machine_1.EstablishedActions.UN_MUTE);
+        this.phone.client.unmute(this.sipCall);
+        this.eventEmitter.emit(exports.EVENT_CALL_UN_MUTED);
+    }
+    hold() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertCan)(this.callActor, call_state_machine_1.EstablishedActions.HOLD);
+            logger.info('call - hold', { id: this.id });
+            this._sendAction(call_state_machine_1.EstablishedActions.HOLD);
+            const hasVideo = (0, webrtc_1.hasLocalVideo)(this.sipCall);
+            // Stop screenshare if needed
+            if (this.currentScreenShare && this.currentScreenShare.sipSessionId === this.id) {
+                yield this.stopScreenSharing(false);
+            }
+            // Downgrade to audio if needed
+            if (hasVideo) {
+                yield (0, webrtc_1.downgradeToAudio)(this.sipCall);
+            }
+            const promise = this.phone.client.hold(this.sipCall, this.isConference(), hasVideo);
+            this.eventEmitter.emit(exports.EVENT_CALL_HELD);
+            return promise;
+        });
+    }
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertCan)(this.callActor, call_state_machine_1.EstablishedActions.RESUME);
+            this._sendAction(call_state_machine_1.EstablishedActions.RESUME);
+            const isConference = this.isConference();
+            const hasVideo = (0, webrtc_1.hasLocalVideo)(this.sipCall);
+            const wasScreensharing = this.currentScreenShare && this.currentScreenShare.sipSessionId === this.id;
+            const wasDesktop = this.currentScreenShare && this.currentScreenShare.desktop;
+            logger.info('call - resume', { id: this.id, isConference, hasVideo, wasScreensharing, wasDesktop });
+            const promise = this.phone.client.unhold(this.sipCall, isConference);
+            if (hasVideo) {
+                const constraints = {
+                    audio: false,
+                    video: true,
+                    screen: wasScreensharing,
+                    desktop: wasDesktop,
+                };
+                yield (0, webrtc_1.upgradeToVideo)(this.sipCall, constraints, isConference);
+            }
+            const onScreenSharing = (stream) => {
+                const hadVideo = this.currentScreenShare && this.currentScreenShare.hadVideo;
+                if (stream) {
+                    this._onScreenSharing(stream, hadVideo, wasDesktop);
+                }
+            };
+            this.eventEmitter.emit(exports.EVENT_CALL_RESUMED);
+            return promise.then(() => {
+                const stream = this.getLocalVideoStream();
+                if (wasScreensharing) {
+                    onScreenSharing(this.getLocalVideoStream());
+                }
+                return stream;
+            });
+        });
+    }
+    turnCameraOn() {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - turn camera on', { id: this.id });
+        (0, webrtc_1.toggleVideo)(this.sipCall, true);
+        this.eventEmitter.emit(exports.EVENT_CAMERA_RESUMED);
+    }
+    turnCameraOff() {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call -  turn camera off', { id: this.id });
+        (0, webrtc_1.toggleVideo)(this.sipCall, false);
+        this.eventEmitter.emit(exports.EVENT_CAMERA_DISABLED);
+    }
+    isHeld() {
+        return (0, utils_1.getState)(this.callActor) === call_state_machine_1.EstablishedStates.HELD;
+    }
+    isEstablished() {
+        return (0, utils_1.getState)(this.callActor) === call_state_machine_1.States.ESTABLISHED;
+    }
+    isConference() {
+        var _a;
+        return (_a = (0, webrtc_1.getPeerConnection)(this.sipCall)) === null || _a === void 0 ? void 0 : _a.sfu;
+    }
+    transfer(target) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - transfer', { id: this.id, target });
+        this.phone.client.transfer(this.sipCall, target);
+    }
+    atxfer() {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - atxfer', { id: this.id });
+        return this.phone.client.atxfer(this.sipCall);
+    }
+    sendDigits(digits) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - send digits', { id: this.id, digits });
+        this.phone.client.sendDTMF(this.sipCall, digits);
+    }
+    startNetworkMonitoring(interval = 1000) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - start network monitoring', { id: this.id });
+        return this.phone.client.startNetworkMonitoring(this.sipCall, interval);
+    }
+    stopNetworkMonitoring() {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - stop network monitoring', { id: this.id });
+        return this.phone.client.stopNetworkMonitoring(this.sipCall);
+    }
+    getStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, webrtc_1.getWebRtcStats)(this.sipCall);
+        });
+    }
+    sendReinvite() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a, _b;
+            (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+            logger.info('call - send reinvite', Object.assign({ id: this.id }, options));
+            const shouldScreenShare = (_a = options.constraints) === null || _a === void 0 ? void 0 : _a.screen;
+            const isUpgrade = shouldScreenShare || ((_b = options.constraints) === null || _b === void 0 ? void 0 : _b.video);
+            // Downgrade
+            if (options.constraints && !isUpgrade) {
+                // No reinvite needed
+                this._downgradeToAudio();
+                return;
+            }
+            if (isUpgrade) {
+                const shouldReinvite = yield this._upgradeToVideo(options);
+                if (!shouldReinvite) {
+                    return;
+                }
+            }
+            return this.phone.client.reinvite(this.sipCall, options.constraints, options.conference, options.audioOnly, options.iceRestart);
+        });
+    }
+    sendMessage(body, contentType = 'text/plain') {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - send message', { id: this.id, body });
+        return this.phone.client.sendMessage(this.sipCall, body, contentType);
+    }
+    sendChat(content) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - send chat', { id: this.id, content });
+        this.sendMessage(JSON.stringify({ type: exports.MESSAGE_TYPE_CHAT, content }), 'application/json');
+    }
+    sendSignal(content) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - send signal', { id: this.id, content });
+        this.sendMessage(JSON.stringify({ type: exports.MESSAGE_TYPE_SIGNAL, content }), 'application/json');
+    }
+    startScreenSharing(constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+            logger.info('call - start screen sharing', { constraints, id: this.id });
+            const screenShareStream = yield (0, webrtc_1.getStreamFromConstraints)(constraints);
+            if (!screenShareStream) {
+                throw new Error(`Can't create media stream for screensharing with: ${JSON.stringify(constraints)}`);
+            }
+            const screenTrack = screenShareStream.getVideoTracks()[0];
+            const pc = (0, webrtc_1.getPeerConnection)(this.sipCall);
+            const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
+            const localStream = (0, webrtc_1.getLocalStream)(this.sipCall);
+            const videoTrack = localStream ? localStream.getTracks().find(track => track.kind === 'video') : null;
+            const hadVideo = !!videoTrack;
+            // Stop local video tracks
+            if (videoTrack && localStream) {
+                videoTrack.enabled = false;
+                videoTrack.stop();
+                localStream.removeTrack(videoTrack);
+            }
+            if (localStream) {
+                localStream.addTrack(screenTrack);
+            }
+            if (sender) {
+                sender.replaceTrack(screenTrack);
+            }
+            this._onScreenSharing(screenShareStream, hadVideo, constraints.desktop);
+            return screenShareStream;
+        });
+    }
+    stopScreenSharing() {
+        return __awaiter(this, arguments, void 0, function* (restoreLocalStream = true) {
+            (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+            if (!this.currentScreenShare) {
+                return;
+            }
+            logger.info('call - stop screen sharing', { restoreLocalStream });
+            let reinvited = null;
+            try {
+                if (this.currentScreenShare.stream) {
+                    this.currentScreenShare.stream.getTracks()
+                        .filter((track) => track.enabled && track.kind === 'video')
+                        .forEach((track) => track.stop());
+                }
+                if (restoreLocalStream) {
+                    const conference = this.isConference();
+                    // When stopping screenshare and we had video before that, we have to re-upgrade
+                    // When upgrading directly to screenshare (eg: we don't have a videoLocalStream to replace)
+                    // We have to downgrade to audio.
+                    const screenshareStopped = this.currentScreenShare.hadVideo;
+                    const constraints = {
+                        audio: false,
+                        video: screenshareStopped,
+                    };
+                    // We have to remove the video sender to be able to re-upgrade to video in `sendReinvite` below
+                    this._downgradeToAudio(false);
+                    // Wait for the track to be removed, unless the video sender won't have a null track in `_upgradeToVideo`.
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    reinvited = yield this.sendReinvite({ constraints, conference });
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            this.eventEmitter.emit(exports.EVENT_SHARE_SCREEN_ENDED);
+            this.currentScreenShare = null;
+            return reinvited;
+        });
+    }
+    onScreenShareReinvite(response, desktop) {
+        const localStream = (0, webrtc_1.getLocalStream)(this.sipCall);
+        logger.info('call - updrading directly in screensharing mode', { id: this.id, tracks: localStream === null || localStream === void 0 ? void 0 : localStream.getTracks() });
+        this._onScreenSharing(localStream, false, desktop);
+    }
+    onAccepted() {
+        this._sendAction(call_state_machine_1.Actions.REMOTLY_ACCEPTED);
+        this.emit(exports.EVENT_CALL_ACCEPTED);
+    }
+    onProgress() {
+        this.emit(exports.EVENT_PROGRESS);
+    }
+    onEarlyMedia() {
+        this.emit(exports.EVENT_EARLY_MEDIA);
+    }
+    onTrack(event) {
+        this.emit(exports.EVENT_TRACK, event);
+    }
+    onError(error) {
+        this.emit(exports.EVENT_CALL_ERROR, error);
+    }
+    onRejected() {
+        this.endTime = new Date();
+        this.emit(exports.EVENT_CALL_REJECTED);
+        this.phone.removeCall(this);
+    }
+    onNetworkStats(stats, previousStats) {
+        this.emit(exports.EVENT_WEB_RTC_STATS, stats, previousStats);
+    }
+    getRemoteStream() {
+        return (0, webrtc_1.getRemoteStream)(this.sipCall);
+    }
+    getRemoteVideoStream() {
+        return (0, webrtc_1.getRemoteVideoStream)(this.sipCall);
+    }
+    hasRemoteVideo() {
+        return (0, webrtc_1.hasRemoteVideo)(this.sipCall);
+    }
+    hasLocalVideo() {
+        return (0, webrtc_1.hasLocalVideo)(this.sipCall);
+    }
+    getLocalStream() {
+        return (0, webrtc_1.getLocalStream)(this.sipCall);
+    }
+    getLocalVideoStream() {
+        return (0, webrtc_1.getLocalVideoStream)(this.sipCall);
+    }
+    hasALocalVideoTrack() {
+        return (0, webrtc_1.hasALocalVideoTrack)(this.sipCall);
+    }
+    isVideoRemotelyHeld() {
+        return (0, webrtc_1.isVideoRemotelyHeld)(this.sipCall);
+    }
+    onReinvite(request, updatedCalleeName, updatedNumber, hadRemoteVideo) {
+        this.emit(exports.EVENT_REINVITE, request, updatedCalleeName, updatedNumber, hadRemoteVideo);
+    }
+    get id() {
+        return (0, sdp_1.getSipSessionId)(this.sipCall);
+    }
+    get number() {
+        const identity = this.sipCall.remoteIdentity || this.sipCall.assertedIdentity;
+        // @ts-ignore: private
+        return identity ? identity.uri._normal.user : null;
+    }
+    _bindEvents() {
+        if (this.sipCall instanceof invitation_1.Invitation) {
+            // Monkey patch to know when canceled with the CANCEL message
+            const onCancel = this.sipCall._onCancel.bind(this.sipCall);
+            this.sipCall._onCancel = (message) => {
+                logger.trace('call - on sip session canceled', { callId: message.callId, id: this.id });
+                onCancel(message);
+                const elsewhere = message.data.indexOf('cause=26') !== -1 && message.data.indexOf('completed elsewhere') !== -1;
+                this.eventEmitter.emit(exports.EVENT_CALL_CANCELED, elsewhere);
+            };
+        }
+        this.sipCall.stateChange.addListener((newState) => {
+            switch (newState) {
+                case session_state_1.SessionState.Terminating:
+                    logger.info('call - terminating', { id: this.id });
+                    this.eventEmitter.emit(exports.EVENT_CALL_TERMINATING);
+                    break;
+                case session_state_1.SessionState.Terminated:
+                    {
+                        logger.info('call - terminated', { id: this.id });
+                        // Should be called before `_onCallTerminated` or the callCount will not decrement...
+                        this.endTime = new Date();
+                        return this.eventEmitter.emit(exports.EVENT_CALL_ENDED);
+                    }
+                default:
+                    break;
+            }
+        });
+        if (!this.sipCall.sessionDescriptionHandler) {
+            return;
+        }
+        // Video events
+        const sdh = this.sipCall.sessionDescriptionHandler;
+        const peerConnection = sdh.peerConnection;
+        if (!peerConnection) {
+            logger.warn('call - no peer connection', { id: this.id });
+            return;
+        }
+        peerConnection.ontrack = (rawEvent) => {
+            const event = rawEvent;
+            const [stream] = event.streams;
+            const kind = event && event.track && event.track.kind;
+            logger.info('call - on track stream called on the peer connection', {
+                id: this.id,
+                streamId: stream ? stream.id : null,
+                tracks: stream ? stream.getTracks() : null,
+                kind,
+            });
+            if (kind === 'audio') {
+                return this.eventEmitter.emit(exports.EVENT_AUDIO_STREAM, stream);
+            }
+            return this.eventEmitter.emit(exports.EVENT_VIDEO_STREAM, stream, event.track.id, event);
+        };
+        peerConnection.onremovestream = (event) => {
+            logger.info('call - on remove stream called on the peer connection', {
+                id: event.stream.id,
+                tracks: event.stream.getTracks(),
+            });
+            this.eventEmitter.emit(exports.EVENT_REMOVE_STREAM, event.stream);
+        };
+        // Client events
+    }
+    _downgradeToAudio(withMessage = true) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - downgrade to audio', { id: this.id, withMessage });
+        (0, webrtc_1.downgradeToAudio)(this.sipCall);
+        if (withMessage) {
+            this._sendReinviteMessage(false);
+        }
+        return true;
+    }
+    // Returns true if we need to send a re-INVITE request
+    _upgradeToVideo() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a, _b;
+            (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+            logger.info('call - upgrade to video', Object.assign({ id: this.id }, options));
+            const shouldScreenShare = (_a = options.constraints) === null || _a === void 0 ? void 0 : _a.screen;
+            const desktop = (_b = options.constraints) === null || _b === void 0 ? void 0 : _b.desktop;
+            const sdhOptions = this.sipCall.sessionDescriptionHandlerOptionsReInvite;
+            const wasAudioOnly = sdhOptions === null || sdhOptions === void 0 ? void 0 : sdhOptions.audioOnly;
+            const newStream = yield (0, webrtc_1.upgradeToVideo)(this.sipCall, options.constraints || {}, !!options.conference);
+            // If no stream is returned, it means we have to reinvite
+            if (!newStream) {
+                return true;
+            }
+            this._sendReinviteMessage(true);
+            if (shouldScreenShare) {
+                this._onScreenSharing(newStream, false, desktop);
+            }
+            // We have to reinvite to change the direction on the bundle when upgrading from an audioOnly conference
+            if (options.conference && wasAudioOnly) {
+                return true;
+            }
+            // No reinvite needed here
+            return false;
+        });
+    }
+    _sendReinviteMessage(isUpgrade) {
+        (0, utils_1.assertState)(this.callActor, call_state_machine_1.States.ESTABLISHED);
+        logger.info('call - sending reinvite message', { id: this.id, isUpgrade });
+        // Have to send the message after a delay due to latency to update the remote peer
+        setTimeout(() => {
+            this.sendMessage(JSON.stringify({
+                type: exports.MESSAGE_TYPE_SIGNAL,
+                content: {
+                    type: exports.MESSAGE_TRACK_UPDATED,
+                    update: isUpgrade ? 'upgrade' : 'downgrade',
+                    sipCallId: this.id,
+                    callId: this.apiId,
+                    number: this.number,
+                },
+            }));
+        }, 2500);
+    }
+    _onScreenSharing(screenStream, hadVideo, desktop) {
+        const screenTrack = screenStream.getVideoTracks()[0];
+        const pc = this.phone.client.getPeerConnection(this.id);
+        const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
+        logger.info('call - on screensharing', { hadVideo, id: this.id, screenTrack });
+        if (screenTrack) {
+            screenTrack.onended = () => {
+                logger.info('call - on screenshare ended', { hadVideo, id: this.id, screenTrack });
+                this.eventEmitter.emit(exports.EVENT_SHARE_SCREEN_ENDING);
+            };
+        }
+        this.currentScreenShare = {
+            stream: screenStream,
+            hadVideo,
+            sender,
+            desktop,
+        };
+        (0, webrtc_1.setLocalMediaStream)(this.sipCall, screenStream);
+        this.eventEmitter.emit(exports.EVENT_SHARE_SCREEN_STARTED, screenStream);
+    }
+    _sendAction(action) {
+        this.callActor.send({ type: action });
+    }
+}
+exports.default = Call;