@wazo/sdk 0.43.5 → 1.0.0-alpha.0

package/lib/voice/softphone.js

@@ -0,0 +1,375 @@
+"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.Softphone = exports.MESSAGE_TYPE_SIGNAL = exports.MESSAGE_TYPE_CHAT = exports.EVENT_ON_SIGNAL = exports.EVENT_ON_CHAT = exports.EVENT_ON_MESSAGE = exports.EVENT_VIDEO_INPUT_CHANGE = exports.EVENT_DISCONNECTED = exports.EVENT_UNREGISTERED = exports.EVENT_REGISTERED = exports.EVENT_HEARTBEAT_TIMEOUT = exports.EVENT_HEARTBEAT = exports.EVENT_INCOMING = void 0;
+/* eslint-disable no-underscore-dangle */
+const events_1 = require("events");
+const xstate_1 = require("xstate");
+const InvalidState_1 = __importDefault(require("../domain/InvalidState"));
+const __1 = __importDefault(require(".."));
+const softphone_state_machine_1 = __importStar(require("../state-machine/softphone-state-machine"));
+const call_state_machine_1 = require("../state-machine/call-state-machine");
+const web_rtc_client_1 = __importDefault(require("../web-rtc-client"));
+const IssueReporter_1 = __importDefault(require("../service/IssueReporter"));
+const sip_logger_1 = __importDefault(require("../utils/sip-logger"));
+const call_1 = __importDefault(require("./call"));
+const utils_1 = require("../state-machine/utils");
+exports.EVENT_INCOMING = 'incoming';
+exports.EVENT_HEARTBEAT = 'heartbeat';
+exports.EVENT_HEARTBEAT_TIMEOUT = 'heartbeatTimeout';
+exports.EVENT_REGISTERED = 'registered';
+exports.EVENT_UNREGISTERED = 'unregistered';
+exports.EVENT_DISCONNECTED = 'disconnected';
+exports.EVENT_VIDEO_INPUT_CHANGE = 'videoInputChange';
+exports.EVENT_ON_MESSAGE = 'message';
+exports.EVENT_ON_CHAT = 'phone/ON_CHAT';
+exports.EVENT_ON_SIGNAL = 'phone/ON_SIGNAL';
+exports.MESSAGE_TYPE_CHAT = 'message/TYPE_CHAT';
+exports.MESSAGE_TYPE_SIGNAL = 'message/TYPE_SIGNAL';
+const logger = IssueReporter_1.default.loggerFor('softphone');
+class Softphone extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.calls = [];
+        this.softphoneActor = (0, xstate_1.createActor)(softphone_state_machine_1.default);
+        this.softphoneActor.start();
+    }
+    connect(options = {}) {
+        this.calls = [];
+        this.options = options;
+        this.audioOutputVolume = 1;
+        this.audioRingVolume = 1;
+        const server = __1.default.Auth.getHost();
+        const session = __1.default.Auth.getSession();
+        if (!server || !session) {
+            throw new Error('Please connect to the server using `Wazo.Auth.logIn` or `Wazo.Auth.authenticate` before using Room.connect().');
+        }
+        this.session = session;
+        this.sipLine = this.getPrimaryWebRtcLine();
+        if (!this.sipLine) {
+            throw new Error('Sorry, no sip lines found for this user');
+        }
+        this.options.userUuid = session.uuid || '';
+        return this.connectWithCredentials(server, this.sipLine, session.displayName(), options);
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.assertCan)(this.softphoneActor, softphone_state_machine_1.Actions.UNREGISTER);
+            if (!this.client) {
+                return null;
+            }
+            // Terminate all calls
+            yield Promise.all(this.calls.map(call => call.hangup()));
+            return this.client.unregister();
+        });
+    }
+    getPrimaryWebRtcLine() {
+        var _a;
+        return ((_a = this.session) === null || _a === void 0 ? void 0 : _a.primaryWebRtcLine()) || null;
+    }
+    connectWithCredentials(server_1, sipLine_1, displayName_1) {
+        return __awaiter(this, arguments, void 0, function* (server, sipLine, displayName, rawOptions = {}) {
+            (0, utils_1.assertCan)(this.softphoneActor, softphone_state_machine_1.Actions.REGISTER);
+            this.softphoneActor.send({ type: softphone_state_machine_1.Actions.REGISTER });
+            const [host, port = 443] = server.split(':');
+            let options = Object.assign({}, rawOptions);
+            options.media = options.media || {
+                audio: true,
+                video: false,
+            };
+            options.uaConfigOverrides = options.uaConfigOverrides || {};
+            if (IssueReporter_1.default.enabled) {
+                options = (0, sip_logger_1.default)(options);
+            }
+            this.client = new web_rtc_client_1.default(Object.assign({ host, port: typeof port === 'string' ? parseInt(port, 10) : port, displayName, authorizationUser: sipLine.username, password: sipLine.secret, uri: `${sipLine.username}@${server}` }, options), undefined, options.uaConfigOverrides);
+            this._bindEvents();
+            return this.client.register().catch(error => {
+                // Avoid exception on `t.server.scheme` in sip transport when losing the webrtc socket connection
+                logger.error('softphone - register error', { message: error.message, stack: error.stack });
+                this._sendAction(softphone_state_machine_1.Actions.UNREGISTER);
+            });
+        });
+    }
+    reconnect() {
+        logger.info('softphone - reconnect', { client: !!this.client });
+        if (!this.client) {
+            return;
+        }
+        this.client.attemptReconnection();
+    }
+    call(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.info('softphone - call', options);
+            if (!options.params.To) {
+                logger.warn('softphone -  calling with empty number, bailing.');
+                return Promise.resolve(null);
+            }
+            if (this.getState() !== softphone_state_machine_1.States.UNREGISTERED) {
+                throw new InvalidState_1.default(`Invalid state ${softphone_state_machine_1.States.UNREGISTERED}`, softphone_state_machine_1.States.UNREGISTERED);
+            }
+            if (this.getState() !== softphone_state_machine_1.States.REGISTERING) {
+                logger.info('softphone - calling when registering, waiting for Softphone to be registered ...');
+                yield (0, utils_1.waitUntilState)(this.softphoneActor, softphone_state_machine_1.States.REGISTERED);
+            }
+            // Hold other calls
+            this.holdAllCalls();
+            let sipCall;
+            try {
+                sipCall = this.client.call(options.params.To, options.withCamera, options.audioOnly, options.conference, options);
+                const call = new call_1.default(sipCall, this);
+                return call;
+            }
+            catch (error) {
+                logger.warn('softphone - call, error', { message: error.message, stack: error.stack });
+                return Promise.resolve(null);
+            }
+        });
+    }
+    removeCall(callToRemove) {
+        this.calls = this.calls.filter((call) => call.id !== callToRemove.id);
+    }
+    holdAllCalls(exceptCall = null) {
+        this.calls.filter(call => !call.isHeld() && call.id === (exceptCall === null || exceptCall === void 0 ? void 0 : exceptCall.id)).forEach(call => call.hold());
+    }
+    startHeartbeat() {
+        logger.info('softphone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client.hasHeartbeat() });
+        if (!this.client || this.client.hasHeartbeat()) {
+            return;
+        }
+        this.client.startHeartbeat();
+    }
+    stopHeartbeat() {
+        logger.info('softphone - stop heartbeat', { client: !!this.client });
+        if (!this.client) {
+            return;
+        }
+        this.client.stopHeartbeat();
+    }
+    setMediaConstraints(media) {
+        this.client.setMediaConstraints(media);
+    }
+    changeAudioOutputDevice(id) {
+        logger.info('softphone - change audio device', { deviceId: id });
+        this.audioOutputDeviceId = id;
+        return this.client.changeAudioOutputDevice(id);
+    }
+    changeAudioInputDevice(id, force) {
+        logger.info('softphone - changeAudio input device', { deviceId: id });
+        const currentCall = this.getCurrentCall();
+        return this.client.changeAudioInputDevice(id, currentCall === null || currentCall === void 0 ? void 0 : currentCall.sipCall, force);
+    }
+    changeVideoInputDevice(id) {
+        logger.info('softphone - change video input device', { deviceId: id });
+        const currentCall = this.getCurrentCall();
+        return this.client.changeVideoInputDevice(id, currentCall === null || currentCall === void 0 ? void 0 : currentCall.sipCall);
+    }
+    changeRingDevice(id) {
+        logger.info('softphone - changing ring device', { id });
+        this.audioRingDeviceId = id;
+    }
+    hasSfu() {
+        var _a;
+        return ((_a = this.sipLine) === null || _a === void 0 ? void 0 : _a.hasVideoConference()) || false;
+    }
+    // volume is a value between 0 and 1
+    changeAudioVolume(volume) {
+        logger.info('softphone - changing audio volume', { volume });
+        this.audioOutputVolume = volume;
+        this.client.changeAudioOutputVolume(volume);
+    }
+    // volume is a value between 0 and 1
+    changeRingVolume(volume) {
+        logger.info('softphone - changing ring volume', { volume });
+        this.audioRingVolume = volume;
+    }
+    getCalls() {
+        return this.calls;
+    }
+    getCurrentCall() {
+        return this.calls.find(call => call.isEstablished());
+    }
+    getState() {
+        return this.softphoneActor.getSnapshot().value;
+    }
+    getUserAgent() {
+        var _a, _b;
+        return ((_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.userAgentString) || 'softphone';
+    }
+    _bindEvents() {
+        this.client.on(this.client.INVITE, (sipSession) => {
+            const call = new call_1.default(sipSession, this);
+            call._sendAction(call_state_machine_1.Actions.INCOMING_CALL);
+            this.calls.push(call);
+            this.eventEmitter.emit(exports.EVENT_INCOMING, call);
+        });
+        this.client.on(this.client.ON_REINVITE, (sipCall, request, updatedCalleeName, updatedNumber, hadRemoteVideo) => {
+            logger.info('softphone - on reinvite', {
+                callId: sipCall.id,
+                inviteId: request.callId,
+                updatedCalleeName,
+                updatedNumber,
+                hadRemoteVideo,
+            });
+            this._onCallEvent(sipCall, 'onReinvite', request, updatedCalleeName, updatedNumber, hadRemoteVideo);
+        });
+        this.client.on(this.client.ACCEPTED, (sipCall) => __awaiter(this, void 0, void 0, function* () {
+            this._onCallEvent(sipCall, 'onAccepted');
+            if (this.audioOutputDeviceId) {
+                yield this.client.changeAudioOutputDevice(this.audioOutputDeviceId);
+            }
+        }));
+        this.client.on(this.client.ON_ERROR, (e, sipCall) => {
+            this._onCallEvent(sipCall, 'onError', e);
+        });
+        this.client.on(this.client.REJECTED, (sipCall) => {
+            this._onCallEvent(sipCall, 'onRejected');
+        });
+        this.client.on(this.client.ON_PROGRESS, (sipCall) => {
+            this._onCallEvent(sipCall, 'onProgress');
+        });
+        this.client.on(this.client.ON_EARLY_MEDIA, (sipCall) => {
+            this._onCallEvent(sipCall, 'onEarlyMedia');
+        });
+        this.client.on(this.client.ON_TRACK, (sipCall, event) => {
+            this._onCallEvent(sipCall, 'onTrack', event);
+        });
+        this.client.on(this.client.ON_NETWORK_STATS, (sipCall, stats, previousStats) => {
+            this._onCallEvent(sipCall, 'onNetworkStats', stats, previousStats);
+        });
+        // Used when upgrading directly in screenshare mode
+        this.client.on(this.client.ON_SCREEN_SHARING_REINVITE, (sipCall, response, desktop) => {
+            this._onCallEvent(sipCall, 'onScreenshareReinvite', response, desktop);
+        });
+        this.client.on(this.client.UNREGISTERED, () => {
+            logger.info('softphone - unregistered');
+            this.eventEmitter.emit(exports.EVENT_UNREGISTERED);
+            this._sendAction(softphone_state_machine_1.Actions.UNREGISTERED);
+        });
+        this.client.on(this.client.ON_DISCONNECTED, () => {
+            logger.info('softphone - disconnected');
+            this.eventEmitter.emit(exports.EVENT_DISCONNECTED);
+            this._sendAction(softphone_state_machine_1.Actions.TRANSPORT_CLOSED);
+        });
+        this.client.on(this.client.REGISTERED, () => {
+            logger.info('softphone - registered', { state: (0, utils_1.getState)(this.softphoneActor) });
+            if (!(0, utils_1.can)(this.softphoneActor, softphone_state_machine_1.Actions.REGISTER_DONE)) {
+                logger.warn('softphone - registered but not in REGISTERING state', { state: (0, utils_1.getState)(this.softphoneActor) });
+                return;
+            }
+            this.stopHeartbeat();
+            this._sendAction(softphone_state_machine_1.Actions.REGISTER_DONE);
+            this.eventEmitter.emit(exports.EVENT_REGISTERED);
+            // If the phone registered with a current callSession (eg: when switching network):
+            // send a reinvite to renegociate ICE with new IP
+            if (this.shouldSendReinvite) {
+                this.shouldSendReinvite = false;
+                // Send reinvite for all active calls
+                this.calls.filter(call => call.isEstablished())
+                    .forEach(call => { call.sendReinvite({ conference: call.isConference(), iceRestart: true }); });
+            }
+        });
+        this.client.on(this.client.CONNECTED, () => {
+            logger.info('softphone - connected');
+            this.stopHeartbeat();
+        });
+        this.client.on(this.client.DISCONNECTED, () => {
+            logger.info('softphone - disconnected');
+            this.eventEmitter.emit(exports.EVENT_DISCONNECTED);
+            // Do not trigger heartbeat if already running
+            if (!this.client.hasHeartbeat()) {
+                this.startHeartbeat();
+            }
+            // Tell to send reinvite when reconnecting
+            this.shouldSendReinvite = this.calls.length > 0;
+        });
+        this.client.on('onVideoInputChange', stream => {
+            this.eventEmitter.emit(exports.EVENT_VIDEO_INPUT_CHANGE, stream);
+        });
+        this.client.on(this.client.MESSAGE, (message) => {
+            this._onMessage(message);
+            this.eventEmitter.emit(exports.EVENT_ON_MESSAGE, message);
+        });
+        this.client.setOnHeartbeatTimeout(() => {
+            this.eventEmitter.emit(exports.EVENT_HEARTBEAT_TIMEOUT);
+        });
+        this.client.setOnHeartbeatCallback(() => {
+            this.eventEmitter.emit(exports.EVENT_HEARTBEAT);
+        });
+    }
+    _sendAction(action) {
+        this.softphoneActor.send({ type: action });
+    }
+    _getCall(sipCall) {
+        return this.calls.find(call => call.id === sipCall.id);
+    }
+    _onCallEvent(sipCall, eventName, ...args) {
+        logger.warn('softphone - received call event', { eventName, sipId: sipCall.id });
+        const call = this._getCall(sipCall);
+        if (!call) {
+            logger.warn('softphone - no call found to send the event', { eventName, sipId: sipCall.id });
+            return;
+        }
+        // @ts-ignore
+        call[eventName](...args);
+    }
+    _onMessage(message) {
+        if (!message || message.method !== 'MESSAGE') {
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(message.body || '');
+        }
+        catch (e) {
+            return;
+        }
+        const { type, content, } = body;
+        switch (type) {
+            case exports.MESSAGE_TYPE_CHAT:
+                this.eventEmitter.emit(exports.EVENT_ON_CHAT, content);
+                break;
+            case exports.MESSAGE_TYPE_SIGNAL:
+                {
+                    this.eventEmitter.emit(exports.EVENT_ON_SIGNAL, content);
+                    break;
+                }
+            default:
+        }
+    }
+}
+exports.Softphone = Softphone;
+exports.default = new Softphone();