@voicenter-team/opensips-js 1.0.21 → 1.0.42

package/build/index.js

@@ -1,911 +0,0 @@
-"use strict";
-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 });
-const jssip_1 = __importDefault(require("jssip"));
-const UA_1 = __importDefault(require("./helpers/UA"));
-const p_iteration_1 = require("p-iteration");
-const time_helper_1 = require("./helpers/time.helper");
-const filter_helper_1 = require("./helpers/filter.helper");
-const audio_helper_1 = require("./helpers/audio.helper");
-const metrics_1 = __importDefault(require("./helpers/webrtcmetrics/metrics"));
-const metric_keys_to_include_1 = require("./enum/metric.keys.to.include");
-const call_event_listener_type_1 = require("./enum/call.event.listener.type");
-const CALL_STATUS_UNANSWERED = 0;
-const STORAGE_KEYS = {
-    SELECTED_INPUT_DEVICE: 'selectedInputDevice',
-    SELECTED_OUTPUT_DEVICE: 'selectedOutputDevice'
-};
-class OpenSIPSJS extends UA_1.default {
-    constructor(options) {
-        const configuration = Object.assign(Object.assign({}, options.configuration), { sockets: options.socketInterfaces.map(sock => new jssip_1.default.WebSocketInterface(sock)) });
-        super(configuration);
-        this.initialized = false;
-        this.newRTCSessionEventName = 'newRTCSession';
-        this.registeredEventName = 'registered';
-        this.unregisteredEventName = 'unregistered';
-        this.activeCalls = {};
-        this.extendedCalls = {};
-        this.state = {
-            isMuted: false,
-            isAutoAnswer: false,
-            activeCalls: {},
-            extendedCalls: {},
-            availableMediaDevices: [],
-            selectedMediaDevices: {
-                input: 'default',
-                output: 'default' //localStorage.getItem(STORAGE_KEYS.SELECTED_OUTPUT_DEVICE) || 'default'
-            },
-            microphoneInputLevel: 2,
-            speakerVolume: 1,
-            muteWhenJoin: false,
-            originalStream: null,
-            isDND: false,
-            listeners: {},
-            activeRooms: {},
-            callStatus: {},
-            callTime: {},
-            timeIntervals: {},
-            callMetrics: {},
-            metricConfig: {
-                refreshEvery: 1000,
-            }
-        };
-        this.options = options;
-    }
-    on(type, listener) {
-        return super.on(type, listener);
-    }
-    off(type, listener) {
-        return super.off(type, listener);
-    }
-    emit(type, args) {
-        return super.emit(type, args);
-    }
-    get sipDomain() {
-        return this.options.sipDomain;
-    }
-    get sipOptions() {
-        const options = Object.assign(Object.assign({}, this.options.sipOptions), { mediaConstraints: this.getUserMediaConstraints });
-        return options;
-    }
-    get currentActiveRoomId() {
-        return this._currentActiveRoomId;
-    }
-    set currentActiveRoomId(roomId) {
-        this._currentActiveRoomId = roomId;
-        this.emit('currentActiveRoomChanged', roomId);
-    }
-    get autoAnswer() {
-        return this.state.isAutoAnswer;
-    }
-    set autoAnswer(value) {
-        this.state.isAutoAnswer = value;
-    }
-    get callAddingInProgress() {
-        return this._callAddingInProgress;
-    }
-    set callAddingInProgress(value) {
-        this._callAddingInProgress = value;
-        this.emit('callAddingInProgressChanged', value);
-    }
-    get muteWhenJoin() {
-        return this.state.muteWhenJoin;
-    }
-    set muteWhenJoin(value) {
-        this.state.muteWhenJoin = value;
-        this.emit('changeMuteWhenJoin', value);
-    }
-    get isDND() {
-        return this.state.isDND;
-    }
-    set isDND(value) {
-        this.state.isDND = value;
-        this.emit('changeIsDND', value);
-    }
-    get speakerVolume() {
-        return this.state.speakerVolume;
-    }
-    set speakerVolume(value) {
-        this.state.speakerVolume = value;
-        Object.values(this.state.extendedCalls).forEach((call) => {
-            if (call.audioTag) {
-                call.audioTag.volume = value;
-            }
-        });
-    }
-    get microphoneInputLevel() {
-        return this.state.microphoneInputLevel;
-    }
-    set microphoneInputLevel(value) {
-        this.state.microphoneInputLevel = value;
-        this.roomReconfigure(this.currentActiveRoomId);
-    }
-    get getActiveCalls() {
-        return this.state.activeCalls;
-    }
-    get hasActiveCalls() {
-        return Object.values(this.state.extendedCalls).length > 0;
-    }
-    get getActiveRooms() {
-        return this.state.activeRooms;
-    }
-    get isMuted() {
-        return this.state.isMuted;
-    }
-    set isMuted(value) {
-        this.state.isMuted = value;
-        this.emit('changeIsMuted', value);
-    }
-    get getInputDeviceList() {
-        return this.state.availableMediaDevices.filter(device => device.kind === 'audioinput');
-    }
-    get getOutputDeviceList() {
-        return this.state.availableMediaDevices.filter(device => device.kind === 'audiooutput');
-    }
-    /*getInputDeviceList: (state) => {
-        return state.availableMediaDevices.filter(device => device.kind === 'audioinput');
-    },
-    getOutputDeviceList: (state) => {
-        return state.availableMediaDevices.filter(device => device.kind === 'audiooutput');
-    }*/
-    get getUserMediaConstraints() {
-        return {
-            audio: {
-                deviceId: {
-                    exact: this.state.selectedMediaDevices.input
-                }
-            },
-            video: false
-        };
-    }
-    get getInputDefaultDevice() {
-        return this.getInputDeviceList.find(device => device.deviceId === 'default');
-    }
-    get getOutputDefaultDevice() {
-        return this.getOutputDeviceList.find(device => device.deviceId === 'default');
-    }
-    get selectedInputDevice() {
-        return this.state.selectedMediaDevices.input;
-    }
-    set selectedInputDevice(deviceId) {
-        localStorage.setItem(STORAGE_KEYS.SELECTED_INPUT_DEVICE, deviceId);
-        this.state.selectedMediaDevices.input = deviceId;
-        this.emit('changeActiveInputMediaDevice', deviceId);
-    }
-    get selectedOutputDevice() {
-        return this.state.selectedMediaDevices.output;
-    }
-    set selectedOutputDevice(deviceId) {
-        localStorage.setItem(STORAGE_KEYS.SELECTED_OUTPUT_DEVICE, deviceId);
-        this.state.selectedMediaDevices.output = deviceId;
-        this.emit('changeActiveOutputMediaDevice', deviceId);
-    }
-    get originalStream() {
-        return this.state.originalStream;
-    }
-    setAvailableMediaDevices(devices) {
-        this.state.availableMediaDevices = devices;
-        this.emit('changeAvailableDeviceList', devices);
-    }
-    updateDeviceList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-            const devices = yield navigator.mediaDevices.enumerateDevices();
-            this.setAvailableMediaDevices(devices);
-        });
-    }
-    setMediaDevices(setDefaults = false) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.state.selectedMediaDevices.input = localStorage.getItem(STORAGE_KEYS.SELECTED_INPUT_DEVICE) || 'default';
-            this.state.selectedMediaDevices.output = localStorage.getItem(STORAGE_KEYS.SELECTED_OUTPUT_DEVICE) || 'default';
-            yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-            const devices = yield navigator.mediaDevices.enumerateDevices();
-            this.setAvailableMediaDevices(devices);
-            const defaultMicrophone = setDefaults
-                ? ((_a = this.getInputDefaultDevice) === null || _a === void 0 ? void 0 : _a.deviceId) || ''
-                : '';
-            const defaultSpeaker = setDefaults
-                ? ((_b = this.getOutputDefaultDevice) === null || _b === void 0 ? void 0 : _b.deviceId) || ''
-                : '';
-            yield this.setMicrophone(defaultMicrophone);
-            yield this.setSpeaker(defaultSpeaker);
-        });
-    }
-    setCallTime(value) {
-        const time = Object.assign({}, value);
-        delete time.callId;
-        this.state.callTime = Object.assign(Object.assign({}, this.state.callTime), { [value.callId]: time });
-    }
-    removeCallTime(callId) {
-        const callTimeCopy = Object.assign({}, this.state.callTime);
-        delete callTimeCopy[callId];
-        this.state.callTime = Object.assign({}, callTimeCopy);
-    }
-    setTimeInterval(callId, interval) {
-        this.state.timeIntervals = Object.assign(Object.assign({}, this.state.timeIntervals), { [callId]: interval });
-    }
-    removeTimeInterval(callId) {
-        const timeIntervalsCopy = Object.assign({}, this.state.timeIntervals);
-        clearInterval(timeIntervalsCopy[callId]);
-        delete timeIntervalsCopy[callId];
-        this.state.timeIntervals = Object.assign({}, timeIntervalsCopy);
-    }
-    _stopCallTimer(callId) {
-        this.removeTimeInterval(callId);
-        this.removeCallTime(callId);
-    }
-    setMetricsConfig(config) {
-        this.state.metricConfig = Object.assign(Object.assign({}, this.state.metricConfig), config);
-    }
-    sendDTMF(callId, value) {
-        const validation_regex = /^[A-D0-9]+$/g;
-        if (!validation_regex.test(value)) {
-            throw new Error('Not allowed character in DTMF input');
-        }
-        const call = this.state.extendedCalls[callId];
-        call.sendDTMF(value);
-    }
-    doMute(value) {
-        const activeRoomId = this.currentActiveRoomId;
-        this.isMuted = value;
-        this.roomReconfigure(activeRoomId);
-    }
-    sendMessage(target, body, options) {
-        return super.sendMessage(`sip:${target}@${this.sipDomain}`, body, options);
-    }
-    doCallHold({ callId, toHold, automatic }) {
-        const call = this.state.extendedCalls[callId];
-        call._automaticHold = automatic !== null && automatic !== void 0 ? automatic : false;
-        if (toHold) {
-            call.hold();
-        }
-        else {
-            call.unhold();
-        }
-    }
-    _cancelAllOutgoingUnanswered() {
-        Object.values(this.getActiveCalls).filter(call => {
-            return call.direction === 'outgoing'
-                && call.status === CALL_STATUS_UNANSWERED;
-        }).forEach(call => this.callTerminate(call._id));
-    }
-    callAnswer(callId) {
-        const call = this.state.extendedCalls[callId];
-        this._cancelAllOutgoingUnanswered();
-        call.answer(this.sipOptions);
-        this.updateCall(call);
-        // TODO: maybe would be better to move to the top
-        this.setCurrentActiveRoomId(call.roomId);
-        call.connection.addEventListener('addstream', (event) => __awaiter(this, void 0, void 0, function* () {
-            this._triggerAddStream(event, call);
-        }));
-    }
-    callMove(callId, roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._updateCallStatus({ callId, isMoving: true });
-            yield this.callChangeRoom({ callId, roomId });
-            this._updateCallStatus({ callId, isMoving: false });
-        });
-    }
-    updateCall(value) {
-        this.state.activeCalls[value._id] = (0, audio_helper_1.simplifyCallObject)(value);
-        this.emit('changeActiveCalls', this.state.activeCalls);
-    }
-    updateRoom(value) {
-        const room = this.state.activeRooms[value.roomId];
-        const newRoomData = Object.assign(Object.assign({}, room), value);
-        this.state.activeRooms = Object.assign(Object.assign({}, this.state.activeRooms), { [value.roomId]: Object.assign({}, newRoomData) });
-        this.emit('updateRoom', { room: newRoomData, roomList: this.state.activeRooms });
-    }
-    hasAutoAnswerHeaders(event) {
-        const regex = /answer-after=0/;
-        const request = event.request;
-        const callInfoHeader = request.getHeader('Call-Info');
-        return callInfoHeader && regex.test(callInfoHeader);
-    }
-    _addCall(value, emitEvent = true) {
-        this.state.activeCalls = Object.assign(Object.assign({}, this.state.activeCalls), { [value._id]: (0, audio_helper_1.simplifyCallObject)(value) });
-        /*this.state.extendedCalls = {
-            ...this.state.extendedCalls,
-            [value._id]: value
-        }*/
-        this.state.extendedCalls[value._id] = value;
-        if (emitEvent) {
-            this.emit('changeActiveCalls', this.state.activeCalls);
-        }
-    }
-    _addCallStatus(callId) {
-        this.state.callStatus = Object.assign(Object.assign({}, this.state.callStatus), { [callId]: {
-                isMoving: false,
-                isTransferring: false,
-                isMerging: false
-            } });
-        this.emit('changeCallStatus', this.state.callStatus);
-    }
-    _updateCallStatus(value) {
-        const prevStatus = Object.assign({}, this.state.callStatus[value.callId]);
-        const newStatus = Object.assign({}, prevStatus);
-        if (value.isMoving !== undefined) {
-            newStatus.isMoving = value.isMoving;
-        }
-        if (value.isTransferring !== undefined) {
-            newStatus.isTransferring = value.isTransferring;
-        }
-        if (value.isMerging !== undefined) {
-            newStatus.isMerging = value.isMerging;
-        }
-        this.state.callStatus = Object.assign(Object.assign({}, this.state.callStatus), { [value.callId]: Object.assign({}, newStatus) });
-        this.emit('changeCallStatus', this.state.callStatus);
-    }
-    _removeCallStatus(callId) {
-        const callStatusCopy = Object.assign({}, this.state.callStatus);
-        delete callStatusCopy[callId];
-        this.state.callStatus = Object.assign({}, callStatusCopy);
-        this.emit('changeCallStatus', this.state.callStatus);
-    }
-    _addRoom(value) {
-        this.state.activeRooms = Object.assign(Object.assign({}, this.state.activeRooms), { [value.roomId]: value });
-        this.emit('addRoom', { room: value, roomList: this.state.activeRooms });
-    }
-    setMicrophone(dId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.getInputDeviceList.find(({ deviceId }) => deviceId === dId)) {
-                return;
-            }
-            this.selectedInputDevice = dId;
-            let stream; // = null
-            try {
-                stream = yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-            }
-            catch (err) {
-                console.error(err);
-            }
-            if (Object.keys(this.getActiveCalls).length === 0) {
-                return;
-            }
-            const callsInCurrentRoom = Object.values(this.state.extendedCalls).filter(call => call.roomId === this.currentActiveRoomId);
-            if (callsInCurrentRoom.length === 1) {
-                Object.values(callsInCurrentRoom).forEach(call => {
-                    const processedStream = (0, audio_helper_1.processAudioVolume)(stream, this.microphoneInputLevel);
-                    processedStream.getTracks().forEach(track => track.enabled = !this.isMuted);
-                    this._setOriginalStream(processedStream);
-                    call.connection.getSenders()[0].replaceTrack(processedStream.getTracks()[0]);
-                    this.updateCall(call);
-                });
-            }
-            else {
-                yield this._doConference(callsInCurrentRoom);
-            }
-        });
-    }
-    _setOriginalStream(value) {
-        this.state.originalStream = value;
-        this.emit('changeOriginalStream', value);
-    }
-    setSpeaker(dId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.getOutputDeviceList.find(({ deviceId }) => deviceId === dId)) {
-                return;
-            }
-            this.selectedOutputDevice = dId;
-            const activeCallList = Object.values(this.state.extendedCalls);
-            if (activeCallList.length === 0) {
-                return;
-            }
-            const callsInCurrentRoom = activeCallList.filter(call => call.roomId === this.currentActiveRoomId);
-            if (callsInCurrentRoom.length === 1) {
-                activeCallList.forEach(call => {
-                    var _a;
-                    (_a = call.audioTag) === null || _a === void 0 ? void 0 : _a.setSinkId(dId);
-                    this.updateCall(call);
-                });
-            }
-            else {
-                yield this._doConference(callsInCurrentRoom);
-            }
-        });
-    }
-    removeRoom(roomId) {
-        const activeRoomsCopy = Object.assign({}, this.state.activeRooms);
-        const roomToRemove = Object.assign({}, activeRoomsCopy[roomId]);
-        delete activeRoomsCopy[roomId];
-        this.state.activeRooms = Object.assign({}, activeRoomsCopy);
-        this.emit('removeRoom', { room: roomToRemove, roomList: this.state.activeRooms });
-    }
-    deleteRoomIfEmpty(roomId) {
-        if (roomId === undefined) {
-            return;
-        }
-        if (Object.values(this.state.extendedCalls).filter(call => call.roomId === roomId).length === 0) {
-            this.removeRoom(roomId);
-            if (this.currentActiveRoomId === roomId) {
-                this.currentActiveRoomId = undefined;
-            }
-        }
-    }
-    checkInitialized() {
-        if (!this.initialized) {
-            throw new Error('[OpenSIPSJS] You must call `start` method first!');
-        }
-    }
-    muteReconfigure(call) {
-        if (this.state.isMuted) {
-            call.mute({ audio: true });
-        }
-        else {
-            call.unmute({ audio: true });
-        }
-    }
-    roomReconfigure(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (roomId === undefined) {
-                return;
-            }
-            const callsInRoom = Object.values(this.state.extendedCalls).filter(call => call.roomId === roomId);
-            // Let`s take care on the audio output first and check if passed room is our selected room
-            if (this.currentActiveRoomId === roomId) {
-                callsInRoom.forEach(call => {
-                    if (call.audioTag) {
-                        this.muteReconfigure(call);
-                        call.audioTag.muted = false;
-                        this.updateCall(call);
-                    }
-                });
-            }
-            else {
-                callsInRoom.forEach(call => {
-                    if (call.audioTag) {
-                        call.audioTag.muted = true;
-                        this.updateCall(call);
-                    }
-                });
-            }
-            // Now let`s configure the sound we are sending for each active call on this room
-            if (callsInRoom.length === 0) {
-                this.deleteRoomIfEmpty(roomId);
-            }
-            else if (callsInRoom.length === 1 && this.currentActiveRoomId !== roomId) {
-                if (!callsInRoom[0].isOnHold().local) {
-                    this.doCallHold({ callId: callsInRoom[0].id, toHold: true, automatic: true });
-                }
-            }
-            else if (callsInRoom.length === 1 && this.currentActiveRoomId === roomId) {
-                if (callsInRoom[0].isOnHold().local && callsInRoom[0]._automaticHold) {
-                    this.doCallHold({ callId: callsInRoom[0].id, toHold: false });
-                }
-                let stream;
-                try {
-                    stream = yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-                }
-                catch (err) {
-                    console.error(err);
-                }
-                if (stream && callsInRoom[0].connection && callsInRoom[0].connection.getSenders()[0]) {
-                    const processedStream = (0, audio_helper_1.processAudioVolume)(stream, this.microphoneInputLevel);
-                    processedStream.getTracks().forEach(track => track.enabled = !this.state.isMuted);
-                    this._setOriginalStream(processedStream);
-                    yield callsInRoom[0].connection.getSenders()[0].replaceTrack(processedStream.getTracks()[0]);
-                    this.muteReconfigure(callsInRoom[0]);
-                }
-            }
-            else if (callsInRoom.length > 1) {
-                yield this._doConference(callsInRoom);
-            }
-        });
-    }
-    _doConference(sessions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            sessions.forEach(call => {
-                if (call._localHold) {
-                    this.doCallHold({ callId: call._id, toHold: false });
-                }
-            });
-            // Take all received tracks from the sessions you want to merge
-            const receivedTracks = [];
-            sessions.forEach(session => {
-                if (session !== null && session !== undefined) {
-                    session.connection.getReceivers().forEach((receiver) => {
-                        receivedTracks.push(receiver.track);
-                    });
-                }
-            });
-            // Use the Web Audio API to mix the received tracks
-            const audioContext = new AudioContext();
-            const allReceivedMediaStreams = new MediaStream();
-            // For each call we will build dedicated mix for all other calls
-            yield (0, p_iteration_1.forEach)(sessions, (session) => __awaiter(this, void 0, void 0, function* () {
-                if (session === null || session === undefined) {
-                    return;
-                }
-                const mixedOutput = audioContext.createMediaStreamDestination();
-                session.connection.getReceivers().forEach((receiver) => {
-                    receivedTracks.forEach(track => {
-                        allReceivedMediaStreams.addTrack(receiver.track);
-                        if (receiver.track.id !== track.id) {
-                            const sourceStream = audioContext.createMediaStreamSource(new MediaStream([track]));
-                            sourceStream.connect(mixedOutput);
-                        }
-                    });
-                });
-                if (sessions[0].roomId === this.currentActiveRoomId) {
-                    // Mixing your voice with all the received audio
-                    const stream = yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-                    const processedStream = (0, audio_helper_1.processAudioVolume)(stream, this.microphoneInputLevel);
-                    processedStream.getTracks().forEach(track => track.enabled = !this.isMuted);
-                    this._setOriginalStream(processedStream);
-                    const sourceStream = audioContext.createMediaStreamSource(processedStream);
-                    // stream.getTracks().forEach(track => track.enabled = !getters.isMuted) // TODO: Fix this
-                    sourceStream.connect(mixedOutput);
-                }
-                if (session.connection.getSenders()[0]) {
-                    //mixedOutput.stream.getTracks().forEach(track => track.enabled = !getters.isMuted) // Uncomment to mute all callers on mute
-                    yield session.connection.getSenders()[0].replaceTrack(mixedOutput.stream.getTracks()[0]);
-                    this._muteReconfigure(session);
-                }
-            }));
-        });
-    }
-    _muteReconfigure(call) {
-        if (this.isMuted) {
-            call.mute({ audio: true });
-        }
-        else {
-            call.unmute({ audio: true });
-        }
-    }
-    muteCaller(callId, value) {
-        const call = this.state.extendedCalls[callId];
-        if (call && call.connection.getReceivers().length) {
-            call.localMuted = value;
-            call.connection.getReceivers().forEach((receiver) => {
-                receiver.track.enabled = !value;
-            });
-            this.updateCall(call);
-            this.roomReconfigure(call.roomId);
-        }
-    }
-    callTerminate(callId) {
-        const call = this.state.extendedCalls[callId];
-        if (call._status !== 8) {
-            call.terminate();
-        }
-    }
-    callTransfer(callId, target) {
-        if (target.toString().length === 0) {
-            return console.error('Target must be passed');
-        }
-        const call = this.state.extendedCalls[callId];
-        if (!call._is_confirmed && !call._is_canceled) {
-            const redirectTarget = `sip:${target}@${this.sipDomain}`;
-            call.terminate({
-                status_code: 302,
-                reason_phrase: 'Moved Temporarily',
-                extraHeaders: [`Contact: ${redirectTarget}`]
-            });
-            return;
-        }
-        this._updateCallStatus({ callId, isTransferring: true });
-        call.refer(`sip:${target}@${this.sipDomain}`);
-        this.updateCall(call);
-    }
-    callMerge(roomId) {
-        const callsInRoom = Object.values(this.state.extendedCalls).filter((call) => call.roomId === roomId);
-        if (callsInRoom.length !== 2)
-            return;
-        const firstCall = callsInRoom[0];
-        const secondCall = callsInRoom[1];
-        if (!firstCall || !secondCall) {
-            return;
-        }
-        // TODO: Check all call.id for working in the same way as call._id
-        this._updateCallStatus({ callId: firstCall._id, isMerging: true });
-        this._updateCallStatus({ callId: secondCall._id, isMerging: true });
-        firstCall.refer(secondCall.remote_identity.uri.toString(), { 'replaces': secondCall });
-        this.updateCall(firstCall);
-    }
-    // TODO: Use this method in demo
-    setDND(value) {
-        this.isDND = value;
-    }
-    _startCallTimer(callId) {
-        const timeData = {
-            callId,
-            hours: 0,
-            minutes: 0,
-            seconds: 0,
-            formatted: ''
-        };
-        this.setCallTime(timeData);
-        const interval = setInterval(() => {
-            const callTime = Object.assign({}, this.state.callTime[callId]);
-            const updatedTime = (0, time_helper_1.setupTime)(callTime);
-            this.setCallTime(Object.assign({ callId }, updatedTime));
-        }, 1000);
-        this.setTimeInterval(callId, interval);
-    }
-    setCurrentActiveRoomId(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const oldRoomId = this.currentActiveRoomId;
-            if (roomId === oldRoomId) {
-                return;
-            }
-            this.currentActiveRoomId = roomId;
-            yield this.roomReconfigure(oldRoomId);
-            yield this.roomReconfigure(roomId);
-        });
-    }
-    getNewRoomId() {
-        const roomIdList = Object.keys(this.state.activeRooms);
-        if (roomIdList.length === 0) {
-            return 1;
-        }
-        return (parseInt(roomIdList.sort()[roomIdList.length - 1]) + 1);
-    }
-    subscribe(type, listener) {
-        const isListenerEmpty = !this.state.listeners[type] || !this.state.listeners[type].length;
-        const newListeners = isListenerEmpty ? [listener] : [...this.state.listeners[type], listener];
-        this.state.listeners = Object.assign(Object.assign({}, this.state.listeners), { [type]: newListeners });
-    }
-    removeIListener(value) {
-        const listenersCopy = Object.assign({}, this.state.listeners);
-        delete listenersCopy[value];
-        this.state.listeners = Object.assign({}, listenersCopy);
-    }
-    addCall(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = event.session;
-            const sessionAlreadyInActiveCalls = this.getActiveCalls[session.id];
-            if (sessionAlreadyInActiveCalls !== undefined) {
-                return;
-            }
-            const roomId = this.getNewRoomId();
-            const newRoomInfo = {
-                started: new Date(),
-                incomingInProgress: false,
-                roomId
-            };
-            if (session.direction === 'incoming') {
-                newRoomInfo.incomingInProgress = true;
-                this.subscribe(call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_CONFIRMED, (call) => {
-                    if (session.id === call.id) {
-                        this.updateRoom({
-                            incomingInProgress: false,
-                            roomId
-                        });
-                        this._startCallTimer(session.id);
-                    }
-                });
-                this.subscribe(call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_FAILED, (call) => {
-                    if (session.id === call.id) {
-                        this.updateRoom({
-                            incomingInProgress: false,
-                            roomId
-                        });
-                        this.deleteRoomIfEmpty(roomId);
-                    }
-                });
-            }
-            else if (session.direction === 'outgoing') {
-                this._startCallTimer(session.id);
-            }
-            const call = session;
-            const autoAnswerByHeaders = this.hasAutoAnswerHeaders(event);
-            const doAutoAnswer = call.direction === 'incoming' && !this.hasActiveCalls && (autoAnswerByHeaders || this.autoAnswer);
-            call.roomId = roomId;
-            call.localMuted = false;
-            call.autoAnswer = doAutoAnswer;
-            if (doAutoAnswer) {
-                this._addCall(call, false);
-            }
-            else {
-                this._addCall(call);
-            }
-            // this._addCall(call)
-            this._addCallStatus(session.id);
-            this._addRoom(newRoomInfo);
-            if (doAutoAnswer) {
-                this.callAnswer(call._id);
-            }
-        });
-    }
-    _triggerListener({ listenerType, session, event }) {
-        const listeners = this.state.listeners[listenerType];
-        if (!listeners || !listeners.length) {
-            return;
-        }
-        listeners.forEach((listener) => {
-            listener(session, event);
-        });
-    }
-    _removeCall(value) {
-        const stateActiveCallsCopy = Object.assign({}, this.state.activeCalls);
-        delete stateActiveCallsCopy[value];
-        // delete activeCalls[value]
-        this.state.activeCalls = Object.assign({}, stateActiveCallsCopy);
-        const stateExtendedCallsCopy = Object.assign({}, this.state.extendedCalls);
-        delete stateExtendedCallsCopy[value];
-        this.state.extendedCalls = Object.assign({}, stateExtendedCallsCopy);
-        this.emit('changeActiveCalls', this.state.activeCalls);
-    }
-    _activeCallListRemove(call) {
-        const callRoomIdToConfigure = this.state.extendedCalls[call._id].roomId;
-        this._removeCall(call._id);
-        this.roomReconfigure(callRoomIdToConfigure);
-    }
-    newRTCSessionCallback(event) {
-        const session = event.session;
-        if (this.isDND) {
-            session.terminate({ status_code: 486, reason_phrase: 'Do Not Disturb' });
-            return;
-        }
-        // stop timers on ended and failed
-        session.on('ended', (event) => {
-            this._triggerListener({ listenerType: call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_ENDED, session, event });
-            const s = this.getActiveCalls[session.id];
-            if (s) {
-                this._activeCallListRemove(s);
-            }
-            this._stopCallTimer(session.id);
-            this._removeCallStatus(session.id);
-            this._removeCallMetrics(session.id);
-            if (!Object.keys(this.state.extendedCalls).length) {
-                this.isMuted = false;
-            }
-        });
-        session.on('progress', (event) => {
-            this._triggerListener({ listenerType: call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_PROGRESS, session, event });
-        });
-        session.on('failed', (event) => {
-            this._triggerListener({ listenerType: call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_FAILED, session, event });
-            if (session.id === this.callAddingInProgress) {
-                this.callAddingInProgress = undefined;
-            }
-            const s = this.getActiveCalls[session.id];
-            if (s) {
-                this._activeCallListRemove(s);
-            }
-            this._stopCallTimer(session.id);
-            this._removeCallStatus(session.id);
-            this._removeCallMetrics(session.id);
-            if (!Object.keys(this.state.extendedCalls).length) {
-                this.isMuted = false;
-            }
-        });
-        session.on('confirmed', (event) => {
-            this._triggerListener({ listenerType: call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_CONFIRMED, session, event });
-            this.updateCall(session);
-            if (session.id === this.callAddingInProgress) {
-                this.callAddingInProgress = undefined;
-            }
-        });
-        this.addCall(event);
-        if (session.direction === 'outgoing') {
-            const roomId = this.getActiveCalls[session.id].roomId;
-            this.setCurrentActiveRoomId(roomId);
-        }
-    }
-    setInitialized(value) {
-        this.initialized = value;
-        this.emit('ready', value);
-    }
-    start() {
-        this.on(this.registeredEventName, () => {
-            this.setInitialized(true);
-        });
-        this.on(this.unregisteredEventName, () => {
-            this.setInitialized(false);
-        });
-        this.on(this.newRTCSessionEventName, this.newRTCSessionCallback.bind(this));
-        super.start();
-        this.setMediaDevices(true);
-        return this;
-    }
-    setMuteWhenJoin(value) {
-        this.muteWhenJoin = value;
-    }
-    _setCallMetrics(value) {
-        const metrics = Object.assign({}, value);
-        delete metrics['callId'];
-        this.state.callMetrics = Object.assign(Object.assign({}, this.state.callMetrics), { [value.callId]: metrics });
-    }
-    _removeCallMetrics(callId) {
-        const callMetricsCopy = Object.assign({}, this.state.callMetrics);
-        delete callMetricsCopy[callId];
-        this.state.callMetrics = Object.assign({}, callMetricsCopy);
-    }
-    _getCallQuality(call) {
-        const metrics = new metrics_1.default(this.state.metricConfig);
-        const probe = metrics.createProbe(call.connection, {
-            cid: call._id
-        });
-        const inboundKeys = [];
-        let inboundAudio;
-        probe.onreport = (probe) => {
-            //console.log('probe', probe)
-            /*const inboundMetrics = Object.entries(probe.audio).filter(([ key, value ]) => {
-                return value.direction === 'inbound'
-            })*/
-            //const ioo = Object.entries(probe.audio).
-            Object.entries(probe.audio).forEach(([key, value]) => {
-                if (value.direction === 'inbound' && !inboundKeys.includes(key)) {
-                    inboundKeys.push(key);
-                    inboundAudio = key;
-                }
-            });
-            /*inboundMetrics.forEach(([ key, value ]) => {
-                if (!inboundKeys.includes(key)) {
-                    inboundKeys.push(key)
-                    inboundAudio = key
-                }
-            })*/
-            const inboundAudioMetric = probe.audio[inboundAudio];
-            const metric = (0, filter_helper_1.filterObjectKeys)(inboundAudioMetric, metric_keys_to_include_1.METRIC_KEYS_TO_INCLUDE);
-            metric.callId = call._id;
-            this._setCallMetrics(metrics);
-        };
-        this.subscribe(call_event_listener_type_1.CALL_EVENT_LISTENER_TYPE.CALL_ENDED, (session) => {
-            if (session._id === call._id) {
-                metrics.stopAllProbes();
-            }
-        });
-        metrics.startAllProbes();
-    }
-    _triggerAddStream(event, call) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.isMuted = this.muteWhenJoin;
-            const stream = yield navigator.mediaDevices.getUserMedia(this.getUserMediaConstraints);
-            const processedStream = (0, audio_helper_1.processAudioVolume)(stream, this.microphoneInputLevel);
-            const muteMicro = this.isMuted || this.muteWhenJoin;
-            processedStream.getTracks().forEach(track => track.enabled = !muteMicro);
-            this._setOriginalStream(processedStream);
-            yield call.connection.getSenders()[0].replaceTrack(processedStream.getTracks()[0]);
-            (0, audio_helper_1.syncStream)(event, call, this.selectedOutputDevice, this.speakerVolume);
-            this._getCallQuality(call);
-            this.updateCall(call);
-        });
-    }
-    doCall({ target, addToCurrentRoom }) {
-        this.checkInitialized();
-        if (target.length === 0) {
-            return console.error('Target must be a valid string');
-        }
-        const call = this.call(`sip:${target}@${this.sipDomain}`, this.sipOptions);
-        this.callAddingInProgress = call.id;
-        if (addToCurrentRoom && this.currentActiveRoomId !== undefined) {
-            this.callChangeRoom({
-                callId: call.id,
-                roomId: this.currentActiveRoomId
-            });
-        }
-        call.connection.addEventListener('addstream', (event) => {
-            this._triggerAddStream(event, call);
-        });
-    }
-    callChangeRoom({ callId, roomId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const oldRoomId = this.state.extendedCalls[callId].roomId;
-            this.state.extendedCalls[callId].roomId = roomId;
-            yield this.setCurrentActiveRoomId(roomId);
-            return Promise.all([
-                this.roomReconfigure(oldRoomId),
-                this.roomReconfigure(roomId)
-            ]).then(() => {
-                this.deleteRoomIfEmpty(oldRoomId);
-                this.deleteRoomIfEmpty(roomId);
-            });
-        });
-    }
-}
-exports.default = OpenSIPSJS;