sip-connector 6.18.0 → 6.19.0

package/dist/SipConnector.js

@@ -1,1099 +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 });
-exports.hasCanceledCallError = exports.EUseLicense = exports.EEventsSyncMediaState = exports.EEventsMic = exports.EEventsMainCAM = void 0;
-const cancelable_promise_1 = require("@krivega/cancelable-promise");
-const events_constructor_1 = __importDefault(require("events-constructor"));
-const causes_1 = require("./causes");
-const constants_1 = require("./constants");
-const eventNames_1 = require("./eventNames");
-const getExtraHeadersRemoteAddress_1 = __importDefault(require("./getExtraHeadersRemoteAddress"));
-const headers_1 = require("./headers");
-const utils_1 = require("./utils");
-const errors_1 = require("./utils/errors");
-const scaleBitrate_1 = __importDefault(require("./videoSendingBalancer/scaleBitrate"));
-const BUSY_HERE_STATUS_CODE = 486;
-const REQUEST_TERMINATED_STATUS_CODE = 487;
-const ORIGINATOR_LOCAL = 'local';
-const ORIGINATOR_REMOTE = 'remote';
-var EEventsMainCAM;
-(function (EEventsMainCAM) {
-    EEventsMainCAM["PAUSE_MAIN_CAM"] = "PAUSEMAINCAM";
-    EEventsMainCAM["RESUME_MAIN_CAM"] = "RESUMEMAINCAM";
-    EEventsMainCAM["MAX_MAIN_CAM_RESOLUTION"] = "MAXMAINCAMRESOLUTION";
-    EEventsMainCAM["ADMIN_STOP_MAIN_CAM"] = "ADMINSTOPMAINCAM";
-    EEventsMainCAM["ADMIN_START_MAIN_CAM"] = "ADMINSTARTMAINCAM";
-})(EEventsMainCAM || (exports.EEventsMainCAM = EEventsMainCAM = {}));
-var EEventsMic;
-(function (EEventsMic) {
-    EEventsMic["ADMIN_STOP_MIC"] = "ADMINSTOPMIC";
-    EEventsMic["ADMIN_START_MIC"] = "ADMINSTARTMIC";
-})(EEventsMic || (exports.EEventsMic = EEventsMic = {}));
-var EEventsSyncMediaState;
-(function (EEventsSyncMediaState) {
-    EEventsSyncMediaState["ADMIN_SYNC_FORCED"] = "1";
-    EEventsSyncMediaState["ADMIN_SYNC_NOT_FORCED"] = "0";
-})(EEventsSyncMediaState || (exports.EEventsSyncMediaState = EEventsSyncMediaState = {}));
-var EUseLicense;
-(function (EUseLicense) {
-    EUseLicense["AUDIO"] = "AUDIO";
-    EUseLicense["VIDEO"] = "VIDEO";
-    EUseLicense["AUDIOPLUSPRESENTATION"] = "AUDIOPLUSPRESENTATION";
-})(EUseLicense || (exports.EUseLicense = EUseLicense = {}));
-const hasCanceledCallError = (error = new Error()) => {
-    const { originator, cause } = error;
-    if ((0, cancelable_promise_1.isCanceledError)(error)) {
-        return true;
-    }
-    if (typeof cause === 'string') {
-        return (cause === causes_1.REQUEST_TIMEOUT ||
-            cause === causes_1.REJECTED ||
-            (originator === ORIGINATOR_LOCAL && (cause === causes_1.CANCELED || cause === causes_1.BYE)));
-    }
-    return false;
-};
-exports.hasCanceledCallError = hasCanceledCallError;
-const moduleName = 'SipConnector';
-const CMD_CHANNELS = 'channels';
-const CMD_WEBCAST_STARTED = 'WebcastStarted';
-const CMD_WEBCAST_STOPPED = 'WebcastStopped';
-const CMD_ACCOUNT_CHANGED = 'accountChanged';
-const CMD_ACCOUNT_DELETED = 'accountDeleted';
-const CMD_ADDED_TO_LIST_MODERATORS = 'addedToListModerators';
-const CMD_REMOVED_FROM_LIST_MODERATORS = 'removedFromListModerators';
-const CMD_MOVE_REQUEST_TO_CONFERENCE = 'WebcastParticipationAccepted';
-const CMD_CANCELLING_WORD_REQUEST = 'WebcastParticipationRejected';
-const CMD_MOVE_REQUEST_TO_STREAM = 'ParticipantMovedToWebcast';
-const CMD_CONFERENCE_PARTICIPANT_TOKEN_ISSUED = 'ConferenceParticipantTokenIssued';
-class SipConnector {
-    constructor({ JsSIP }) {
-        this._isRegisterConfig = false;
-        this._connectionConfiguration = {};
-        this._remoteStreams = {};
-        this.getSipServerUrl = (id) => {
-            return id;
-        };
-        this.connect = (data) => {
-            this._cancelRequests();
-            return this._cancelableConnect.request(data);
-        };
-        this.createUa = (data) => {
-            return this._cancelableCreateUa.request(data);
-        };
-        this.set = (data) => {
-            return this._cancelableSet.request(data);
-        };
-        this.call = (data) => {
-            return this._cancelableCall.request(data);
-        };
-        this.disconnect = () => {
-            this._cancelRequests();
-            return this._disconnectWithoutCancelRequests();
-        };
-        this.answerToIncomingCall = (data) => {
-            return this._cancelableAnswer.request(data);
-        };
-        this.sendDTMF = (tone) => {
-            return this._cancelableSendDTMF.request(tone);
-        };
-        this.hangUp = () => {
-            this._cancelRequests();
-            return this._hangUpWithoutCancelRequests();
-        };
-        this.tryRegister = () => {
-            if (!this.isRegisterConfig) {
-                return Promise.reject(new Error('Config is not registered'));
-            }
-            this._uaEvents.trigger(constants_1.CONNECTING, undefined);
-            return this.unregister()
-                .finally(() => {
-                return this.register();
-            })
-                .finally(() => {
-                return undefined;
-            });
-        };
-        this.declineToIncomingCall = ({ statusCode = REQUEST_TERMINATED_STATUS_CODE } = {}) => {
-            return new Promise((resolve, reject) => {
-                if (!this.isAvailableIncomingCall) {
-                    reject(new Error('no incomingSession'));
-                    return undefined;
-                }
-                const incomingSession = this.incomingSession;
-                const callerData = this.remoteCallerData;
-                this._cancelableCall.cancelRequest();
-                this._cancelableAnswer.cancelRequest();
-                this.removeIncomingSession();
-                this._uaEvents.trigger(constants_1.DECLINED_INCOMING_CALL, callerData);
-                resolve(incomingSession.terminate({ status_code: statusCode }));
-                return undefined;
-            });
-        };
-        this.busyIncomingCall = () => {
-            return this.declineToIncomingCall({ statusCode: BUSY_HERE_STATUS_CODE });
-        };
-        this.removeIncomingSession = () => {
-            delete this.incomingSession;
-        };
-        this.handleNewRTCSession = ({ originator, session }) => {
-            if (originator === ORIGINATOR_REMOTE) {
-                this.incomingSession = session;
-                const callerData = this.remoteCallerData;
-                session.on(constants_1.FAILED, ({ originator }) => {
-                    this.removeIncomingSession();
-                    if (originator !== ORIGINATOR_LOCAL) {
-                        this._uaEvents.trigger(constants_1.FAILED_INCOMING_CALL, callerData);
-                    }
-                    else {
-                        this._uaEvents.trigger(constants_1.TERMINATED_INCOMING_CALL, callerData);
-                    }
-                });
-                this._uaEvents.trigger(constants_1.INCOMING_CALL, callerData);
-            }
-        };
-        this._connect = (params) => {
-            return this.createUa(params).then(() => {
-                return this._start();
-            });
-        };
-        this._createUa = ({ displayName = '', user, password, register = false, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders = [], sdpSemantics = 'plan-b', sessionTimers = false, registerExpires = 60 * 5, // 5 minutes in sec
-        connectionRecoveryMinInterval = 2, connectionRecoveryMaxInterval = 6, userAgent, }) => __awaiter(this, void 0, void 0, function* () {
-            if (!sipServerUrl) {
-                throw new Error('sipServerUrl is required');
-            }
-            if (!sipWebSocketServerURL) {
-                throw new Error('sipWebSocketServerURL is required');
-            }
-            if (register && !user) {
-                throw new Error('user is required for authorized connection');
-            }
-            if (register && !password) {
-                throw new Error('password is required for authorized connection');
-            }
-            this._connectionConfiguration = {
-                sipServerUrl,
-                displayName,
-                register,
-                user,
-                password,
-            };
-            this._init({ sipServerUrl, sipWebSocketServerURL });
-            let authorizationUser;
-            if (register && user) {
-                authorizationUser = user.trim();
-            }
-            else {
-                authorizationUser = (0, utils_1.generateUserId)();
-            }
-            const configuration = {
-                password,
-                register,
-                display_name: (0, utils_1.parseDisplayName)(displayName),
-                user_agent: userAgent,
-                sdp_semantics: sdpSemantics,
-                sockets: [this.socket],
-                uri: this.getSipServerUrl(authorizationUser),
-                session_timers: sessionTimers,
-                register_expires: registerExpires,
-                connection_recovery_min_interval: connectionRecoveryMinInterval,
-                connection_recovery_max_interval: connectionRecoveryMaxInterval,
-            };
-            if (this.ua) {
-                yield this._disconnectWithoutCancelRequests();
-            }
-            this._isRegisterConfig = !!configuration.register;
-            this.ua = new this.JsSIP.UA(configuration);
-            this._uaEvents.eachTriggers((trigger, eventName) => {
-                const uaJsSipEvent = eventNames_1.UA_JSSIP_EVENT_NAMES.find((jsSipEvent) => {
-                    return jsSipEvent === eventName;
-                });
-                if (uaJsSipEvent) {
-                    this.ua.on(uaJsSipEvent, trigger);
-                }
-            });
-            const extraHeadersRemoteAddress = (0, getExtraHeadersRemoteAddress_1.default)(remoteAddress);
-            const extraHeadersBase = [...extraHeadersRemoteAddress, ...extraHeaders];
-            this.ua.registrator().setExtraHeaders(extraHeadersBase);
-            return this.ua;
-        });
-        this._start = () => {
-            return new Promise((resolve, reject) => {
-                const resolveUa = () => {
-                    removeEventListeners();
-                    resolve(this.ua);
-                };
-                const rejectError = (error) => {
-                    removeEventListeners();
-                    reject(error);
-                };
-                const addEventListeners = () => {
-                    if (this.isRegisterConfig) {
-                        this.on(constants_1.REGISTERED, resolveUa);
-                        this.on(constants_1.REGISTRATION_FAILED, rejectError);
-                    }
-                    else {
-                        this.on(constants_1.CONNECTED, resolveUa);
-                    }
-                    this.on(constants_1.DISCONNECTED, rejectError);
-                };
-                const removeEventListeners = () => {
-                    this.off(constants_1.REGISTERED, resolveUa);
-                    this.off(constants_1.REGISTRATION_FAILED, rejectError);
-                    this.off(constants_1.CONNECTED, resolveUa);
-                    this.off(constants_1.DISCONNECTED, rejectError);
-                };
-                addEventListeners();
-                this.on(constants_1.NEW_RTC_SESSION, this.handleNewRTCSession);
-                this.ua.start();
-            });
-        };
-        this._set = ({ displayName, password }) => {
-            return new Promise((resolve, reject) => {
-                let changedDisplayName = false;
-                let changedPassword = false;
-                if (displayName !== undefined && displayName !== this._connectionConfiguration.displayName) {
-                    changedDisplayName = this.ua.set('display_name', (0, utils_1.parseDisplayName)(displayName));
-                    this._connectionConfiguration.displayName = displayName;
-                }
-                if (password !== undefined && password !== this._connectionConfiguration.password) {
-                    changedPassword = this.ua.set('password', password);
-                    this._connectionConfiguration.password = password;
-                }
-                const changedSome = changedDisplayName || changedPassword;
-                if (changedPassword && this.isRegisterConfig) {
-                    this.register()
-                        .then(() => {
-                        return resolve(changedSome);
-                    })
-                        .catch(reject);
-                }
-                else if (changedSome) {
-                    resolve(changedSome);
-                }
-                else {
-                    reject(changedSome);
-                }
-            });
-        };
-        this._disconnectWithoutCancelRequests = () => {
-            return this._cancelableDisconnect.request();
-        };
-        this._disconnect = () => __awaiter(this, void 0, void 0, function* () {
-            this.off(constants_1.NEW_RTC_SESSION, this.handleNewRTCSession);
-            const disconnectedPromise = new Promise((resolve) => {
-                this.once(constants_1.DISCONNECTED, () => {
-                    delete this.ua;
-                    resolve();
-                });
-            });
-            if (this.ua) {
-                yield this._hangUpWithoutCancelRequests();
-                if (this.ua) {
-                    this.ua.stop();
-                }
-                else {
-                    this._uaEvents.trigger(constants_1.DISCONNECTED, undefined);
-                }
-            }
-            else {
-                this._uaEvents.trigger(constants_1.DISCONNECTED, undefined);
-            }
-            return disconnectedPromise;
-        });
-        this._call = ({ number, mediaStream, extraHeaders = [], ontrack, iceServers, videoMode, audioMode, degradationPreference, offerToReceiveAudio = true, offerToReceiveVideo = true, }) => {
-            return new Promise((resolve, reject) => {
-                this._connectionConfiguration.number = number;
-                this._connectionConfiguration.answer = false;
-                this._handleCall({ ontrack }).then(resolve).catch(reject);
-                this.session = this.ua.call(this.getSipServerUrl(number), {
-                    extraHeaders,
-                    mediaStream: (0, utils_1.prepareMediaStream)(mediaStream, {
-                        videoMode,
-                        audioMode,
-                    }),
-                    eventHandlers: this._sessionEvents.triggers,
-                    videoMode,
-                    audioMode,
-                    degradationPreference,
-                    pcConfig: {
-                        iceServers,
-                    },
-                    rtcOfferConstraints: {
-                        offerToReceiveAudio,
-                        offerToReceiveVideo,
-                    },
-                });
-            });
-        };
-        this._answer = ({ mediaStream, ontrack, extraHeaders = [], iceServers, videoMode, audioMode, degradationPreference, }) => {
-            return new Promise((resolve, reject) => {
-                if (!this.isAvailableIncomingCall) {
-                    reject(new Error('no incomingSession'));
-                    return undefined;
-                }
-                this.session = this.incomingSession;
-                this.removeIncomingSession();
-                const session = this.session;
-                if (!session) {
-                    reject(new Error('No session established'));
-                    return;
-                }
-                this._sessionEvents.eachTriggers((trigger, eventName) => {
-                    const sessionJsSipEvent = eventNames_1.SESSION_JSSIP_EVENT_NAMES.find((jsSipEvent) => {
-                        return jsSipEvent === eventName;
-                    });
-                    if (sessionJsSipEvent) {
-                        session.on(sessionJsSipEvent, trigger);
-                    }
-                });
-                this._connectionConfiguration.answer = true;
-                this._connectionConfiguration.number = session.remote_identity.uri.user;
-                this._handleCall({ ontrack }).then(resolve).catch(reject);
-                const preparedMediaStream = (0, utils_1.prepareMediaStream)(mediaStream, {
-                    videoMode,
-                    audioMode,
-                });
-                session.answer({
-                    extraHeaders,
-                    videoMode,
-                    audioMode,
-                    degradationPreference,
-                    mediaStream: preparedMediaStream,
-                    pcConfig: {
-                        iceServers,
-                    },
-                });
-                return undefined;
-            });
-        };
-        this._handleCall = ({ ontrack }) => {
-            return new Promise((resolve, reject) => {
-                const addStartedEventListeners = () => {
-                    this.onSession(constants_1.PEER_CONNECTION, handlePeerConnection);
-                    this.onSession(constants_1.CONFIRMED, handleConfirmed);
-                };
-                const removeStartedEventListeners = () => {
-                    this.offSession(constants_1.PEER_CONNECTION, handlePeerConnection);
-                    this.offSession(constants_1.CONFIRMED, handleConfirmed);
-                };
-                const addEndedEventListeners = () => {
-                    this.onSession(constants_1.FAILED, handleEnded);
-                    this.onSession(constants_1.ENDED, handleEnded);
-                };
-                const removeEndedEventListeners = () => {
-                    this.offSession(constants_1.FAILED, handleEnded);
-                    this.offSession(constants_1.ENDED, handleEnded);
-                };
-                const handleEnded = (error) => {
-                    removeStartedEventListeners();
-                    removeEndedEventListeners();
-                    reject(error);
-                };
-                let savedPeerconnection;
-                const handlePeerConnection = ({ peerconnection }) => {
-                    savedPeerconnection = peerconnection;
-                    savedPeerconnection.ontrack = (track) => {
-                        this._sessionEvents.trigger(constants_1.PEER_CONNECTION_ONTRACK, savedPeerconnection);
-                        if (ontrack) {
-                            ontrack(track);
-                        }
-                    };
-                };
-                const handleConfirmed = () => {
-                    if (savedPeerconnection) {
-                        this._sessionEvents.trigger(constants_1.PEER_CONNECTION_CONFIRMED, savedPeerconnection);
-                    }
-                    removeStartedEventListeners();
-                    removeEndedEventListeners();
-                    resolve(savedPeerconnection);
-                };
-                addStartedEventListeners();
-                addEndedEventListeners();
-            });
-        };
-        this._restoreSession = () => {
-            this._resetPresentation();
-            delete this._connectionConfiguration.number;
-            delete this.session;
-            this._remoteStreams = {};
-        };
-        this._sendDTMF = (tone) => {
-            return new Promise((resolve, reject) => {
-                const session = this.session;
-                if (!session) {
-                    reject(new Error('No session established'));
-                    return;
-                }
-                this.onceSession(constants_1.NEW_DTMF, ({ originator }) => {
-                    if (originator === ORIGINATOR_LOCAL) {
-                        resolve();
-                    }
-                });
-                session.sendDTMF(tone, {
-                    duration: 120,
-                    interToneGap: 600,
-                });
-            });
-        };
-        this._hangUpWithoutCancelRequests = () => __awaiter(this, void 0, void 0, function* () {
-            if (this.ua && this.session) {
-                const { session } = this;
-                if (this._streamPresentationCurrent) {
-                    yield this.stopPresentation();
-                }
-                this._restoreSession();
-                if (!session.isEnded()) {
-                    session.terminate();
-                }
-            }
-        });
-        this._handleShareState = (eventName) => {
-            switch (eventName) {
-                case headers_1.AVAILABLE_SECOND_REMOTE_STREAM:
-                    this._sessionEvents.trigger(constants_1.AVAILABLE_SECOND_REMOTE_STREAM_EVENT, undefined);
-                    break;
-                case headers_1.NOT_AVAILABLE_SECOND_REMOTE_STREAM:
-                    this._sessionEvents.trigger(constants_1.NOT_AVAILABLE_SECOND_REMOTE_STREAM_EVENT, undefined);
-                    break;
-                case headers_1.MUST_STOP_PRESENTATION:
-                    this._sessionEvents.trigger(constants_1.MUST_STOP_PRESENTATION_EVENT, undefined);
-                    break;
-                default:
-                    break;
-            }
-        };
-        this._maybeTriggerChannels = (request) => {
-            const inputChannels = request.getHeader(headers_1.HEADER_INPUT_CHANNELS);
-            const outputChannels = request.getHeader(headers_1.HEADER_OUTPUT_CHANNELS);
-            if (inputChannels && outputChannels) {
-                const headersChannels = {
-                    inputChannels,
-                    outputChannels,
-                };
-                this._sessionEvents.trigger(constants_1.CHANNELS, headersChannels);
-            }
-        };
-        this._handleNotify = (header) => {
-            if (header.cmd === CMD_CHANNELS) {
-                const channelsInfo = header;
-                this._triggerChannelsNotify(channelsInfo);
-            }
-            else if (header.cmd === CMD_WEBCAST_STARTED) {
-                const webcastInfo = header;
-                this._triggerWebcastStartedNotify(webcastInfo);
-            }
-            else if (header.cmd === CMD_WEBCAST_STOPPED) {
-                const webcastInfo = header;
-                this._triggerWebcastStoppedNotify(webcastInfo);
-            }
-            else if (header.cmd === CMD_ADDED_TO_LIST_MODERATORS) {
-                const data = header;
-                this._triggerAddedToListModeratorsNotify(data);
-            }
-            else if (header.cmd === CMD_REMOVED_FROM_LIST_MODERATORS) {
-                const data = header;
-                this._triggerRemovedFromListModeratorsNotify(data);
-            }
-            else if (header.cmd === CMD_MOVE_REQUEST_TO_CONFERENCE) {
-                const data = header;
-                this._triggerParticipantMoveRequestToConference(data);
-            }
-            else if (header.cmd === CMD_CANCELLING_WORD_REQUEST) {
-                const data = header;
-                this._triggerParticipantCancelingWordRequest(data);
-            }
-            else if (header.cmd === CMD_MOVE_REQUEST_TO_STREAM) {
-                const data = header;
-                this._triggerParticipantMoveRequestToStream(data);
-            }
-            else if (header.cmd === CMD_ACCOUNT_CHANGED) {
-                this._triggerAccountChangedNotify();
-            }
-            else if (header.cmd === CMD_ACCOUNT_DELETED) {
-                this._triggerAccountDeletedNotify();
-            }
-            else if (header.cmd === CMD_CONFERENCE_PARTICIPANT_TOKEN_ISSUED) {
-                const data = header;
-                this._triggerConferenceParticipantTokenIssued(data);
-            }
-        };
-        this._triggerRemovedFromListModeratorsNotify = ({ conference, }) => {
-            const headersParametersModeratorsList = {
-                conference,
-            };
-            this._uaEvents.trigger(constants_1.PARTICIPANT_REMOVED_FROM_LIST_MODERATORS, headersParametersModeratorsList);
-        };
-        this._triggerAddedToListModeratorsNotify = ({ conference }) => {
-            const headersParametersModeratorsList = {
-                conference,
-            };
-            this._uaEvents.trigger(constants_1.PARTICIPANT_ADDED_TO_LIST_MODERATORS, headersParametersModeratorsList);
-        };
-        this._triggerWebcastStartedNotify = ({ body: { conference, type } }) => {
-            const headersParametersWebcast = {
-                conference,
-                type,
-            };
-            this._uaEvents.trigger(constants_1.WEBCAST_STARTED, headersParametersWebcast);
-        };
-        this._triggerWebcastStoppedNotify = ({ body: { conference, type } }) => {
-            const headersParametersWebcast = {
-                conference,
-                type,
-            };
-            this._uaEvents.trigger(constants_1.WEBCAST_STOPPED, headersParametersWebcast);
-        };
-        this._triggerAccountChangedNotify = () => {
-            this._uaEvents.trigger(constants_1.ACCOUNT_CHANGED, undefined);
-        };
-        this._triggerAccountDeletedNotify = () => {
-            this._uaEvents.trigger(constants_1.ACCOUNT_DELETED, undefined);
-        };
-        this._triggerConferenceParticipantTokenIssued = ({ body: { conference, participant, jwt }, }) => {
-            const headersConferenceParticipantTokenIssued = {
-                conference,
-                participant,
-                jwt,
-            };
-            this._uaEvents.trigger(constants_1.CONFERENCE_PARTICIPANT_TOKEN_ISSUED, headersConferenceParticipantTokenIssued);
-        };
-        this._triggerChannelsNotify = (channelsInfo) => {
-            const inputChannels = channelsInfo.input;
-            const outputChannels = channelsInfo.output;
-            const data = {
-                inputChannels,
-                outputChannels,
-            };
-            this._uaEvents.trigger(constants_1.CHANNELS_NOTIFY, data);
-        };
-        this._triggerParticipantMoveRequestToConference = ({ body: { conference }, }) => {
-            const data = {
-                conference,
-            };
-            this._uaEvents.trigger(constants_1.PARTICIPANT_MOVE_REQUEST_TO_CONFERENCE, data);
-        };
-        this._triggerParticipantCancelingWordRequest = ({ body: { conference }, }) => {
-            const data = {
-                conference,
-            };
-            this._uaEvents.trigger(constants_1.PARTICIPANT_CANCELLING_WORD_REQUEST, data);
-        };
-        this._triggerParticipantMoveRequestToStream = ({ body: { conference }, }) => {
-            const data = {
-                conference,
-            };
-            this._uaEvents.trigger(constants_1.PARTICIPANT_MOVE_REQUEST_TO_STREAM, data);
-        };
-        this._triggerEnterRoom = (request) => {
-            const room = request.getHeader(headers_1.HEADER_CONTENT_ENTER_ROOM);
-            this._sessionEvents.trigger(constants_1.ENTER_ROOM, room);
-        };
-        this._triggerShareState = (request) => {
-            const eventName = request.getHeader(headers_1.HEADER_CONTENT_SHARE_STATE);
-            this._sessionEvents.trigger(constants_1.SHARE_STATE, eventName);
-        };
-        this._triggerMainCamControl = (request) => {
-            const mainCam = request.getHeader(headers_1.HEADER_MAIN_CAM);
-            const syncState = request.getHeader(headers_1.HEADER_MEDIA_SYNC);
-            const isSyncForced = syncState === EEventsSyncMediaState.ADMIN_SYNC_FORCED ? true : false;
-            if (mainCam === EEventsMainCAM.ADMIN_START_MAIN_CAM) {
-                this._sessionEvents.trigger(constants_1.ADMIN_START_MAIN_CAM, { isSyncForced });
-            }
-            else if (mainCam === EEventsMainCAM.ADMIN_STOP_MAIN_CAM) {
-                this._sessionEvents.trigger(constants_1.ADMIN_STOP_MAIN_CAM, { isSyncForced });
-            }
-            else if ((mainCam === EEventsMainCAM.RESUME_MAIN_CAM || mainCam === EEventsMainCAM.PAUSE_MAIN_CAM) &&
-                !!syncState) {
-                this._sessionEvents.trigger(constants_1.ADMIN_FORCE_SYNC_MEDIA_STATE, { isSyncForced });
-            }
-            else {
-                const resolutionMainCam = request.getHeader(headers_1.HEADER_MAIN_CAM_RESOLUTION);
-                this._sessionEvents.trigger(constants_1.MAIN_CAM_CONTROL, {
-                    mainCam,
-                    resolutionMainCam,
-                });
-            }
-        };
-        this._triggerMicControl = (request) => {
-            const mic = request.getHeader(headers_1.HEADER_MIC);
-            const syncState = request.getHeader(headers_1.HEADER_MEDIA_SYNC);
-            const isSyncForced = syncState === EEventsSyncMediaState.ADMIN_SYNC_FORCED ? true : false;
-            if (mic === EEventsMic.ADMIN_START_MIC) {
-                this._sessionEvents.trigger(constants_1.ADMIN_START_MIC, { isSyncForced });
-            }
-            else if (mic === EEventsMic.ADMIN_STOP_MIC) {
-                this._sessionEvents.trigger(constants_1.ADMIN_STOP_MIC, { isSyncForced });
-            }
-        };
-        this._triggerUseLicense = (request) => {
-            const license = request.getHeader(headers_1.HEADER_CONTENT_USE_LICENSE);
-            this._sessionEvents.trigger(constants_1.USE_LICENSE, license);
-        };
-        this._handleNewInfo = (info) => {
-            const { originator } = info;
-            if (originator !== 'remote') {
-                return;
-            }
-            const request = info.request;
-            const contentType = request.getHeader(headers_1.HEADER_CONTENT_TYPE_NAME);
-            if (contentType) {
-                switch (contentType) {
-                    case headers_1.CONTENT_TYPE_ENTER_ROOM:
-                        this._triggerEnterRoom(request);
-                        this._maybeTriggerChannels(request);
-                        break;
-                    case headers_1.CONTENT_TYPE_NOTIFY:
-                        this._maybeHandleNotify(request);
-                        break;
-                    case headers_1.CONTENT_TYPE_SHARE_STATE:
-                        this._triggerShareState(request);
-                        break;
-                    case headers_1.CONTENT_TYPE_MAIN_CAM:
-                        this._triggerMainCamControl(request);
-                        break;
-                    case headers_1.CONTENT_TYPE_MIC:
-                        this._triggerMicControl(request);
-                        break;
-                    case headers_1.CONTENT_TYPE_USE_LICENSE:
-                        this._triggerUseLicense(request);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        };
-        this._handleSipEvent = ({ request }) => {
-            this._maybeHandleNotify(request);
-        };
-        this._maybeHandleNotify = (request) => {
-            const headerNotify = request.getHeader(headers_1.HEADER_NOTIFY);
-            if (headerNotify) {
-                const headerNotifyParsed = JSON.parse(headerNotify);
-                this._handleNotify(headerNotifyParsed);
-            }
-        };
-        this._handleEnded = (error) => {
-            const { originator } = error;
-            if (originator === ORIGINATOR_REMOTE) {
-                this._sessionEvents.trigger(constants_1.ENDED_FROM_SERVER, error);
-            }
-            this._restoreSession();
-        };
-        this.JsSIP = JsSIP;
-        this._sessionEvents = new events_constructor_1.default(eventNames_1.SESSION_EVENT_NAMES);
-        this._uaEvents = new events_constructor_1.default(eventNames_1.UA_EVENT_NAMES);
-        this._cancelableConnect = new cancelable_promise_1.CancelableRequest(this._connect, {
-            moduleName,
-            afterCancelRequest: () => {
-                this._cancelableCreateUa.cancelRequest();
-                this._cancelableDisconnect.cancelRequest();
-            },
-        });
-        this._cancelableCreateUa = new cancelable_promise_1.CancelableRequest(this._createUa, { moduleName });
-        this._cancelableDisconnect = new cancelable_promise_1.CancelableRequest(this._disconnect, { moduleName });
-        this._cancelableSet = new cancelable_promise_1.CancelableRequest(this._set, {
-            moduleName,
-        });
-        this._cancelableCall = new cancelable_promise_1.CancelableRequest(this._call, { moduleName });
-        this._cancelableAnswer = new cancelable_promise_1.CancelableRequest(this._answer, { moduleName });
-        this._cancelableSendDTMF = new cancelable_promise_1.CancelableRequest(this._sendDTMF, { moduleName });
-        this.onSession(constants_1.SHARE_STATE, this._handleShareState);
-        this.onSession(constants_1.NEW_INFO, this._handleNewInfo);
-        this.on(constants_1.SIP_EVENT, this._handleSipEvent);
-        this.onSession(constants_1.FAILED, this._handleEnded);
-        this.onSession(constants_1.ENDED, this._handleEnded);
-    }
-    register() {
-        return new Promise((resolve, reject) => {
-            if (this.isRegisterConfig) {
-                this.ua.on(constants_1.REGISTERED, resolve);
-                this.ua.on(constants_1.REGISTRATION_FAILED, reject);
-                this.ua.register();
-            }
-            else {
-                reject(new Error('Config is not registered'));
-            }
-        });
-    }
-    unregister() {
-        return new Promise((resolve, reject) => {
-            if (this.isRegistered) {
-                this.ua.on(constants_1.UNREGISTERED, resolve);
-                this.ua.unregister();
-            }
-            else {
-                reject(new Error('ua is not registered'));
-            }
-        });
-    }
-    sendOptions(target, body, extraHeaders) {
-        if (!this.ua) {
-            return Promise.reject(new Error('is not connected'));
-        }
-        return new Promise((resolve, reject) => {
-            try {
-                this.ua.sendOptions(target, body, {
-                    extraHeaders,
-                    eventHandlers: {
-                        succeeded: () => {
-                            resolve();
-                        },
-                        failed: (error) => {
-                            reject(error);
-                        },
-                    },
-                });
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    ping(body, extraHeaders) {
-        if (!this.ua || !this.ua.configuration || !this.ua.configuration.uri) {
-            return Promise.reject(new Error('is not connected'));
-        }
-        const target = this.ua.configuration.uri;
-        return this.sendOptions(target, body, extraHeaders);
-    }
-    replaceMediaStream(mediaStream, options) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        return this.session.replaceMediaStream(mediaStream, options);
-    }
-    askPermissionToEnableCam(options = { noTerminateWhenError: true }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        const extraHeaders = [headers_1.HEADER_ENABLE_MAIN_CAM];
-        return this.session
-            .sendInfo(headers_1.CONTENT_TYPE_MAIN_CAM, undefined, Object.assign(Object.assign({}, options), { extraHeaders }))
-            .catch((error) => {
-            if ((0, errors_1.hasDeclineResponseFromServer)(error)) {
-                throw error;
-            }
-            return;
-        });
-    }
-    get isPendingPresentation() {
-        return !!this.promisePendingStartPresentation || !!this.promisePendingStopPresentation;
-    }
-    _sendPresentation(session, stream, { maxBitrate, degradationPreference, isNeedReinvite = true, isP2P = false, }) {
-        const streamPresentationCurrent = (0, utils_1.prepareMediaStream)(stream);
-        this._streamPresentationCurrent = streamPresentationCurrent;
-        const preparatoryHeaders = isP2P
-            ? [headers_1.HEADER_START_PRESENTATION_P2P]
-            : [headers_1.HEADER_START_PRESENTATION];
-        const result = session
-            .sendInfo(headers_1.CONTENT_TYPE_SHARE_STATE, undefined, {
-            extraHeaders: preparatoryHeaders,
-        })
-            .then(() => {
-            return session.startPresentation(streamPresentationCurrent, isNeedReinvite, degradationPreference);
-        })
-            // @ts-ignore
-            .then(() => {
-            const { connection } = this;
-            if (!connection || maxBitrate === undefined) {
-                return undefined;
-            }
-            const senders = connection.getSenders();
-            return (0, scaleBitrate_1.default)(senders, stream, maxBitrate);
-        })
-            .then(() => {
-            return stream;
-        })
-            .catch((error) => {
-            this._sessionEvents.trigger(constants_1.PRESENTATION_FAILED, error);
-            throw error;
-        });
-        this.promisePendingStartPresentation = result;
-        return result.finally(() => {
-            this.promisePendingStartPresentation = undefined;
-        });
-    }
-    startPresentation(stream, { isNeedReinvite = true, isP2P = false, maxBitrate, degradationPreference, } = {}) {
-        const session = this.establishedSession;
-        if (!session) {
-            return Promise.reject(new Error('No session established'));
-        }
-        if (this._streamPresentationCurrent) {
-            return Promise.reject(new Error('Presentation is already started'));
-        }
-        return this._sendPresentation(session, stream, {
-            isNeedReinvite,
-            isP2P,
-            maxBitrate,
-            degradationPreference,
-        });
-    }
-    stopPresentation({ isP2P = false, } = {}) {
-        const streamPresentationPrev = this._streamPresentationCurrent;
-        let result = this.promisePendingStartPresentation || Promise.resolve();
-        const preparatoryHeaders = isP2P ? [headers_1.HEADER_STOP_PRESENTATION_P2P] : [headers_1.HEADER_STOP_PRESENTATION];
-        const session = this.establishedSession;
-        if (session && streamPresentationPrev) {
-            result = result
-                .then(() => {
-                return session.sendInfo(headers_1.CONTENT_TYPE_SHARE_STATE, undefined, {
-                    extraHeaders: preparatoryHeaders,
-                });
-            })
-                .then(() => {
-                return session.stopPresentation(streamPresentationPrev);
-            })
-                .catch((error) => {
-                this._sessionEvents.trigger(constants_1.PRESENTATION_FAILED, error);
-                throw error;
-            });
-        }
-        if (!session && streamPresentationPrev) {
-            this._sessionEvents.trigger(constants_1.PRESENTATION_ENDED, streamPresentationPrev);
-        }
-        this.promisePendingStopPresentation = result;
-        return result.finally(() => {
-            this._resetPresentation();
-        });
-    }
-    updatePresentation(stream, { isP2P = false, maxBitrate, degradationPreference, } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.establishedSession;
-            if (!session) {
-                return Promise.reject(new Error('No session established'));
-            }
-            if (!this._streamPresentationCurrent) {
-                return Promise.reject(new Error('Presentation has not started yet'));
-            }
-            if (this.promisePendingStartPresentation) {
-                yield this.promisePendingStartPresentation;
-            }
-            return this._sendPresentation(session, stream, {
-                isP2P,
-                maxBitrate,
-                degradationPreference,
-                isNeedReinvite: false,
-            });
-        });
-    }
-    _resetPresentation() {
-        delete this._streamPresentationCurrent;
-        this.promisePendingStartPresentation = undefined;
-        this.promisePendingStopPresentation = undefined;
-    }
-    on(eventName, handler) {
-        return this._uaEvents.on(eventName, handler);
-    }
-    once(eventName, handler) {
-        return this._uaEvents.once(eventName, handler);
-    }
-    onceRace(eventNames, handler) {
-        return this._uaEvents.onceRace(eventNames, handler);
-    }
-    wait(eventName) {
-        return this._uaEvents.wait(eventName);
-    }
-    off(eventName, handler) {
-        this._uaEvents.off(eventName, handler);
-    }
-    onSession(eventName, handler) {
-        return this._sessionEvents.on(eventName, handler);
-    }
-    onceSession(eventName, handler) {
-        return this._sessionEvents.once(eventName, handler);
-    }
-    onceRaceSession(eventNames, handler) {
-        return this._sessionEvents.onceRace(eventNames, handler);
-    }
-    waitSession(eventName) {
-        return this._sessionEvents.wait(eventName);
-    }
-    offSession(eventName, handler) {
-        this._sessionEvents.off(eventName, handler);
-    }
-    isConfigured() {
-        return !!this.ua;
-    }
-    getConnectionConfiguration() {
-        return Object.assign({}, this._connectionConfiguration);
-    }
-    getRemoteStreams() {
-        if (!this.connection) {
-            return undefined;
-        }
-        const receivers = this.connection.getReceivers();
-        const remoteTracks = receivers.map(({ track }) => {
-            return track;
-        });
-        if ((0, utils_1.hasVideoTracks)(remoteTracks)) {
-            return this._generateStreams(remoteTracks);
-        }
-        return this._generateAudioStreams(remoteTracks);
-    }
-    get connection() {
-        var _a;
-        const connection = (_a = this === null || this === void 0 ? void 0 : this.session) === null || _a === void 0 ? void 0 : _a.connection;
-        return connection;
-    }
-    get remoteCallerData() {
-        var _a, _b, _c, _d, _e, _f;
-        return {
-            // eslint-disable-next-line camelcase
-            displayName: (_b = (_a = this === null || this === void 0 ? void 0 : this.incomingSession) === null || _a === void 0 ? void 0 : _a.remote_identity) === null || _b === void 0 ? void 0 : _b.display_name,
-            // eslint-disable-next-line camelcase
-            host: (_d = (_c = this === null || this === void 0 ? void 0 : this.incomingSession) === null || _c === void 0 ? void 0 : _c.remote_identity) === null || _d === void 0 ? void 0 : _d.uri.host,
-            // eslint-disable-next-line camelcase
-            incomingNumber: (_f = (_e = this === null || this === void 0 ? void 0 : this.incomingSession) === null || _e === void 0 ? void 0 : _e.remote_identity) === null || _f === void 0 ? void 0 : _f.uri.user,
-            session: this === null || this === void 0 ? void 0 : this.incomingSession,
-        };
-    }
-    get requested() {
-        return (this._cancelableConnect.requested ||
-            this._cancelableCreateUa.requested ||
-            this._cancelableCall.requested ||
-            this._cancelableAnswer.requested);
-    }
-    get establishedSession() {
-        return this.session && this.session.isEstablished() ? this.session : undefined;
-    }
-    get isRegistered() {
-        return !!this.ua && this.ua.isRegistered();
-    }
-    get isRegisterConfig() {
-        return !!this.ua && this._isRegisterConfig;
-    }
-    get isCallActive() {
-        return !!(this.ua && this.session);
-    }
-    get isAvailableIncomingCall() {
-        return !!this.incomingSession;
-    }
-    _init({ sipServerUrl, sipWebSocketServerURL }) {
-        this.getSipServerUrl = (0, utils_1.resolveSipUrl)(sipServerUrl);
-        this.socket = new this.JsSIP.WebSocketInterface(sipWebSocketServerURL);
-    }
-    _generateStream(videoTrack, audioTrack) {
-        const id = videoTrack.id;
-        const remoteStream = this._remoteStreams[id] || new MediaStream();
-        if (audioTrack) {
-            remoteStream.addTrack(audioTrack);
-        }
-        remoteStream.addTrack(videoTrack);
-        this._remoteStreams[id] = remoteStream;
-        return remoteStream;
-    }
-    _generateAudioStream(audioTrack) {
-        const id = audioTrack.id;
-        const remoteStream = this._remoteStreams[id] || new MediaStream();
-        remoteStream.addTrack(audioTrack);
-        this._remoteStreams[id] = remoteStream;
-        return remoteStream;
-    }
-    _generateStreams(remoteTracks) {
-        const remoteStreams = [];
-        remoteTracks.forEach((track, index) => {
-            if (track.kind === 'audio') {
-                return;
-            }
-            const videoTrack = track;
-            const prevTrack = remoteTracks[index - 1];
-            let audioTrack;
-            if (prevTrack && prevTrack.kind === 'audio') {
-                audioTrack = prevTrack;
-            }
-            const remoteStream = this._generateStream(videoTrack, audioTrack);
-            remoteStreams.push(remoteStream);
-        }, []);
-        return remoteStreams;
-    }
-    _generateAudioStreams(remoteTracks) {
-        const remoteStreams = remoteTracks.map((remoteTrack) => {
-            return this._generateAudioStream(remoteTrack);
-        });
-        return remoteStreams;
-    }
-    _cancelRequests() {
-        this._cancelActionsRequests();
-        this._cancelCallRequests();
-        this._cancelConnectRequests();
-    }
-    _cancelConnectRequests() {
-        this._cancelableConnect.cancelRequest();
-    }
-    _cancelCallRequests() {
-        this._cancelableCall.cancelRequest();
-        this._cancelableAnswer.cancelRequest();
-    }
-    _cancelActionsRequests() {
-        this._cancelableAnswer.cancelRequest();
-        this._cancelableSendDTMF.cancelRequest();
-    }
-    waitChannels() {
-        return this.waitSession(constants_1.CHANNELS);
-    }
-    waitSyncMediaState() {
-        return this.waitSession(constants_1.ADMIN_FORCE_SYNC_MEDIA_STATE);
-    }
-    sendChannels({ inputChannels, outputChannels }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        const headerInputChannels = `${headers_1.HEADER_INPUT_CHANNELS}: ${inputChannels}`;
-        const headerOutputChannels = `${headers_1.HEADER_OUTPUT_CHANNELS}: ${outputChannels}`;
-        const extraHeaders = [
-            headerInputChannels,
-            headerOutputChannels,
-        ];
-        return this.session.sendInfo(headers_1.CONTENT_TYPE_CHANNELS, undefined, { extraHeaders });
-    }
-    sendMediaState({ cam, mic }, options = { noTerminateWhenError: true }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        const headerMediaState = `${headers_1.HEADER_MEDIA_STATE}: currentstate`;
-        const headerCam = `${headers_1.HEADER_MAIN_CAM_STATE}: ${+cam}`;
-        const headerMic = `${headers_1.HEADER_MIC_STATE}: ${+mic}`;
-        const extraHeaders = [
-            headerMediaState,
-            headerCam,
-            headerMic,
-        ];
-        return this.session.sendInfo(headers_1.CONTENT_TYPE_MEDIA_STATE, undefined, Object.assign(Object.assign({}, options), { extraHeaders }));
-    }
-    _sendRefusalToTurnOn(type, options = { noTerminateWhenError: true }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        const typeMicOnServer = 0;
-        const typeCamOnServer = 1;
-        const typeToSend = type == 'mic' ? typeMicOnServer : typeCamOnServer;
-        const headerMediaType = `${headers_1.HEADER_MEDIA_TYPE}: ${typeToSend}`;
-        const extraHeaders = [headerMediaType];
-        return this.session.sendInfo(headers_1.CONTENT_TYPE_REFUSAL, undefined, Object.assign(Object.assign({}, options), { extraHeaders }));
-    }
-    sendRefusalToTurnOnMic(options = { noTerminateWhenError: true }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        return this._sendRefusalToTurnOn('mic', options);
-    }
-    sendRefusalToTurnOnCam(options = { noTerminateWhenError: true }) {
-        if (!this.session) {
-            throw new Error('No session established');
-        }
-        return this._sendRefusalToTurnOn('cam', options);
-    }
-}
-exports.default = SipConnector;
-//# sourceMappingURL=SipConnector.js.map