@telegenta/webclient 2.0.11 → 3.0.0

package/dist/telegenta.js

@@ -0,0 +1,3627 @@
+import EventEmitter from 'events';
+import JsSIP from 'jssip';
+
+/*eslint no-console: ["error", { allow: ["debug", "info", "warn", "error", "log"] }] */
+
+/**
+ * Logging class for Telegenta library. Use this if you want to handle logs or control log level.
+ * If no handler is given, logs will be sent to console.
+ *
+ * @example
+ * // Creating Phone object with custom log instance
+ * import {LogHandler, LOGLVL} from './telegenta.js';
+ * const myLogger = new LogHandler(LOGLVL.WARNING, null)
+ * const phone = new Telegenta.Phone(myLogger)
+ * ...
+ */
+class LogHandler {
+    /** Create new log handler
+     * @param {LOGLVL} level - Log level
+     * @param {function} handler - External handler function to call on new log entries
+     */
+    constructor(level = 2, handler = null) {
+        this.extHandler = handler;
+        this.level = level;
+    }
+
+    debug(...args) {
+        this._doLog(LOGLVL$1.DEBUG, args);
+    }
+
+    info(...args) {
+        this._doLog(LOGLVL$1.INFO, args);
+    }
+
+    warn(...args) {
+        this._doLog(LOGLVL$1.WARN, args);
+    }
+
+    warning(...args) {
+        this._doLog(LOGLVL$1.WARN, args);
+    }
+
+    error(...args) {
+        this._doLog(LOGLVL$1.ERROR, args);
+    }
+
+    _doLog(level, args) {
+        // Check log level
+        if (level > this.level) {
+            return;
+        }
+
+        // If only one element, discard array (gives better output to console)
+        if (args.length === 1) {
+            args = args[0];
+        }
+
+        // Use external handler?
+        if (this.extHandler) {
+            this.extHandler(LOGLVLSTR[level], args);
+        } else {
+            switch (level) {
+                case LOGLVL$1.DEBUG:
+                    console.debug(args);
+                    break;
+
+                case LOGLVL$1.INFO:
+                    console.info(args);
+                    break;
+
+                case LOGLVL$1.WARN:
+                    console.warn(args);
+                    break;
+
+                case LOGLVL$1.ERROR:
+                    console.error(args);
+                    break;
+
+                default:
+                    console.log(args);
+            }
+        }
+    }
+}
+
+/**
+ * Log levels
+ * @typedef LOGLVL {number}
+ * @property {number} ERROR 0 Error messages
+ * @property {number} WARN 1 Warning meesages
+ * @property {number} INFO 2 Informational messages (default)
+ * @property {number} DEBUG 3 Debug messages
+ */
+const LOGLVL$1 = {
+    DEBUG: 3,
+    INFO: 2,
+    WARN: 1,
+    ERROR: 0,
+};
+
+const LOGLVLSTR = {
+    3: "DEBUG",
+    2: "INFO ",
+    1: "WARN ",
+    0: "ERROR",
+};
+
+/**
+ * Exception raised if Phone media permission is not prepared / allowed
+ */
+class MediaNotPrepared extends Error {
+    constructor(message) {
+        super();
+        this.name = 'MediaNotPrepared';
+        this.message = message;
+    }
+}
+
+/**
+ * Exception raised if Phone is not ready to perform desired action
+ */
+class NotReady extends Error {
+    constructor(message) {
+        super();
+        this.name = 'NotReady';
+        this.message = message;
+    }
+}
+
+/**
+ * Exception raised if media device id given does not exists
+ * @property message - Error message
+ */
+class InvalidMediaDevice extends Error {
+    constructor(message) {
+        super();
+        this.name = 'InvalidMediaDevice';
+        this.message = message;
+    }
+}
+
+/**
+ * Exception raised if one or more options parsed is invalid
+ * @property param - Name of invalid options parameter
+ * @property message - Error message
+ *
+ */
+class InvalidOptions extends Error {
+    constructor(param, message) {
+        super();
+        this.name = 'InvalidOptions';
+        this.param = param;
+        this.message = message;
+    }
+}
+
+/**
+ * Exception raised if parameter given is invalid
+ * @property message - Error message
+ */
+class InvalidParameter extends Error {
+    constructor(message) {
+        super();
+        this.name = 'InvalidParameter';
+        this.message = message;
+    }
+}
+
+/**
+ * Exception raised if trying to perform actions that require active session
+ */
+class NoActiveSession extends Error {
+    constructor() {
+        super();
+        this.name = 'NoActiveSession';
+    }
+}
+
+/**
+ * Exception raised if unable to connect to service
+ */
+class UnableToConnect extends Error {
+    constructor() {
+        super();
+        this.name = 'UnableToConnect';
+    }
+}
+
+/**
+ * Exception raised operation is not allowed
+ */
+class NotAllowed extends Error {
+    constructor(message) {
+        super();
+        this.name = 'NotAllowed';
+        this.message = message;
+    }
+}
+
+/*
+ * TOOLBOX
+ */
+
+// Create a new UUID
+function createUUID() {
+    let d = new Date().getTime();
+    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+        d += performance.now(); //use high-precision timer if available
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        let r = (d + Math.random() * 16) % 16 | 0;
+        d = Math.floor(d / 16);
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}
+
+// Compare properties of two objects. Comparison check if all properties in obj1 exists and has same values in obj2
+function compareObjects(obj1, obj2) {
+    if ((!obj1) || (!obj2)) {
+        return false;
+    }
+
+    // console.info('OBJECT 1: '+JSON.stringify(obj1));
+    // console.info('OBJECT 2: '+JSON.stringify(obj2));
+
+    const k2 = Object.keys(obj2);
+    return Object.keys(obj1).every(function (k) {
+        // Check key exists first
+        if (k2.indexOf(k) === -1) {
+            return false;
+        }
+
+        return (obj1[k] === obj2[k]);
+    });
+}
+
+// Return duration as formatted string
+function createDurationString(milliSeconds) {
+    const seconds = Math.floor(milliSeconds / 1000);
+
+    let s = '';
+
+    // Days
+    if (seconds / 86400 >= 1) {
+        s = s + Math.floor(seconds / 86400) + 'd ';
+    }
+    // Hour
+    if (seconds / 3600 >= 1) {
+        s = s + Math.floor(seconds / 3600) % 24 + 'h ';
+    }
+
+    // Seconds
+    if (seconds >= 0) {
+        s = s + ("00" + Math.floor(seconds / 60) % 60).slice(-2) + ':';
+        s = s + ("00" + (seconds % 60)).slice(-2);
+    } else {
+        s = '00:00';
+    }
+
+    return s;
+}
+
+// Browser checks
+function browserIsOpera() {
+    return ((navigator.userAgent.indexOf("Opera") || navigator.userAgent.indexOf('OPR')) !== -1)
+}
+
+function browserIsChrome() {
+    return (navigator.userAgent.indexOf("Chrome") !== -1)
+}
+
+function browserIsFirefox() {
+    return (navigator.userAgent.indexOf("Firefox") !== -1)
+}
+
+function browserIsSafari() {
+    return (navigator.userAgent.indexOf("Safari") !== -1)
+}
+
+function browserIsEdge() {
+    return (navigator.userAgent.indexOf("Edge") !== -1)
+}
+
+// Request timeout after 10 sec
+const REQUEST_TIMEOUT = 10000;
+
+/**
+ * Request class passed to event listeners
+ * Can be used to fulfill request and receive request parameters (data property)
+ */
+class Request {
+    constructor(owner, socket, request) {
+        this.socket = socket;
+        this._owner = owner;
+        this._request = request;
+        this._handled = false;
+        this.data = request.data;
+    }
+
+    /**
+     * Resolve request (promise will be resolved successfully on remote)
+     * @param data
+     */
+    resolve(data = null) {
+        this._assertSingleRequest();
+        try {
+            this.socket.send(JSON.stringify({ type: "_ACK", id: this._request.id, data: data }));
+        } catch (e) {
+            this._owner.log.warning(`Unable to resolve request ${this._request.id}: ${e}`);
+        }
+    }
+
+    /**
+     * Reject request (promise will be rejected on remote)
+     * @param reason
+     */
+    reject(reason = null) {
+        this._assertSingleRequest();
+        try {
+            this.socket.send(JSON.stringify({ type: "_NACK", id: this._request.id, reason: reason }));
+        } catch (e) {
+            this._owner.log.warning(`Unable to reject request ${this._request.id}: ${e}`);
+        }
+    }
+
+    // Make sure request is only fulfilled once
+    _assertSingleRequest() {
+        if (this._handled) {
+            throw new NotAllowed(`Request ${this._request.id} already fulfilled`);
+        }
+        this._handled = true;
+    }
+}
+
+/**
+ * This class handles async communication on websockets and implements promises for requests
+ */
+class Requestor extends EventEmitter {
+    constructor(logger = null) {
+        super();
+        this.log = logger ? logger : new LogHandler(LOGLVL$1.INFO);
+        this._pendingRequests = [];
+    }
+
+    /**
+     * Receive message from websocket
+     * @param socket
+     * @param message
+     */
+    receiveMessage(socket, message) {
+        this.log.debug("Received message: " + message);
+
+        let msg;
+        try {
+            msg = JSON.parse(message);
+        } catch (err) {
+            this.log.warning("Unable to parse message: " + message);
+            return;
+        }
+
+        // Validate msg fields
+        if (!msg.hasOwnProperty("type") || !msg.hasOwnProperty("id")) {
+            this.log.warning(`Invalid message received: ${msg} - missing type or id`);
+            return;
+        }
+
+        // Is it a ACK or NACK response?
+        if (msg.type === "_ACK" || msg.type === "_NACK") {
+            // Find pending request first
+            const request = this.findPendingRequest(msg.id);
+            if (!request) {
+                this.log.warning(`Received message with invalid request id: ${msg.id} - timed out?`);
+                return;
+            }
+
+            if (msg.type === "_ACK") {
+                this.log.debug(`Received ACK with id=${msg.id}`);
+                request.resolve(msg.data);
+            } else if (msg.type === "_NACK") {
+                this.log.debug(`Received NACK with id=${msg.id}`);
+                request.reject(msg.reason);
+            }
+
+            this.removePendingRequest(msg.id);
+            return;
+        }
+
+        // Is it PING request?
+        if (msg.type === "_PING") {
+            this.log.debug("Received ping, sending pong (ACK)");
+            socket.send(
+                JSON.stringify({
+                    type: "_ACK",
+                    id: msg.id,
+                    data: "pong",
+                }),
+            );
+            return;
+        }
+
+        this.log.debug(`Received new request of type '${msg.type}' with id=${msg.id}`);
+        if (!this.emit(msg.type, new Request(this, socket, msg))) {
+            this.log.warning("Received request with no listeners, rejecting");
+            socket.send(
+                JSON.stringify({
+                    type: "_NACK",
+                    id: msg.id,
+                    reason: "No handlers for that request type",
+                }),
+            );
+        }
+    }
+
+    /**
+     * Send a request
+     * @param socket Socket to send request
+     * @param type Request type name
+     * @param data Request Payload
+     * @throws InvalidParameter - If one or more parameters specified is invalid
+     * @returns promise Fulfilled once request has been handled on remote or rejected on error
+     */
+    sendRequest(socket, type, data = {}) {
+        if (!socket || !type) {
+            throw new InvalidParameter("You must specify socket and request type");
+        }
+
+        // Build and send request message
+        let r = { type: type, id: createUUID(), data: data };
+        this.log.debug(`Sending request type '${type}' with id ${r.id}`);
+        try {
+            socket.send(JSON.stringify(r));
+        } catch (e) {
+            this.log.warning(`Unable to send request ${r.id} socket error: ${e}`);
+            return new Promise(function (resolve, reject) {
+                reject(`Unable to send request: ${e}`);
+            });
+        }
+
+        // Return promise and push to pending request list with a timeout
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            self._pendingRequests.push({
+                request: r,
+                resolve: resolve,
+                reject: reject,
+                timeoutObj: setTimeout(function () {
+                    self.log.warning(`Timeout on request ${r.id}, rejecting!`);
+                    self.removePendingRequest(r.id);
+                    reject("Request timed out");
+                }, REQUEST_TIMEOUT),
+            });
+        });
+    }
+
+    /**
+     * Send a ping request (for keep alives)
+     * @param socket
+     * @returns promise Promise resolved on reply
+     */
+    ping(socket) {
+        this.log.debug("Sending ping");
+        return this.sendRequest(socket, "_PING");
+    }
+
+    /**
+     * Remove a request from pending queue
+     * @param requestId
+     * @returns boolean Removal outcome (true = removed)
+     */
+    removePendingRequest(requestId) {
+        for (let idx in this._pendingRequests) {
+            if (this._pendingRequests[idx].request.id === requestId) {
+                clearTimeout(this._pendingRequests[idx].timeoutObj);
+                this._pendingRequests.splice(idx, 1);
+                this.log.debug(`Removed request id: ${requestId}`);
+                return true;
+            }
+        }
+
+        this.log.warning(`Unable to remove request ${requestId} => not found`);
+        return false;
+    }
+
+    /**
+     * Get index og pending request
+     * @param requestId
+     * @returns object Return request from pending request array or null if not found
+     */
+    findPendingRequest(requestId) {
+        for (let req of this._pendingRequests) {
+            if (req.request.id === requestId) {
+                return req;
+            }
+        }
+        return null;
+    }
+}
+
+/*
+ * EVENT CLASS
+ *
+ * AMQP Message structure
+ * ----------------------
+ * event_name
+ * customer_id
+ * partner_id
+ * payload
+ * resource_name (only resource_changed)
+ * call_token (only calldata_available)
+ *
+ */
+// Keep alive in seconds
+const PING_INTERVAL = 50;
+
+const ES_DEFAULT_SERVER_URL = "wss://api.telegenta.com/es/";
+
+// Starting retry interval
+const RETRY_INTERVAL_START = 1 + Math.random();
+
+// Maximum reconnect time
+const RETRY_MAX_BACKOFF = 300;
+
+class EventSubscription {
+    constructor(id, specification, callback) {
+        this.id = id;
+        this.specification = specification;
+        this.callback = callback;
+    }
+
+    doCallback(context, payload) {
+        return this.callback.apply(context, [payload]);
+    }
+}
+
+/**
+ * Class is responsible for handling real time server events over websockets <br>
+ * Using this class you can subscribe to a list of useful remote events
+ *
+ * @param {LogHandler} [logger] - Custom log instance
+ *
+ */
+class EventClient {
+    constructor(logger = null) {
+        this._socket = null;
+        this._previousSubscriptions = [];
+        this._activeSubscriptions = [];
+        this._pingTimerObj = null;
+        this._autoReconnect = false;
+        this._reconnectRetrySeconds = RETRY_INTERVAL_START;
+        this.log = logger ? logger : new LogHandler(LOGLVL.ERROR);
+        this._requestor = new Requestor(this.log);
+
+        this._requestor.on("event", (request) => {
+            this._handleIncomingEvent(request);
+        });
+    }
+
+    /**
+     * Establish a connecting to the event service
+     * @param {string=} Event service address URL
+     * @returns object Connection promise
+     */
+    connect(server_address = null) {
+        if (!server_address) {
+            server_address = ES_DEFAULT_SERVER_URL;
+        }
+
+        this._serverAddress = server_address;
+        this._previousSubscriptions = [];
+        this._activeSubscriptions = [];
+        return this._connectServer();
+    }
+
+    /**
+     * Disconnect from event service and clear all active subscriptions
+     * @throws NoActiveSession if not connected
+     */
+    disconnect() {
+        if (this._socket.readyState !== 1) {
+            throw new NoActiveSession();
+        }
+
+        this._activeSubscriptions = [];
+        this._autoReconnect = false;
+        this._socket.close();
+    }
+
+    /**
+     * Return service connection state
+     * @returns {boolean}
+     */
+    isConnected() {
+        if (this._socket) {
+            return this._socket.readyState === 1;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Subscribe to event
+     * @param eventSpecification object Event parameters (please check docs for further description)
+     * @param callback object Callback function (will be called when event is received)
+     * @throws InvalidParameter
+     * @returns object Promise on subscription
+     */
+    subscribe(eventSpecification, callback) {
+        if (!eventSpecification || !callback) {
+            throw new InvalidParameter("You must specify both event spec and callback function");
+        }
+
+        if (!eventSpecification.hasOwnProperty("event_name")) {
+            throw new InvalidParameter("Your event specification must contain event name");
+        }
+
+        if (!this.isConnected()) {
+            throw new NoActiveSession();
+        }
+
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            self._requestor.sendRequest(self._socket, "subscribe", eventSpecification).then(
+                function (subscriptionId) {
+                    self.log.debug(`Subscription to '${eventSpecification.event_name}' was successful, ID = ${subscriptionId}`);
+                    self._activeSubscriptions.push(new EventSubscription(subscriptionId, eventSpecification, callback));
+                    resolve(subscriptionId);
+                },
+                function (reason) {
+                    self.log.warning(`Subscription to '${eventSpecification.event_name}' failed: ${reason}`);
+                    reject(reason);
+                },
+            );
+        });
+    }
+
+    /**
+     * Unsubscribe event messages
+     * @param subscriptionId Object Event specification to unsubscribe (must match specification used on subscribe)
+     * @throws InvalidParameter
+     * @returns object Promise on unsubscribe
+     */
+    unsubscribe(subscriptionId) {
+        if (!subscriptionId) {
+            throw new InvalidParameter("You must specify subscription id");
+        }
+
+        if (!this.isConnected()) {
+            throw new NoActiveSession();
+        }
+
+        this.log.info("Unsubscribe id: " + subscriptionId);
+
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            self._requestor.sendRequest(self._socket, "unsubscribe", { id: subscriptionId }).then(
+                (data) => {
+                    self.log.info(`Unsubscribe to '${subscriptionId}' was successful`);
+                    self._removeSubscription(subscriptionId);
+                    resolve(data);
+                },
+                (reason) => {
+                    self.log.warning(`Remote unsubscribe to '${subscriptionId}' failed: ${reason}`);
+                    reject(reason);
+                },
+            );
+        });
+    }
+
+    /**
+     * Fire event message
+     * @param type Event type to fire
+     * @param payload Event payload
+     * @throws NoActiveSession
+     * @returns object Promise on event
+     */
+    fireEvent(type, payload) {
+        if (!this.isConnected()) {
+            throw new NoActiveSession();
+        }
+
+        return new Promise((resolve, reject) => {
+            this._requestor.sendRequest(this._socket, type, payload).then(
+                (data) => {
+                    this.log.info(`Event ${type} was successful`);
+                    resolve(data);
+                },
+                (reason) => {
+                    this.log.warning(`Event ${type} failed: ${reason}`);
+                    reject(reason);
+                },
+            );
+        });
+    }
+
+    // Remove subscription from active subscriptions
+    _removeSubscription(subscriptionId) {
+        for (let idx in this._activeSubscriptions) {
+            if (this._activeSubscriptions[idx].id === subscriptionId) {
+                this.log.debug(`Removed local subscription: ${subscriptionId}`);
+                this._activeSubscriptions.splice(idx, 1);
+                return true;
+            }
+        }
+
+        this.log.warning(`Unable to remove subscription ${subscriptionId} locally, not found?`);
+        return false;
+    }
+
+    // Connect to event service
+    _connectServer() {
+        this.log.info("Connecting to event server: " + this._serverAddress);
+
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            if (self._socket) {
+                switch (self._socket.readyState) {
+                    case 0:
+                        reject("Unable to connect, already connecting");
+                        return;
+                    case 1:
+                        reject("Unable to connect, already connected");
+                        return;
+                    case 2:
+                        reject("Unable to connect, socket is still closing");
+                        return;
+                }
+            }
+
+            self._socket = new WebSocket(self._serverAddress);
+            let was_connected = false;
+
+            // CONNECTION OPEN
+            self._socket.addEventListener("open", function (/*event*/) {
+                self.log.info("Successfully connected to event service");
+
+                was_connected = true;
+                // After successful connect we enable auto connect and reset reconnect timer
+                self._autoReconnect = true;
+                self._reconnectRetrySeconds = RETRY_INTERVAL_START;
+
+                // Hook up event for incoming messages to requestor
+                self._socket.addEventListener("message", function (event) {
+                    self._requestor.receiveMessage(self._socket, event.data);
+                });
+
+                // Start keep alive timer
+                clearTimeout(self._pingTimerObj);
+                self._pingTimerObj = setInterval(function () {
+                    self._requestor.ping(self._socket).then(
+                        function () {
+                            // self.log.debug('Pong');
+                        },
+                        function (reason) {
+                            self.log.warning("Ping failed: " + reason);
+                            self._reconnectServer();
+                        },
+                    );
+                }, PING_INTERVAL * 1000);
+
+                // Reset active subscriptions first
+                self._previousSubscriptions = self._activeSubscriptions;
+                self._activeSubscriptions = [];
+
+                // Resubscribe all events
+                for (let sub of self._previousSubscriptions) {
+                    self.subscribe(sub.specification, sub.callback).catch(function (reason) {
+                        self.log.error(`Resubscribing to ${sub.specification.event_name} failed: ${reason}`);
+                    });
+                }
+
+                resolve();
+            });
+
+            // CONNECTION CLOSE
+            self._socket.addEventListener("close", function (/*event*/) {
+                self.log.info("Disconnected from event service");
+                clearTimeout(self._pingTimerObj);
+                // We try to reconnect if possible
+                self._reconnectServer();
+            });
+
+            // CONNECTION ERROR
+            self._socket.addEventListener("error", function (error) {
+                self.log.error("Websocket connection error");
+                // Only reject promise if no connection was made (in that case promise is already resolved)
+                if (!was_connected) {
+                    reject("Unable to connect: " + error);
+                }
+            });
+        });
+    }
+
+    _reconnectServer() {
+        if (this._autoReconnect) {
+            const retryInterval = Math.floor(this._reconnectRetrySeconds);
+            this.log.info(`Reconnecting in ${retryInterval} secs`);
+            const self = this;
+            setTimeout(function () {
+                self._connectServer().then(
+                    function () {
+                        self.log.info("Reconnect attempt successful");
+                    },
+                    function () {
+                        self.log.warning("Reconnect attempt failed");
+                    },
+                );
+                if (self._reconnectRetrySeconds <= RETRY_MAX_BACKOFF) {
+                    self._reconnectRetrySeconds = self._reconnectRetrySeconds * 2;
+                }
+            }, self._reconnectRetrySeconds * 1000);
+        } else {
+            this.log.info("Auto reconnect disabled (disconnecting?)");
+        }
+    }
+
+    _handleIncomingEvent(request) {
+        // Find subscription by id
+        const subId = request.data.subscription_id;
+        for (let sub of this._activeSubscriptions) {
+            if (sub.id === subId) {
+                this.log.debug(`Received event for subcription id ${sub.id} payload: ` + JSON.stringify(request.data.payload));
+                try {
+                    sub.callback(request.data.payload);
+                } catch (e) {
+                    this.log.warning(`Callback had unhandled exception ${e}`);
+                    request.resolve();
+                }
+
+                request.resolve();
+                return;
+            }
+        }
+
+        request.reject(`Invalid subscription id for event: ${subId}`);
+    }
+}
+
+const isObject$1 = value => typeof value === 'object' && value !== null;
+
+// Customized for this use-case
+const isObjectCustom = value =>
+	isObject$1(value)
+	&& !(value instanceof RegExp)
+	&& !(value instanceof Error)
+	&& !(value instanceof Date)
+	&& !(globalThis.Blob && value instanceof globalThis.Blob);
+
+const mapObjectSkip = Symbol('mapObjectSkip');
+
+const _mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
+	options = {
+		deep: false,
+		target: {},
+		...options,
+	};
+
+	if (isSeen.has(object)) {
+		return isSeen.get(object);
+	}
+
+	isSeen.set(object, options.target);
+
+	const {target} = options;
+	delete options.target;
+
+	const mapArray = array => array.map(element => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
+	if (Array.isArray(object)) {
+		return mapArray(object);
+	}
+
+	for (const [key, value] of Object.entries(object)) {
+		const mapResult = mapper(key, value, object);
+
+		if (mapResult === mapObjectSkip) {
+			continue;
+		}
+
+		let [newKey, newValue, {shouldRecurse = true} = {}] = mapResult;
+
+		// Drop `__proto__` keys.
+		if (newKey === '__proto__') {
+			continue;
+		}
+
+		if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
+			newValue = Array.isArray(newValue)
+				? mapArray(newValue)
+				: _mapObject(newValue, mapper, options, isSeen);
+		}
+
+		target[newKey] = newValue;
+	}
+
+	return target;
+};
+
+function mapObject(object, mapper, options) {
+	if (!isObject$1(object)) {
+		throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+	}
+
+	if (Array.isArray(object)) {
+		throw new TypeError('Expected an object, got an array');
+	}
+
+	return _mapObject(object, mapper, options);
+}
+
+const UPPERCASE = /[\p{Lu}]/u;
+const LOWERCASE = /[\p{Ll}]/u;
+const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+const SEPARATORS = /[_.\- ]+/;
+
+const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
+const NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
+
+const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase) => {
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+	let isLastLastCharPreserved = false;
+
+	for (let index = 0; index < string.length; index++) {
+		const character = string[index];
+		isLastLastCharPreserved = index > 2 ? string[index - 3] === '-' : true;
+
+		if (isLastCharLower && UPPERCASE.test(character)) {
+			string = string.slice(0, index) + '-' + string.slice(index);
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			index++;
+		} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase)) {
+			string = string.slice(0, index - 1) + '-' + string.slice(index - 1);
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+		}
+	}
+
+	return string;
+};
+
+const preserveConsecutiveUppercase = (input, toLowerCase) => {
+	LEADING_CAPITAL.lastIndex = 0;
+
+	return input.replaceAll(LEADING_CAPITAL, match => toLowerCase(match));
+};
+
+const postProcess = (input, toUpperCase) => {
+	SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+	NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+
+	return input
+		.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ['_', '-'].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match))
+		.replaceAll(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier));
+};
+
+function camelCase(input, options) {
+	if (!(typeof input === 'string' || Array.isArray(input))) {
+		throw new TypeError('Expected the input to be `string | string[]`');
+	}
+
+	options = {
+		pascalCase: false,
+		preserveConsecutiveUppercase: false,
+		...options,
+	};
+
+	if (Array.isArray(input)) {
+		input = input.map(x => x.trim())
+			.filter(x => x.length)
+			.join('-');
+	} else {
+		input = input.trim();
+	}
+
+	if (input.length === 0) {
+		return '';
+	}
+
+	const toLowerCase = options.locale === false
+		? string => string.toLowerCase()
+		: string => string.toLocaleLowerCase(options.locale);
+
+	const toUpperCase = options.locale === false
+		? string => string.toUpperCase()
+		: string => string.toLocaleUpperCase(options.locale);
+
+	if (input.length === 1) {
+		if (SEPARATORS.test(input)) {
+			return '';
+		}
+
+		return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+	}
+
+	const hasUpperCase = input !== toLowerCase(input);
+
+	if (hasUpperCase) {
+		input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
+	}
+
+	input = input.replace(LEADING_SEPARATORS, '');
+	input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+
+	if (options.pascalCase) {
+		input = toUpperCase(input.charAt(0)) + input.slice(1);
+	}
+
+	return postProcess(input, toUpperCase);
+}
+
+class QuickLRU extends Map {
+	#size = 0;
+	#cache = new Map();
+	#oldCache = new Map();
+	#maxSize;
+	#maxAge;
+	#onEviction;
+
+	constructor(options = {}) {
+		super();
+
+		if (!(options.maxSize && options.maxSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+			throw new TypeError('`maxAge` must be a number greater than 0');
+		}
+
+		this.#maxSize = options.maxSize;
+		this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+		this.#onEviction = options.onEviction;
+	}
+
+	// For tests.
+	get __oldCache() {
+		return this.#oldCache;
+	}
+
+	#emitEvictions(cache) {
+		if (typeof this.#onEviction !== 'function') {
+			return;
+		}
+
+		for (const [key, item] of cache) {
+			this.#onEviction(key, item.value);
+		}
+	}
+
+	#deleteIfExpired(key, item) {
+		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+			if (typeof this.#onEviction === 'function') {
+				this.#onEviction(key, item.value);
+			}
+
+			return this.delete(key);
+		}
+
+		return false;
+	}
+
+	#getOrDeleteIfExpired(key, item) {
+		const deleted = this.#deleteIfExpired(key, item);
+		if (deleted === false) {
+			return item.value;
+		}
+	}
+
+	#getItemValue(key, item) {
+		return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
+	}
+
+	#peek(key, cache) {
+		const item = cache.get(key);
+		return this.#getItemValue(key, item);
+	}
+
+	#set(key, value) {
+		this.#cache.set(key, value);
+		this.#size++;
+
+		if (this.#size >= this.#maxSize) {
+			this.#size = 0;
+			this.#emitEvictions(this.#oldCache);
+			this.#oldCache = this.#cache;
+			this.#cache = new Map();
+		}
+	}
+
+	#moveToRecent(key, item) {
+		this.#oldCache.delete(key);
+		this.#set(key, item);
+	}
+
+	* #entriesAscending() {
+		for (const item of this.#oldCache) {
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield item;
+				}
+			}
+		}
+
+		for (const item of this.#cache) {
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield item;
+			}
+		}
+	}
+
+	get(key) {
+		if (this.#cache.has(key)) {
+			const item = this.#cache.get(key);
+			return this.#getItemValue(key, item);
+		}
+
+		if (this.#oldCache.has(key)) {
+			const item = this.#oldCache.get(key);
+			if (this.#deleteIfExpired(key, item) === false) {
+				this.#moveToRecent(key, item);
+				return item.value;
+			}
+		}
+	}
+
+	set(key, value, {maxAge = this.#maxAge} = {}) {
+		const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
+			? (Date.now() + maxAge)
+			: undefined;
+
+		if (this.#cache.has(key)) {
+			this.#cache.set(key, {
+				value,
+				expiry,
+			});
+		} else {
+			this.#set(key, {value, expiry});
+		}
+
+		return this;
+	}
+
+	has(key) {
+		if (this.#cache.has(key)) {
+			return !this.#deleteIfExpired(key, this.#cache.get(key));
+		}
+
+		if (this.#oldCache.has(key)) {
+			return !this.#deleteIfExpired(key, this.#oldCache.get(key));
+		}
+
+		return false;
+	}
+
+	peek(key) {
+		if (this.#cache.has(key)) {
+			return this.#peek(key, this.#cache);
+		}
+
+		if (this.#oldCache.has(key)) {
+			return this.#peek(key, this.#oldCache);
+		}
+	}
+
+	expiresIn(key) {
+		const item = this.#cache.get(key) ?? this.#oldCache.get(key);
+		if (item) {
+			return item.expiry ? item.expiry - Date.now() : Number.POSITIVE_INFINITY;
+		}
+	}
+
+	delete(key) {
+		const deleted = this.#cache.delete(key);
+		if (deleted) {
+			this.#size--;
+		}
+
+		return this.#oldCache.delete(key) || deleted;
+	}
+
+	clear() {
+		this.#cache.clear();
+		this.#oldCache.clear();
+		this.#size = 0;
+	}
+
+	resize(newSize) {
+		if (!(newSize && newSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		const items = [...this.#entriesAscending()];
+		const removeCount = items.length - newSize;
+		if (removeCount < 0) {
+			this.#cache = new Map(items);
+			this.#oldCache = new Map();
+			this.#size = items.length;
+		} else {
+			if (removeCount > 0) {
+				this.#emitEvictions(items.slice(0, removeCount));
+			}
+
+			this.#oldCache = new Map(items.slice(removeCount));
+			this.#cache = new Map();
+			this.#size = 0;
+		}
+
+		this.#maxSize = newSize;
+	}
+
+	evict(count = 1) {
+		const requested = Number(count);
+		if (!requested || requested <= 0) {
+			return;
+		}
+
+		const items = [...this.#entriesAscending()];
+		const evictCount = Math.trunc(Math.min(requested, Math.max(items.length - 1, 0)));
+		if (evictCount <= 0) {
+			return;
+		}
+
+		this.#emitEvictions(items.slice(0, evictCount));
+		this.#oldCache = new Map(items.slice(evictCount));
+		this.#cache = new Map();
+		this.#size = 0;
+	}
+
+	* keys() {
+		for (const [key] of this) {
+			yield key;
+		}
+	}
+
+	* values() {
+		for (const [, value] of this) {
+			yield value;
+		}
+	}
+
+	* [Symbol.iterator]() {
+		for (const item of this.#cache) {
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		for (const item of this.#oldCache) {
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesDescending() {
+		let items = [...this.#cache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		items = [...this.#oldCache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesAscending() {
+		for (const [key, value] of this.#entriesAscending()) {
+			yield [key, value.value];
+		}
+	}
+
+	get size() {
+		if (!this.#size) {
+			return this.#oldCache.size;
+		}
+
+		let oldCacheSize = 0;
+		for (const key of this.#oldCache.keys()) {
+			if (!this.#cache.has(key)) {
+				oldCacheSize++;
+			}
+		}
+
+		return Math.min(this.#size + oldCacheSize, this.#maxSize);
+	}
+
+	get maxSize() {
+		return this.#maxSize;
+	}
+
+	get maxAge() {
+		return this.#maxAge;
+	}
+
+	entries() {
+		return this.entriesAscending();
+	}
+
+	forEach(callbackFunction, thisArgument = this) {
+		for (const [key, value] of this.entriesAscending()) {
+			callbackFunction.call(thisArgument, value, key, this);
+		}
+	}
+
+	get [Symbol.toStringTag]() {
+		return 'QuickLRU';
+	}
+
+	toString() {
+		return `QuickLRU(${this.size}/${this.maxSize})`;
+	}
+
+	[Symbol.for('nodejs.util.inspect.custom')]() {
+		return this.toString();
+	}
+}
+
+const has = (array, key) => array.some(element => {
+	if (typeof element === 'string') {
+		return element === key;
+	}
+
+	element.lastIndex = 0;
+
+	return element.test(key);
+});
+
+// Preserve numeric keys. The trim check excludes empty/whitespace strings,
+// which Number() would incorrectly convert to 0.
+const isNumericKey = key => key.trim() !== '' && !Number.isNaN(Number(key));
+
+const cache = new QuickLRU({maxSize: 100_000});
+
+const isBuiltIn = value =>
+	ArrayBuffer.isView(value)
+	// Check for known built-in types
+	|| value instanceof Date
+	|| value instanceof RegExp
+	|| value instanceof Error
+	|| value instanceof Map
+	|| value instanceof Set
+	|| value instanceof WeakMap
+	|| value instanceof WeakSet
+	|| value instanceof Promise;
+
+// Reproduces behavior from `map-obj`.
+const isObject = value =>
+	typeof value === 'object'
+	&& value !== null
+	&& !isBuiltIn(value);
+
+const transform = (input, options = {}, isSeen = new WeakMap(), parentPath) => {
+	if (!isObject(input)) {
+		return input;
+	}
+
+	// Check for circular references
+	if (isSeen.has(input)) {
+		return isSeen.get(input);
+	}
+
+	const {
+		exclude,
+		pascalCase = false,
+		stopPaths,
+		deep = false,
+		preserveConsecutiveUppercase = false,
+	} = options;
+
+	const stopPathsSet = new Set(stopPaths);
+
+	// Handle arrays directly
+	if (Array.isArray(input)) {
+		const result = [];
+		isSeen.set(input, result);
+
+		for (const item of input) {
+			result.push(isObject(item) ? transform(item, options, isSeen, parentPath) : item);
+		}
+
+		return result;
+	}
+
+	// Pre-allocate the result object for circular reference handling
+	const result = {};
+	isSeen.set(input, result);
+
+	const makeMapper = currentParentPath => (key, value) => {
+		// Handle deep transformation
+		if (deep && isObject(value)) {
+			const path = currentParentPath === undefined ? key : `${currentParentPath}.${key}`;
+
+			if (!stopPathsSet.has(path)) {
+				// Handle arrays and objects recursively
+				value = Array.isArray(value)
+					? value.map(item => isObject(item) ? transform(item, options, isSeen, path) : item)
+					: transform(value, options, isSeen, path);
+			}
+		}
+
+		// Skip transformation for excluded keys, numeric keys
+		// Only transform string keys (preserve symbols and numbers)
+		if (typeof key === 'string' && !isNumericKey(key) && !(exclude && has(exclude, key))) {
+			const cacheKey = pascalCase ? `${key}_` : key;
+
+			if (cache.has(cacheKey)) {
+				key = cache.get(cacheKey);
+			} else {
+				// Preserve leading `_` and `$` as they typically have semantic meaning
+				// This should eventually be fixed in the `camelcase` package itself
+				const leadingPrefix = key.match(/^[_$]*/)[0];
+				const transformed = camelCase(key.slice(leadingPrefix.length), {pascalCase, locale: false, preserveConsecutiveUppercase});
+				key = leadingPrefix + transformed;
+
+				// Only cache reasonable length keys to prevent memory abuse
+				if (key.length < 100) {
+					cache.set(cacheKey, key);
+				}
+			}
+		}
+
+		return [key, value];
+	};
+
+	const mappedResult = mapObject(input, makeMapper(parentPath), {deep: false});
+
+	// Copy properties to the pre-allocated result for circular reference handling
+	Object.assign(result, mappedResult);
+
+	// Preserve symbol keys (mapObject doesn't handle them)
+	const symbols = Object.getOwnPropertySymbols(input);
+	for (const symbol of symbols) {
+		result[symbol] = deep && isObject(input[symbol])
+			? transform(input[symbol], options, isSeen, parentPath)
+			: input[symbol];
+	}
+
+	return result;
+};
+
+function camelcaseKeys(input, options) {
+	const isSeen = new WeakMap();
+
+	if (Array.isArray(input)) {
+		// More efficient array handling - directly map the array
+		return input.map(item =>
+			isObject(item)
+				? transform(item, options, isSeen, undefined)
+				: item);
+	}
+
+	return transform(input, options, isSeen);
+}
+
+// 'use strict';
+
+const options = {
+    wssServer: "wss://api.telegenta.com/sip/",
+    eventServer: "wss://api.telegenta.com/es/",
+    provisionToken: null,
+    authorizationUsername: null,
+    password: null,
+    callToken: null,
+    register: true,
+    iceGatherTimeout: 3000,
+    playSignalTones: true,
+    logger: null,
+    logLevel: 3,
+    connectEventService: false,
+    useCallDataInfoEvent: false,
+    toneVolume: 0.3,
+    autoBusyIncoming: true,
+    autoRemoveSessionTime: 3000,
+    playRingOnIncoming: true,
+    playCallInitializedTone: false,
+};
+
+// DTMF Frequency table
+const DTMF_FREQUENCY_TABLE = {
+    1: [1209, 697],
+    2: [1336, 697],
+    3: [1477, 697],
+    a: [1633, 697],
+    4: [1209, 770],
+    5: [1336, 770],
+    6: [1477, 770],
+    b: [1633, 770],
+    7: [1209, 852],
+    8: [1336, 852],
+    9: [1477, 852],
+    c: [1633, 852],
+    "*": [1209, 941],
+    0: [1336, 941],
+    "#": [1477, 941],
+    d: [1633, 941],
+};
+
+// SIGNAL TONE SEQUENCES
+
+// Params: d = Duration, f1 = Frequency 1, f2 = Frequency 2, g = Gap
+const ST_TEMP_UNAVAIL = [{ d: 250, f1: 425, f2: 0, g: 250 }];
+const ST_BUSY = [{ d: 500, f1: 425, f2: 0, g: 500 }];
+const ST_INVALID_NUMBER = [
+    { d: 333, f1: 950, f2: 0, g: 0 },
+    { d: 333, f1: 1400, f2: 0, g: 0 },
+    { d: 333, f1: 1800, f2: 0, g: 1000 },
+];
+const ST_CALLINIT = [
+    { d: 200, f1: 500, f2: 0, g: 0 },
+    { d: 200, f1: 700, f2: 0, g: 5000 },
+];
+const ST_RINGBACK = [{ d: 1000, f1: 425, f2: 0, g: 4000 }];
+const ST_INCOMING = [
+    { d: 150, f1: 400, f2: 0, g: 0 },
+    { d: 150, f1: 600, f2: 0, g: 0 },
+    { d: 150, f1: 400, f2: 0, g: 0 },
+    { d: 150, f1: 600, f2: 0, g: 0 },
+    { d: 150, f1: 400, f2: 0, g: 0 },
+    { d: 150, f1: 600, f2: 0, g: 3000 },
+];
+
+/**
+ * This class acts as a SIP user Agent and is responsible for handling calls using the WebRTC interface in the browser.<br>
+ * If you have your own log handler or if you want to adjust the log level you can create your own logging instance, when you create the Phone
+ * instance. See {@link LogHandler} class for more information.
+ *
+ * @param {LogHandler} [logger] - Custom log instance
+ *
+ * @fires connectionStateChange on connection state changes.
+ * @fires sessionCreated When a new session has been created
+ * @fires sessionRemoved When a existing session has been removed (after autoRemoveSessionTime)
+ * @fires callDataInfo Receive detailed information about call after call has been terminated
+ * @fires incomingCall Incoming call sessions are received on this event
+ *
+ * @example
+ * // Creating Phone object and use it make a call
+ * const phone = new Telegenta.Phone()
+ * phone.prepareMedia().then(() => {
+ *   // Hook up events
+ *   ...
+ *   // Start phone
+ *   phone.start(options);
+ *
+ *   // Dial 12345678
+ *   session = phone.call('12345678');
+ * }
+ */
+class Phone extends EventEmitter {
+    constructor(logger = null) {
+        super();
+
+        this._mediaPermission = false;
+        this._mediaPermissionError = false;
+        this._UA = null;
+        this._connectionState = null;
+        this._isStarted = false;
+        this._eventClient = null;
+        this._options = null;
+
+        // List of active sessions
+        this._sessionCounter = 0;
+        this._activeSessions = {};
+
+        // Create remote audio element
+        this._remoteAudioElement = document.createElement("AUDIO");
+        this._remoteAudioElement.autoplay = true;
+
+        // Tone generator
+        this._toneAudioElement = document.createElement("AUDIO");
+        this._toneAudioElement.autoplay = true;
+        this._toneTimer = null;
+        this._repeatToneActive = false;
+        this._repeatToneSequence = [];
+        this._repeatToneSequencePos = 0;
+        this._toneGainProcessor = null;
+        this._oscillator1 = null;
+        this._oscillator2 = null;
+
+        // Set default logger
+        this.log = logger ? logger : new LogHandler(LOGLVL$1.INFO);
+
+        // Handle jssip debug logs
+        if (this.log.level === LOGLVL$1.DEBUG) {
+            JsSIP.debug.disable("JsSIP:*");
+        } else {
+            JsSIP.debug.disable("JsSIP:*");
+        }
+    }
+
+    /**
+     * Prepare media and get media permission from browser
+     * This must be done prior to using the phone or getting device lists.
+     *
+     * @return A promise which will be resolved when user accepts access to media devices
+     *
+     */
+    prepareMedia() {
+        this.log.info("Get media permission");
+        const self = this;
+        const constraints = { audio: true, video: false };
+        return new Promise(function (resolve, reject) {
+            navigator.mediaDevices.getUserMedia(constraints).then(
+                () => {
+                    self._mediaPermission = true;
+                    self._mediaPermissionError = false;
+                    self.log.info("Media permission granted");
+                    resolve();
+                },
+                (err) => {
+                    self._mediaPermission = false;
+                    self._mediaPermissionError = true;
+                    self.log.error("Denied media permission: " + err);
+                    reject(err);
+                },
+            );
+        });
+    }
+
+    /**
+     * Start phone and connect to server if needed
+     *
+     * @param phoneOptions {object} configuration options
+     * @param {string} [phoneOptions.provisionToken] Provisioning token from API service
+     * @param {string} [phoneOptions.authorizationUsername] Authorizing username
+     * @param {string} [phoneOptions.password] WSS Password
+     * @param {string} [phoneOptions.callToken] Call token
+     * @param {boolean} [phoneOptions.connectEventService=false] Connect to event service (required to send call commands and receive callDataInfo event)
+     * @param {boolean} [phoneOptions.useCallDataInfoEvent=false] Subscribe to callDataInfo remote event
+     * @param {boolean} [phoneOptions.register=true] Register on server to receive enable incoming calls
+     * @param {number} [phoneOptions.playSignalTones=false] Play signal tones (busy, invalid number, etc) remotely
+     * @param {number} [phoneOptions.iceGatherTimeout=3000] Number of millisecs before ICE gather will be forced stopped and candidate selection will take place
+     * @param {number} [phoneOptions.toneVolume=0.3] Signal- and DTMF tone volume (0-1)
+     * @param {boolean} [phoneOptions.autoBusyIncoming=true] Automatically reject calls with busy if active session exists
+     * @param {number} [phoneOptions.autoRemoveSessionTime=3000] Automatically remove session after interval specified
+     * @param {number} [phoneOptions.playRingOnIncoming=true] Play ringing tones on incoming calls
+     * @param {number} [phoneOptions.playCallInitializedTone=false] Play tone when call has been initiated (before progress/ringback tones)
+     *
+     * @throws MediaNotPrepared - If {@link prepareMedia} was not called and resolved prior to calling this method
+     * @throws InvalidOptions - If one or more options are invalid
+     * @throws UnableToConnect - If unable to connect phone to server
+     */
+
+    start(phoneOptions) {
+        this._checkMediaPermission();
+        // Check phone is not running already, if so stop it first
+        if (this._isStarted) {
+            this.log.warning("Phone already started, stopping first");
+            this.stop();
+        }
+
+        // Apply options
+        this._options = Object.assign(options, phoneOptions);
+
+        this._initToneGenerator();
+
+        // Unpack provisioning token if specified
+        if (this._options.provisionToken) {
+            let pt = null;
+            try {
+                pt = JSON.parse(atob(this._options.provisionToken));
+            } catch (err) {
+                throw new InvalidOptions("provisionToken", "Invalid token");
+            }
+
+            this.log.info("Using provisioning token authorization");
+            this._options.wssServer = pt.wss_server;
+            this._options.eventServer = pt.event_server;
+            this._options.authorizationUsername = pt.wss_username;
+            this._options.password = pt.wss_password;
+            this._options.callToken = pt.wss_token;
+        } else {
+            this.log.info("Using manual specified credentials");
+
+            // Check auth info is provided
+            if (!this._options.authorizationUsername) {
+                throw new InvalidOptions("authorizationUsername", "Missing username");
+            }
+
+            if (!this._options.password) {
+                throw new InvalidOptions("password", "Missing password");
+            }
+
+            if (!this._options.callToken) {
+                throw new InvalidOptions("callToken", "Missing call token");
+            }
+        }
+
+        // If we must subscribe to call data info event, we enable event service
+        if (this._options.useCallDataInfoEvent && !this._options.connectEventService) {
+            this.log.info(`Enabled event service because 'useCallDataInfoEvent' is enabled`);
+            this._options.connectEventService = true;
+        }
+
+        // Connect to event service if needed
+        if (this._options.connectEventService) {
+            // Create and connect event client
+            this._eventClient = new EventClient(this.log);
+
+            this._eventClient.connect(this._options.eventServer).then(
+                () => {
+                    this.log.info(`Connected to event server`);
+
+                    // Subscript to CallDataEvent is needed
+                    if (this._options.useCallDataInfoEvent) {
+                        // Subscribe to calldata_available events
+                        let eventSpec = {
+                            event_name: "calldata_available",
+                            call_token: this._options.callToken,
+                        };
+
+                        this._eventClient
+                            .subscribe(eventSpec, (data) => {
+                                try {
+                                    this.log.debug("Received remote call data info");
+                                    this.log.debug(data);
+                                    this._fireCallDataInfoEvent(data);
+                                } catch (e) {
+                                    this.log.error("Event callback failed: " + e);
+                                }
+                            })
+                            .then(
+                                (subscriptionId) => {
+                                    this.log.info(`Subscription successful ID = ${subscriptionId}`);
+                                },
+                                (reason) => {
+                                    this.log.error(`Subscribe failed: ${reason}`);
+                                },
+                            );
+                    }
+                },
+                (reason) => {
+                    this.log.error(`Unable to connect to event server: ${reason}`);
+                },
+            );
+        }
+
+        let wsSocket = null;
+        try {
+            wsSocket = new JsSIP.WebSocketInterface(this._options.wssServer);
+        } catch (err) {
+            throw new UnableToConnect("Unable to connect phone websocket: " + err);
+        }
+
+        this.log.info("Starting phone");
+        this.log.debug(this._options);
+
+        this._UA = new JsSIP.UA({
+            sockets: [wsSocket],
+            authorization_user: this._options.authorizationUsername,
+            password: this._options.password,
+            register: this._options.register,
+            display_name: this._options.authorizationUsername,
+            uri: this._options.authorizationUsername + "@telegenta.com",
+            session_timers: false,
+        });
+
+        // Setup remote media handler
+        const self = this;
+        this._UA.on("newRTCSession", function (data) {
+            self.log.debug("New RTCSession");
+            if (data.originator === "remote") {
+                // Create new session
+                const session = new Session(self);
+
+                session.newInboundSession(data);
+
+                if (self._options.playRingOnIncoming) {
+                    self._startRepeatTone(ST_INCOMING);
+                }
+
+                // Check if we have other sessions and reject call if autoBusyIncoming is true
+                if (self._options.autoBusyIncoming) {
+                    if (Object.keys(self._activeSessions).length > 0) {
+                        self.log.info(`Autorejecting incoming call ${session.uuid} because there is already active calls`);
+                        session.reject(486, "Busy");
+                        return;
+                    } else {
+                        self.log.debug("There are no other sessions, adding incoming call");
+                    }
+                }
+
+                self._addSession(session);
+
+                // Set new session state
+                session._setSessionState("INCOMING");
+
+                // Now fire incomingCall event
+                self._fireIncomingCallEvent(session);
+            }
+        });
+
+        // Setup connection state event subscriptions
+        this._UA.on("connecting", function (/* data */) {
+            self._setConnectionState("CONNECTING");
+        });
+
+        this._UA.on("connected", function (/* data */) {
+            self._setConnectionState("CONNECTED");
+        });
+
+        this._UA.on("disconnected", function (/* data */) {
+            self._setConnectionState("DISCONNECTED");
+        });
+
+        this._UA.on("registered", function (/* data */) {
+            self._setConnectionState("REGISTERED");
+        });
+
+        this._UA.on("unregistered", function (/* data */) {
+            self._setConnectionState("UNREGISTERED");
+        });
+
+        this._UA.on("registrationFailed", function (/* data */) {
+            self._setConnectionState("REGISTRATION_FAILED");
+        });
+
+        this._UA.start();
+        this._isStarted = true;
+        this.log.info("Successfully started phone");
+    }
+
+    /**
+     * Stops the phone client, gracefully disconnects from the server and terminates any active calls
+     * @throws NotReady - If phone is not started
+     */
+    stop() {
+        // Check phone is started first
+        if (!this._isStarted) {
+            throw new NotReady("Phone is not started");
+        }
+
+        // Make sure events are not firing anymore, we can't rely on GC.
+        this._UA.removeAllListeners();
+
+        // Stop the UA
+        this._UA.stop();
+        delete this._UA;
+
+        // Disconnect event client if needed
+        if (!this._eventClient) {
+            this.log.debug("Event client not running, not stopping");
+            return;
+        }
+        try {
+            this._eventClient.disconnect();
+            delete this._eventClient;
+        } catch (e) {
+            this.log.warning("Unable to disconnect event client");
+        }
+
+        this._isStarted = false;
+        this.log.info("Phone client successfully stopped");
+    }
+
+    /**
+     * Start a new call
+     * If you have other active calls they will be set on hold
+     * @param number Number to call
+     * @param params {object} call options
+     * @param {number} [params.record] Recording retention days. The number of days recording will be kept. Setting this to 0 disables recording.
+     * @param {number} [params.explicitCallerId] Force a specific caller id, by providing explicit phone number id
+     * @param {number} [params.explicitShortCallerId] Force a specific caller id, by providing explicit short caller id
+     * @param {number} [params.answerCallTimeout=0] Hangup call with NO ANSWER if call is not picked up before specified interval (seconds). If 0, timeout is disabled.
+     * @param {number} [params.maximumCallCost] Maximum call cost (in customer currency) allowed for call. The call will automatically be stopped when the specified cost has been reached. Setting this to 0 disables checking for maximum cost.
+     * @param {string} [params.metaInfo] Add meta info to call, which will be available in server events and inside call complete webhook (max 256 chars)
+     * @return {Session} object for call
+     * @throws NotReady - If phone is not ready to call
+     * @throws NotAllowed - If there are calls currently connecting
+     *
+     */
+    call(number, params = {}) {
+        // Check phone is started first
+        if (!this._isStarted) {
+            throw new NotReady("Phone is not started");
+        }
+
+        // Check we dont have any other connecting calls
+        if (this._checkForConnectingCalls()) {
+            throw NotAllowed("Unable to make new calls while others are connecting");
+        }
+
+        // Hold other calls if needed
+        this.holdAllCalls();
+
+        const callParams = Object.assign(
+            {
+                record: false,
+                maximumCallCost: 0,
+                answerCallTimeout: 0,
+                explicitCallerId: null,
+                explicitShortCallerId: null,
+                metaInfo: null,
+                _isListenCall: false,
+            },
+            params,
+        );
+
+        // Trim phone number to remove spaces and '()'
+        number = number.trim().replace(/ |\(|\)/g, "");
+
+        this.log.info("Calling number: " + number);
+
+        let session = new Session(this);
+        session.newOutboundSession(number, callParams);
+        this._addSession(session);
+        return session;
+    }
+
+    /**
+     * Start a new session and listen to another call
+     * @param listenKey provided by API endpoint "active-calls" and the event library subscription for resource name "activecall"
+     * @return {Session} object for listen
+     * @throws NotReady - If phone is not ready to call
+     * @throws NotAllowed - If there are calls currently connecting
+     */
+    listen(listenKey) {
+        const s = listenKey.split("@");
+        let callUUID = s[0];
+        let mediaSwitch = "sip:" + s[1];
+
+        this.log.debug("Initiating listen to call with uuid " + callUUID + " on media switch " + mediaSwitch);
+        return this.call("listen-" + callUUID, {
+            mediaSwitchURI: mediaSwitch,
+            _isListenCall: true,
+        });
+    }
+
+    /**
+     * Get session by UUID, if none are found null is returned
+     * @param uuid
+     * @returns {Session|null}
+     */
+    getSessionByUUID(uuid) {
+        for (let key in this._activeSessions) {
+            if (this._activeSessions.hasOwnProperty(key)) {
+                if (this._activeSessions[key].uuid === uuid) {
+                    return this._activeSessions[key];
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Return phone options
+     * @returns {phoneOptions}
+     */
+    get options() {
+        return this._options;
+    }
+
+    /**
+     * Return list of current sessions
+     * @returns [Session]
+     */
+    get sessions() {
+        let s = [];
+        for (let key in this._activeSessions) {
+            if (this._activeSessions.hasOwnProperty(key)) {
+                s.push(this._activeSessions[key]);
+            }
+        }
+
+        return s;
+    }
+
+    /**
+     * Return media permission state
+     * @return {boolean}
+     */
+    get hasMediaPermission() {
+        return this._mediaPermission;
+    }
+
+    /**
+     * Media permission denied
+     * @return {boolean}
+     */
+    get hasMediaPermissionError() {
+        return this._mediaPermissionError;
+    }
+
+    /**
+     * Phone client started
+     * @return {boolean}
+     */
+    get isStarted() {
+        return this._isStarted;
+    }
+
+    /**
+     * Verify browser is supported
+     * @return true if browser supported
+     */
+    get browserSupported() {
+        return browserIsChrome() || browserIsFirefox() || browserIsOpera() || browserIsSafari();
+    }
+
+    /**
+     * Remote audio HTML element
+     */
+    get remoteAudioElement() {
+        return this._remoteAudioElement;
+    }
+
+    // TONE STUFF
+    /**
+     * Play tone locally (on incoming remote audio)
+     * @param duration Duration of tone in ms
+     * @param freq1 Frequency in Hz of tone 1
+     * @param freq2 Frequency in Hz of tone 2
+     * @param callback Function to be called after tone has ended
+     * @throws NotAllowed - If audio api is not supported by browser
+     */
+    playTone(duration, freq1, freq2 = 0, callback = null) {
+        this.log.debug(`Playing tone ${freq1} / ${freq2} for ${duration} ms`);
+
+        this._oscillator1.frequency.value = freq1;
+        this._oscillator2.frequency.value = freq2;
+        this._toneGainProcessor.gain.value = this._options.toneVolume;
+
+        // Set timer to stop tone again
+        const self = this;
+        this._toneTimer = setTimeout(function () {
+            self.stopTone();
+
+            // Handle callback now
+            if (callback) {
+                callback();
+            }
+        }, duration);
+    }
+
+    /**
+     * Immediately stop playing tones
+     * (Tone callbacks will be cancelled)
+     */
+    stopTone() {
+        this._oscillator1.frequency.value = 0;
+        this._oscillator2.frequency.value = 0;
+        this._toneGainProcessor.gain.value = 0;
+        clearTimeout(this._toneTimer);
+    }
+
+    // Begin repeating tones
+    _startRepeatTone(sequences) {
+        this.log.info("Repeating tone sequence started");
+        this.log.debug(sequences);
+        this._repeatToneSequence = sequences;
+        this._repeatToneSequencePos = 0;
+        this._repeatToneActive = true;
+        this._doRepeatTone();
+    }
+
+    // Do one tone
+    _doRepeatTone() {
+        if (this._repeatToneActive) {
+            this.log.debug(`Playing repeated tone, pos = ${this._repeatToneSequencePos}`);
+
+            // Get tone definitions and move to next sequence position
+            let toneDef = this._repeatToneSequence[this._repeatToneSequencePos];
+            this._repeatToneSequencePos++;
+            if (this._repeatToneSequencePos === this._repeatToneSequence.length) {
+                this._repeatToneSequencePos = 0;
+            }
+
+            const self = this;
+            this.playTone(toneDef.d, toneDef.f1, toneDef.f2, function () {
+                setTimeout(self._doRepeatTone.bind(self), toneDef.g);
+            });
+        }
+    }
+
+    // End repeating tones
+    _endRepeatTone() {
+        if (this._repeatToneActive) {
+            this.log.info("Repeating tone stopped");
+            this._repeatToneActive = false;
+            this.stopTone();
+        }
+    }
+
+    // Initialize tone generator
+    _initToneGenerator() {
+        // Create audio context
+        const AudioContext = window.AudioContext || window.webkitAudioContext || false;
+        if (!AudioContext) {
+            throw new NotAllowed("Audio API not supported by this browser");
+        }
+
+        const ctx = new AudioContext();
+        this._toneStreamNode = ctx.createMediaStreamDestination();
+        this._toneAudioElement.srcObject = this._toneStreamNode.stream;
+
+        this._toneGainProcessor = ctx.createGain();
+        this._toneGainProcessor.gain.value = 0;
+        this._toneGainProcessor.connect(this._toneStreamNode);
+
+        // Create two oscillators and start them
+        this._oscillator1 = ctx.createOscillator();
+        this._oscillator1.connect(this._toneGainProcessor);
+        this._oscillator1.frequency.value = 0;
+        this._oscillator1.start();
+
+        this._oscillator2 = ctx.createOscillator();
+        this._oscillator2.connect(this._toneGainProcessor);
+        this._oscillator2.frequency.value = 0;
+        this._oscillator2.start();
+    }
+
+    /**
+     * Hold all active calls
+     * @throws NotAllowed If there are connection calls
+     */
+    holdAllCalls() {
+        this.log.info("Holding all active sessions");
+        // Check all session can be set on hold
+        if (this._checkForConnectingCalls()) {
+            throw NotAllowed("A session is currently connecting");
+        }
+
+        // Iterate through all active calls and hold them
+        for (let key in this._activeSessions) {
+            if (this._activeSessions.hasOwnProperty(key)) {
+                let session = this._activeSessions[key];
+                if (session.state === "ACTIVE") {
+                    session.hold();
+                }
+            }
+        }
+    }
+
+    /*
+     * ======= PRIVATE METHODS PHONE CLASS =========================================================================
+     */
+
+    // Add a new session
+    _addSession(session) {
+        /**
+         * @event sessionCreated
+         * @type {object}
+         * @param {session} session - New session created
+         */
+        // Give session unique id
+        this._sessionCounter++;
+        session.__containerId = this._sessionCounter;
+
+        this.log.info(`Adding new session ${session.__containerId}: ${session.uuid}`);
+        this._activeSessions[session.__containerId] = session;
+        this.log.debug(`We now have ${Object.keys(this._activeSessions).length} sessions:`);
+        this.log.debug(this._activeSessions);
+
+        // Fire event
+        try {
+            this.emit("sessionCreated", { session: session });
+        } catch (e) {
+            this.log.error("Exception in sessionCreated event: " + e);
+        }
+    }
+
+    // Remove session
+    _removeSession(session) {
+        /**
+         * @event sessionRemoved
+         * @type {object}
+         * @param {session} session - Session removed
+         */
+
+        this.log.info(`Removing session ${session.__containerId}: ${session.uuid}`);
+
+        // Fire event
+        try {
+            this.emit("sessionRemoved", { session: session });
+        } catch (e) {
+            this.log.error("Exception in sessionRemoved event: " + e);
+        }
+
+        delete this._activeSessions[session.__containerId];
+        this.log.debug(`We now have ${Object.keys(this._activeSessions).length} sessions`);
+        this.log.debug(this._activeSessions);
+
+        // Stop any repeating tones
+        this._endRepeatTone();
+    }
+
+    // Session call this when call is finished
+    _sessionTerminated(session) {
+        this.log.debug(`Session ${session.uuid} terminated, removing in ${this._options.autoRemoveSessionTime} ms`);
+        const self = this;
+        setTimeout(function () {
+            self._removeSession(session);
+        }, this._options.autoRemoveSessionTime);
+    }
+
+    // Return true if there are calls currently connecting
+    _checkForConnectingCalls() {
+        for (let key in this._activeSessions) {
+            if (this._activeSessions.hasOwnProperty(key)) {
+                let session = this._activeSessions[key];
+                if (session.state === "INITIALIZING" || session.state === "CALLING" || session.state === "PROGRESS" || session.state === "INCOMING") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @typedef {string} CONNECTION_STATE
+     * @property {string} CONNECTING  Connecting to server
+     * @property {string} CONNECTED Connected to server
+     * @property {string} DISCONNECTED Disconnected from server
+     * @property {string} REGISTERED Registered on server
+     * @property {string} UNREGISTERED De-registered from server
+     * @property {string} REGISTRATION_FAILED Registration failed
+     */
+    // Set connection state and emit event
+    _setConnectionState(state) {
+        /**
+         * @event connectionStateChange
+         * @type {object}
+         * @param {CONNECTION_STATE} state - The current connection state
+         */
+
+        this.log.info("Connection state: " + state);
+        this._connectionState = state;
+        try {
+            this.emit("connectionStateChange", { state: state });
+        } catch (e) {
+            this.log.error("Exception in connectionStateChange event: " + e);
+        }
+    }
+
+    /**
+     * @event incomingCall
+     * @type {object}
+     * @param {Session} session New incoming session
+     */
+    _fireIncomingCallEvent(session) {
+        try {
+            this.emit("incomingCall", session);
+        } catch (e) {
+            this.log.error("Exception in incomingCall event: " + e);
+        }
+    }
+
+    // Fire call data event to subscribers
+    _fireCallDataInfoEvent(eventData = null) {
+        /**
+         * @event callDataInfo
+         *
+         * @type {object}
+         * @property {uuid} uuid - Customer Call UUID for session
+         * @param {CALL_DIRECTION} direction - Call direction
+         * @param {CALL_DISPOSITION} disposition - The final call disposition
+         * @param {string} originatingNumber - Caller ID number (a-number) used for call
+         * @param {string} destinationNumber - Destination number (b-number) used for call
+         * @param {Date} startTime - Start time of call
+         * @param {Date} answerTime - Time call was answered
+         * @param {Date} endTime - End time of call
+         * @param {number} duration - Total duration of the call (including call setup and remote answer time) (millisec)
+         * @param {String} durationStr - Total duration of the call formatted as (mm:ss)
+         * @param {number} answerDuration - Time before call was answered (millisec)
+         * @param {String} answerDurationStr - Time before call was answered formatted as (mm:ss)
+         * @param {number} activeDuration - Active duration of the call (time spend talking) (millisec)
+         * @param {String} activeDurationStr - Active duration of the call formatted as (mm:ss)
+         * @param {number} rateDestinationId - Rate destination id
+         * @param {string} rateDestinationStr - Rate destination name
+         * @param {number} rateDestinationCost - Rate destination cost / minute
+         * @param {number} callConnectFee - Call attempt/connect cost
+         * @param {number} effectiveCidId - Phone number id used as a-number for call
+         * @param {number} effectiveCidNumberStr - Phone number used as a-number for call
+         * @param {string} effectiveCidNameStr - Phone number name used as a-number for call
+         * @param {boolean} callPrivacy - Call privacy used for call (number hidden)
+         * @param {number} hangupCauseQ850 - Q.850 hangup cause code
+         * @param {Object[]} recordings - List of recordings done for this call
+         * @param {number} recordings[].startTime - Time recording was started
+         * @param {number} recordings[].length - Recording length in milliseconds
+         * @param {number} recordings[].size - Recording size (bytes)
+         * @param {number} recordings[].urlPlayer - URL for recording with player
+         * @param {number} recordings[].url - URL for recording without player
+         * @param {number} recordings[].retentionDate - Date recording will be automatically deleted
+         */
+
+        let e;
+        e = camelcaseKeys(eventData);
+        e.recordings = camelcaseKeys(eventData.recordings);
+
+        // Event all duration fields are in seconds, convert to millisecs
+        e.duration = e.duration * 1000;
+        e.answerDuration = e.answerDuration * 1000;
+        e.activeDuration = e.activeDuration * 1000;
+
+        // Add some extra convenience fields
+        e.durationStr = createDurationString(e.duration);
+        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : "";
+        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : "";
+        try {
+            this.emit("callDataInfo", e);
+        } catch (e) {
+            this.log.error("Exception in callDataInfo event: " + e);
+        }
+    }
+
+    // Check if we have media permission
+    _checkMediaPermission() {
+        // Check media is prepared
+        if (!this._mediaPermission) {
+            throw new MediaNotPrepared();
+        }
+    }
+}
+
+/** Session class created for every active call. You should use either call() or event incomingCall() to get new sessions
+ *
+ * @fires callEnded Receive basic information about call after call has been terminated
+ * @fires callDurationUpdate Regular updates on call duration (every second)
+ * @fires sessionStateChange Changes to session state
+ * @fires recordingStateChange When recording state changes
+ * @fires muteStateChange When mute state changes
+ * @fires holdStateChange When call is hold/unload
+ *
+ */
+class Session extends EventEmitter {
+    constructor(phone) {
+        super();
+
+        // Parent Phone object
+        this._phone = phone;
+
+        // Use log instance from phone object
+        this.log = phone.log;
+
+        this._callUUID = null;
+        this._webRTCSession = null;
+        this._sessionState = null;
+        this._iceCandidateTimer = null;
+        this._isOnHold = false;
+
+        // Audio device flags
+        this._isMuted = false;
+        this._isRecording = false;
+        this._recordingError = null;
+
+        // Call timers
+        this._callBeginTime = null;
+        this._callAnswerTime = null;
+        this._callEndTime = null;
+        this._durationUpdTimerObj = null;
+
+        // Call information
+        this._originatingNumber = null;
+        this._destinationNumber = null;
+        this._callDisposition = null;
+        this._localNumberName = null;
+        this._isListenCall = false;
+        this._whisperMode = null;
+        this._manualDisposition = null;
+
+        // Quality report
+        this._rtcpStatsTimer = null;
+        this._currentReport = null;
+
+        // Timeout
+        this._answerCallTimeout = 0;
+        this._answerCallTimer = null;
+
+        // Current media switch handling the call
+        this._mediaSwitch = null;
+    }
+
+    // Create a new outbound session
+    newOutboundSession(number, callParams) {
+        // First create a UUID
+        this._callUUID = createUUID();
+        this.log.debug(`Created new outbound session to: ${number} [${this._callUUID}]`);
+        this.destinationNumber = number;
+
+        let options = {
+            mediaConstraints: { audio: true, video: false },
+            pcConfig: {
+                iceServers: [{ urls: ["stun:stun.l.google.com:19302"] }],
+            },
+            extraHeaders: ["X-Call-token: " + this._phone.options.callToken, "X-P-UUID: " + this._callUUID, "X-Max-cost: " + callParams.maximumCallCost],
+        };
+
+        // Append explicit caller id if needed
+        if (callParams.explicitCallerId) {
+            options.extraHeaders.push("X-CID-Number-Id: " + callParams.explicitCallerId);
+        }
+
+        // Append explicit short cid if needed
+        if (callParams.explicitShortCallerId) {
+            options.extraHeaders.push("X-Short-CID-Id: " + callParams.explicitShortCallerId);
+        }
+
+        // Append meta info
+        if (callParams.metaInfo) {
+            options.extraHeaders.push("X-Meta-Info: " + encodeURI(callParams.metaInfo.toString().substr(0, 255)));
+        }
+
+        // Enable recording?
+        if (callParams.record) {
+            if (isNaN(callParams.record)) {
+                throw new InvalidParameter("Record parameter must be a number");
+            }
+            this.log.debug(`Recording enabled and kept for ${callParams.record} days`);
+            options.extraHeaders.push("X-Record: " + callParams.record);
+            this._isRecording = true;
+        } else {
+            this._isRecording = false;
+        }
+
+        // Store listen flag
+        this._isListenCall = callParams._isListenCall;
+
+        // Manually specified media switch
+        if (callParams.mediaSwitchURI) {
+            this.log.debug("Requesting specific media switch " + callParams.mediaSwitchURI);
+            options.extraHeaders.push("X-RMS: " + callParams.mediaSwitchURI);
+        } else {
+            // Request specific media switch to group calls on same server
+            const otherSessions = this.getOtherSessions();
+
+            if (otherSessions.length > 0) {
+                if (otherSessions[0]._mediaSwitch) {
+                    // There are existing active calls, append first media switch address found and request call grouping to this
+                    this.log.debug("Requesting call grouping on media switch " + otherSessions[0]._mediaSwitch);
+                    options.extraHeaders.push("X-RMS: sip:" + otherSessions[0]._mediaSwitch);
+                } else {
+                    this.log.warning("Other sessions exist but media switch address is invalid");
+                }
+            } else {
+                this.log.debug("No other active calls, no media switch grouping requested");
+            }
+        }
+
+        // Prepare invite uri
+        const uri = "sip:" + number + "@telegenta.com";
+
+        // Not start call and create sip session
+        try {
+            this._initWebRTCSession(this._phone._UA.call(uri, options));
+        } catch (error) {
+            this.log.error("Error starting call:", error);
+            return null;
+        }
+
+        if (callParams.answerCallTimeout) {
+            this._setAnswerCallTimeout(callParams.answerCallTimeout);
+        }
+    }
+
+    // Create new inbound session
+    newInboundSession(newSessionRequest) {
+        this._callUUID = newSessionRequest.request.getHeader("X-P-UUID", 0);
+        this._destinationNumber = newSessionRequest.request.getHeader("X-DID", 0);
+        this._localNumberName = unescape(newSessionRequest.request.getHeader("X-DID-NAME", 0));
+        this._originName = newSessionRequest.request.from.display_name;
+        this._originatingNumber = newSessionRequest.request.from.uri.user;
+        this.log.info(`Incoming call from ${this._originatingNumber} [${this._callUUID}]`);
+        this.log.debug(newSessionRequest);
+
+        // Get media switch info
+        this._mediaSwitch = newSessionRequest.request.getHeader("X-MS");
+        this.log.debug(`Media switch handling call: ${this._mediaSwitch}`);
+
+        this._initWebRTCSession(newSessionRequest.session);
+    }
+
+    /**
+     * Return a list of all sessions except this session
+     * Mostly used when transferring call
+     */
+    getOtherSessions() {
+        const allSessions = this._phone.sessions;
+
+        let s = [];
+        for (let key in allSessions) {
+            if (allSessions[key]) {
+                if (allSessions[key].__containerId !== this.__containerId) {
+                    s.push(allSessions[key]);
+                }
+            }
+        }
+
+        return s;
+    }
+
+    // Initialize with WebRTCSession object
+    _initWebRTCSession(webRTCSession) {
+        this._webRTCSession = webRTCSession;
+        this._callBeginTime = Date.now();
+
+        // Hookup events
+        const self = this;
+
+        // ICE CANDIDATES
+        this._webRTCSession.on("icecandidate", function (event) {
+            const c = event.candidate;
+            self.log.debug(`Got ICE candidate: ${c.candidate}`);
+            if (c.type === "srflx" && c.relatedAddress !== null && c.relatedPort !== null) {
+                self.log.info(`Accepting ICE candidate: ${c.candidate}`);
+
+                // Clear timer first
+                if (self._iceCandidateTimer != null) clearTimeout(self._iceCandidateTimer);
+
+                // Now fire ready
+                event.ready();
+            } else {
+                // Start timeout
+                if (self._iceCandidateTimer != null) clearTimeout(self._iceCandidateTimer);
+
+                self._iceCandidateTimer = setTimeout(
+                    function (data) {
+                        self.log.debug(`ICE Timeout (${self._phone.options.iceGatherTimeout} ms) reached`);
+                        data.ready();
+                    },
+                    self._phone.options.iceGatherTimeout,
+                    event,
+                );
+            }
+        });
+
+        this._webRTCSession.on("connecting", function (/* data */) {
+            self._startDurationUpdateTimer();
+            self._startRTCPStatsUpdateTimer();
+            self._setSessionState("INITIALIZING");
+        });
+
+        this._webRTCSession.on("sending", function (/* data */) {
+            // Play call initialized tone if needed
+            if (self._phone.options.playCallInitializedTone) {
+                self._phone._startRepeatTone(ST_CALLINIT);
+            }
+
+            self._setSessionState("CALLING");
+        });
+
+        this._webRTCSession.on("progress", function (data) {
+            if (data.originator === "remote") {
+                self._setSessionState("PROGRESS", { code: data.response.status_code });
+                self._phone._endRepeatTone();
+
+                // Ringback handling on 180 RINGING
+                if (data.response.status_code === 180) {
+                    self._phone._startRepeatTone(ST_RINGBACK);
+                }
+
+                // Also start answer call timeout
+                if (self._answerCallTimeout) {
+                    self._answerCallTimer = setTimeout(function () {
+                        self.log.info(`Answer call timeout after ${self._answerCallTimeout} seconds`);
+                        try {
+                            self.hangup();
+                        } catch (e) {
+                            self.log.info("No active session, ignoring answer call timeout");
+                        }
+                    }, self._answerCallTimeout * 1000);
+                }
+            }
+        });
+
+        this._webRTCSession.on("accepted", function (data) {
+            // Always end ringsback
+            self._phone._endRepeatTone();
+
+            self._callAnswerTime = Date.now();
+
+            // Call was answered, clear answer call timeout timer if needed
+            if (self._answerCallTimeout) {
+                clearTimeout(self._answerCallTimer);
+                self._answerCallTimeout = 0;
+            }
+
+            // Get initial recording state
+            if (data.originator === "remote") {
+                const recState = data.response.getHeader("X-Recording");
+                if (recState === "true") {
+                    self.log.debug("Call is being prerecorded");
+                    // self._isRecording = true;
+                    // self.emit('recordingStateChange', {state: true, error: null});
+                } else {
+                    self.log.debug("No call recording started yet");
+                }
+
+                // Get media switch info
+                self._mediaSwitch = data.response.getHeader("X-MS");
+                self.log.debug(`Media switch handling call: ${self._mediaSwitch}`);
+            }
+        });
+
+        this._webRTCSession.on("confirmed", function (/* data */) {
+            self._setSessionState("ACTIVE");
+        });
+
+        this._webRTCSession.on("ended", function (/* data */) {
+            // End any ringsbacks if needed
+            self._phone._endRepeatTone();
+
+            self._callEndTime = Date.now();
+
+            // Clear answer call timeout timer if needed
+            if (self._answerCallTimeout) {
+                clearTimeout(self._answerCallTimer);
+            }
+
+            self._setSessionState("TERMINATED");
+        });
+
+        this._webRTCSession.on("failed", function (data) {
+            // End any ringsbacks if needed
+            self._phone._endRepeatTone();
+
+            // self.log.error(data);
+            self._callEndTime = Date.now();
+
+            // Clear answer call timeout timer if needed
+            if (self._answerCallTimeout) {
+                clearTimeout(self._answerCallTimer);
+            }
+
+            let m;
+
+            // Append message if available
+            if (data.message) {
+                m = `${data.message.status_code} ${data.message.reason_phrase}`;
+            } else {
+                m = "";
+            }
+
+            self._setSessionState("FAILED", { cause: data.cause, message: m });
+        });
+
+        this._webRTCSession.on("dtmf", function (data) {
+            self.log.debug("Session DTMF", data);
+        });
+
+        this._webRTCSession.on("newInfo", function (data) {
+            self.log.debug("New session info", data);
+        });
+
+        this._webRTCSession.on("hold", function (/* data */) {
+            self._isOnHold = true;
+            self._fireHoldStateEvent();
+            self._setSessionState("ON_HOLD");
+        });
+
+        this._webRTCSession.on("unhold", function (/* data */) {
+            self._isOnHold = false;
+            self._fireHoldStateEvent();
+            self._setSessionState("ACTIVE");
+        });
+
+        this._webRTCSession.on("muted", function (data) {
+            self.log.debug("Microphone muted", data);
+            self._isMuted = true;
+            self._fireMuteStateEvent();
+        });
+
+        this._webRTCSession.on("unmuted", function (data) {
+            self.log.debug("Microphone unmuted", data);
+            self._isMuted = false;
+            self._fireMuteStateEvent();
+        });
+
+        this._webRTCSession.on("reinvite", function (data) {
+            self.log.debug("Session reinvite", data);
+        });
+
+        this._webRTCSession.on("update", function (data) {
+            self.log.debug("Session update", data);
+        });
+
+        this._webRTCSession.on("getusermediafailed", function (data) {
+            self.log.error("Getusermedia failed", data);
+        });
+
+        // If connection connect audio stream
+        if (self._webRTCSession.connection) {
+            self._handleRemoteAudio(self._webRTCSession);
+        }
+
+        // DEBUG STUFF
+        this.log.debug("WebRTCSession object:");
+        this.log.debug(this);
+    }
+
+    /**
+     * Hangup call
+     * @param {CALL_DISPOSITION} disposition - Hangup call with specific disposition
+     * @throws NoActiveSession - If no active session / call exists
+     */
+    hangup(disposition = null) {
+        if (!disposition) {
+            this.log.info("Hanging up call");
+            this._webRTCSession.terminate();
+        } else {
+            this.log.info(`Hanging up call with disposition ${disposition}`);
+            this._manualDisposition = disposition;
+            this._webRTCSession.terminate({
+                extraHeaders: ["X-HDISP: " + disposition],
+            });
+        }
+    }
+
+    /**
+     * Answer incoming call
+     * @param metaInfo - Add meta info to this call
+     */
+    answer(metaInfo = null) {
+        let options = {
+            mediaConstraints: { audio: true, video: false },
+            pcConfig: {
+                iceServers: [{ urls: ["stun:stun.l.google.com:19302"] }],
+            },
+            extraHeaders: ["X-Call-token: " + this._phone.options.callToken],
+        };
+
+        // Append meta info if needed
+        if (metaInfo) {
+            options.extraHeaders.push("X-Meta-Info: " + encodeURI(metaInfo.toString().substr(0, 255)));
+        }
+
+        this._webRTCSession.answer(options);
+
+        // After answer we start remote audio
+        this._handleRemoteAudio(this._webRTCSession);
+    }
+
+    /**
+     * Reject incoming call
+     * @param statusCode - SIP Status code
+     * @param reasonPhrase - Reason phrase
+     */
+    reject(statusCode = 603, reasonPhrase = "Rejected call") {
+        this.log.info("Rejecting call");
+        this._webRTCSession.terminate({
+            status_code: statusCode,
+            reason_phrase: reasonPhrase,
+        });
+    }
+
+    /**
+     * Return UUID of call
+     * @returns {string} UUID of call
+     */
+    get uuid() {
+        return this._callUUID;
+    }
+
+    /**
+     * Destination number called
+     * @returns {string} called number
+     */
+    get destinationNumber() {
+        return this._destinationNumber;
+    }
+
+    /**
+     * Name of local number (for inbound)
+     * @returns {string} Name of local number called
+     */
+    get localNumberName() {
+        return this._localNumberName;
+    }
+
+    /**
+     * Originating number
+     * @returns {string} Number of calling party
+     */
+    get originatingNumber() {
+        return this._originatingNumber;
+    }
+
+    // Set destination number
+    set destinationNumber(number) {
+        this.log.debug("Setting destination number to: " + number);
+        this._destinationNumber = number;
+    }
+
+    /**
+     * Session state
+     * @returns {SESSION_STATE} current session state
+     */
+    get state() {
+        return this._sessionState;
+    }
+
+    /**
+     * Session call direction
+     * @returns {CALL_DIRECTION} current session state
+     */
+    get direction() {
+        if (this._isListenCall) {
+            this.log.debug("Call direction is LISTEN");
+            return "LISTEN";
+        } else if (this._webRTCSession.direction === "incoming") {
+            this.log.debug("Call direction is INBOUND");
+            return "INBOUND";
+        } else if (this._webRTCSession.direction === "outgoing") {
+            this.log.debug("Call direction is OUTBOUND");
+            return "OUTBOUND";
+        } else {
+            this.log.error("Unknown call direction: " + this._webRTCSession.direction);
+            return "UNKNOWN";
+        }
+    }
+
+    // RECORDING
+    /**
+     * Start recording
+     */
+    startRecording() {
+        const opt = {
+            extraHeaders: ["Record: on"],
+        };
+
+        this.log.debug("Request start recording");
+
+        const self = this;
+        this._webRTCSession.once("newInfo", (data) => {
+            if (data.originator === "local") {
+                data.info.on("succeeded", function (/* data */) {
+                    self.log.info("Recording started successfully");
+                    self._isRecording = true;
+                    try {
+                        self.emit("recordingStateChange", { state: true, error: null });
+                    } catch (e) {
+                        self.log.error("Exception in recordingStateChange event: " + e);
+                    }
+                });
+
+                data.info.on("failed", function (data) {
+                    self._recordingError = data.response.reason_phrase;
+                    self.log.error("Recording start failed: " + self._recordingError);
+                    self._fireRecordingStateEvent();
+                });
+            }
+        });
+
+        this._webRTCSession.sendInfo("application/info", null, opt);
+    }
+
+    /**
+     * Stop recording
+     */
+    stopRecording() {
+        const opt = {
+            extraHeaders: ["Record: off"],
+        };
+
+        this.log.debug("Request stop recording");
+
+        const self = this;
+
+        this._webRTCSession.once("newInfo", (data) => {
+            data.info.on("succeeded", function (/* data */) {
+                self.log.info("Recording stopped successfully");
+                self._isRecording = false;
+                try {
+                    self.emit("recordingStateChange", { state: false, error: null });
+                } catch (e) {
+                    self.log.error("Exception in recordingStateChange event: " + e);
+                }
+            });
+
+            data.info.on("failed", function (data) {
+                self.log.error("Recording stopped failed: " + data.response.reason_phrase);
+                try {
+                    self.emit("recordingStateChange", { state: self._isRecording, error: data.response.reason_phrase });
+                } catch (e) {
+                    self.log.error("Exception in recordingStateChange event: " + e);
+                }
+            });
+        });
+
+        this._webRTCSession.sendInfo("application/info", null, opt);
+    }
+
+    /**
+     * Toogle recording ON/OFF
+     */
+    toggleRecording() {
+        if (!this._isRecording) {
+            this.startRecording();
+            return true;
+        } else {
+            this.stopRecording();
+            return false;
+        }
+    }
+
+    /**
+     * Return recording state
+     * @return {boolean}
+     */
+    get isRecording() {
+        return this._isRecording;
+    }
+
+    // MUTE
+    /**
+     * Mute microphone
+     */
+    muteMic() {
+        this.log.info("Mute microphone");
+        this._webRTCSession.mute();
+    }
+
+    /**
+     * Unmute microphone
+     */
+    unmuteMic() {
+        this.log.info("Unmute microphone");
+        this._webRTCSession.unmute();
+    }
+
+    /**
+     * Toggle microphone mute state
+     */
+    toggleMute() {
+        if (!this._isMuted) {
+            this.muteMic();
+        } else {
+            this.unmuteMic();
+        }
+    }
+
+    /**
+     * Return mute state
+     * @return {bool}
+     */
+    get isMuted() {
+        return this._isMuted;
+    }
+
+    // HOLD
+    /**
+     * Hold call
+     */
+    hold() {
+        this.log.info("Hold call");
+        this._webRTCSession.hold();
+    }
+
+    /**
+     * Unhold call
+     */
+    unhold() {
+        this.log.info("Uncall call");
+        this._phone.holdAllCalls();
+        this._webRTCSession.unhold();
+    }
+
+    /**
+     * Toggle call hold
+     */
+    toggleHold() {
+        if (!this._isOnHold) {
+            this.hold();
+        } else {
+            this.unhold();
+        }
+    }
+
+    /**
+     * Return call hold status
+     * @return {bool}
+     */
+    get isOnHold() {
+        return this._isOnHold;
+    }
+
+    /**
+     * Send DTMF tone on call
+     * @param code What DTMF code to send (valid: 0-9,*,#,d)
+     * @param playLocal=True Play DTMF sound locally also
+     * @throws InvalidParameter - On incorrect DTMF codes
+     */
+    sendDTMF(code, playLocal = true) {
+        // Check for correct DTMF and get frequencies
+        if (!(code in DTMF_FREQUENCY_TABLE)) {
+            throw new InvalidParameter("Invalid DTMF code");
+        }
+
+        this.log.info("Sending DTMF: " + code);
+        this._webRTCSession.sendDTMF(code);
+
+        if (playLocal) {
+            const f = DTMF_FREQUENCY_TABLE[code];
+
+            // First mute microphone before playing DTMF
+            if (this._isMuted) {
+                this.log.debug("Mic already muted, just sending DTMF");
+                this._phone.playTone(500, f[0], f[1]);
+            } else {
+                this.log.debug("Mute mic while sending DTMF");
+                this._webRTCSession.mute();
+
+                const self = this;
+                this._phone.playTone(500, f[0], f[1], function () {
+                    self.log.debug("Unmute mic after DTMF");
+                    self._webRTCSession.unmute();
+                });
+            }
+        }
+    }
+
+    /**
+     * Transfer call to another session (attended transfer)
+     *
+     * @param dstSession Destination session
+     */
+    transfer(dstSession) {
+        this.log.info(`Transferring ${this.uuid} => ${dstSession.uuid}`);
+
+        // Create ReferSubscriber event class
+        const referSubscriber = this._webRTCSession.refer(this._webRTCSession._request.ruri, { replaces: dstSession._webRTCSession });
+
+        const self = this;
+
+        // Setup some logging
+        referSubscriber.on("requestSucceeded", function () {
+            self.log.info("Transfer completed successfully");
+        });
+
+        referSubscriber.on("requestFailed", function (cause) {
+            self.log.error(`Transfer rejected: ${cause}`);
+        });
+
+        referSubscriber.on("failed", function (cause) {
+            self.log.error(`Transfer failed: ${cause}`);
+        });
+    }
+
+    /**
+     * Playback media file into call. You must be connected the event service to use this feature (set connectEventService=true)
+     *
+     * @param media_file_id Media file to playback
+     * @param hangup_after Hangup call after playback ends
+     *
+     * @throws NotAllowed - If event service is not enabled
+     *
+     * @return Promise that resolves when playback has started
+     */
+    playback(media_file_id, hangup_after = false) {
+        // Check event service is enabled first
+        if (!this._phone._options.connectEventService) {
+            throw new NotAllowed("Event service not enabled");
+        }
+
+        this.log.info(`Playback media file ${media_file_id} hangup after ${hangup_after}`);
+
+        const p = this._phone._eventClient.fireEvent("call_command", {
+            call_uuid: this.uuid,
+            call_command: "playback",
+            media_file_id: media_file_id,
+            hangup_after: hangup_after,
+        });
+
+        // When playback is acknowledged and 'hangup_after' is true, we set session state into PLAYBACK
+        if (hangup_after) {
+            // Stop remote audio
+            this._phone._remoteAudioElement.srcObject = null;
+
+            // Mute microphone
+            this._webRTCSession.mute();
+
+            // When playback starts set state to playback
+            p.then(() => {
+                // Set session state
+                this._setSessionState("PLAYBACK");
+            });
+        }
+
+        return p;
+    }
+
+    /**
+     * Set whisper mode on "listen" calls
+     *
+     * @param mode Whisper mode 0 = No whisper / 1 = local peer only / 2 = Three way (both local and remote)
+     *
+     * @throws NotAllowed - If call is not listen call
+     * @throws InvalidOptions - If invalid mode given
+     */
+    setWhisperMode(mode = 0) {
+        if (!this.direction === "LISTEN") {
+            throw new NotAllowed("Call is not correct type (listen)");
+        }
+
+        if (mode < 0 || mode > 2) {
+            throw new InvalidOptions("Invalid mode");
+        }
+
+        let t_dtmf_mode;
+
+        if (mode === 0) {
+            t_dtmf_mode = 0;
+        }
+
+        if (mode === 1) {
+            t_dtmf_mode = 2;
+        }
+
+        if (mode === 2) {
+            t_dtmf_mode = 3;
+        }
+
+        this.sendDTMF(t_dtmf_mode, false);
+        this._whisperMode = mode;
+        this._fireWhisperModeChangeEvent();
+    }
+
+    /*
+     * ======= PRIVATE METHODS PHONE SESSION =========================================================================
+     */
+
+    // Begin update timer events
+    _startDurationUpdateTimer() {
+        /**
+         * @event callDurationUpdate
+         * @type {object}
+         * @property {String} uuid - UUID of session
+         * @property {Date} beginTime - Time session was created
+         * @property {Date} answerTime - Time session was answered
+         * @property {Date} duration - The total duration of the session
+         * @property {String} durationStr - The duration of the session string formated (mm:ss)
+         * @property {Date} activeDuration - The active duration of the session
+         * @property {String} activeDurationStr - The active duration of the session string formated (mm:ss)
+         *
+         * @example
+         * // Update duration text on screen
+         * session.on('callDurationUpdate', function (event) {
+         *   document.getElementById('duration').textContent = event.durationStr;
+         * });
+         */
+
+        const self = this;
+        if (!this._durationUpdTimerObj) {
+            this._durationUpdTimerObj = setInterval(function () {
+                const activeDuration = self._callAnswerTime ? Date.now() - self._callAnswerTime : null;
+                const e = {
+                    uuid: self._callUUID,
+                    beginTime: self._callBeginTime,
+                    answerTime: self._callAnswerTime,
+                    endTime: self._callEndTime,
+                    duration: Date.now() - self._callBeginTime,
+                    durationStr: createDurationString(Date.now() - self._callBeginTime),
+                    activeDuration: activeDuration,
+                    activeDurationStr: activeDuration ? createDurationString(activeDuration) : "",
+                };
+
+                try {
+                    self.emit("callDurationUpdate", e);
+                } catch (e) {
+                    self.log.error("Exception in call duration update event: " + e);
+                }
+            }, 1000);
+        }
+    }
+
+    // Begin rtcp stats update timer events
+    _startRTCPStatsUpdateTimer() {
+        /**
+         * @event callQualityReportUpdate
+         * @description
+         * Contains information about call quality (fires in interval of 5 sec).
+         * Payload contains "total" (metrics for whole session) and "delta" (metrics last 5 secs).
+         *
+         * @type {object}
+         * @property {String} uuid - UUID of session
+         * @property {Number} outboundPacketsSent - Number of packets sent
+         * @property {Number} outboundBytesSent - Number of bytes sent
+         * @property {Number} outboundPacketsLost - Number of packets lost to remote
+         * @property {Number} outboundPacketLossPct - Percentage of outbound packets lost
+         * @property {Number} outboundJitter - Network jitter to remote (ms)
+         * @property {Number} inboundPacketsReceived - Number of packets received
+         * @property {Number} inboundBytesReceived - Number of bytes received
+         * @property {Number} inboundPacketsLost - Number of packets lost from remote
+         * @property {Number} inboundPacketLossPct - Percentage of inbound packets lost
+         * @property {Number} inboundJitter - Network jitter from remote (ms)
+         * @property {Number} roundTripTime - Latency in ms to media gateway
+         * @property {Number} effectiveLatency - Effective latency with combined jitter impact
+         * @property {Number} rFactor - Quality of media stream (0 - 100%)
+         * @property {Number} mos - Synthetic MOS
+         * @property {String} qualityString - Quality string [Excellent, Good, Fair, Poor, Bad]
+         *
+         * @example
+         * // Update call quality text on screen
+         * session.on('callQualityReportUpdate', (report) => {
+         *   document.getElementById('quality_text').textContent = report.delta.qualityString;
+         *   document.getElementById('latency').textContent = report.delta.effectiveLatency;
+         * });
+         */
+
+        if (!this._rtcpStatsTimer) {
+            const emptyReport = {
+                outboundPacketsSent: 0,
+                outboundBytesSent: 0,
+                outboundPacketsLost: 0,
+                outboundJitter: 0,
+                inboundPacketsReceived: 0,
+                inboundBytesReceived: 0,
+                inboundPacketsLost: 0,
+                inboundJitter: 0,
+                roundTripTime: 0,
+            };
+
+            // Initialize report first
+            this._currentReport = Object.assign({}, emptyReport);
+
+            this._rtcpStatsTimer = setInterval(() => {
+                this._webRTCSession._connection.getStats().then((data) => {
+                    let totalReport = Object.assign({}, emptyReport);
+                    let deltaReport = Object.assign({}, emptyReport);
+
+                    for (let report of data.values()) {
+                        // this.log.debug(report);
+                        switch (report.type) {
+                            case "outbound-rtp":
+                                // this.log.debug('Got: outbound-rtp');
+                                // this.log.debug(report);
+                                // Packets
+                                totalReport.outboundPacketsSent = report.packetsSent;
+                                deltaReport.outboundPacketsSent = report.packetsSent - this._currentReport.outboundPacketsSent;
+                                // Bytes
+                                totalReport.outboundBytesSent = report.bytesSent;
+                                deltaReport.outboundBytesSent = report.bytesSent - this._currentReport.outboundBytesSent;
+                                break;
+
+                            case "inbound-rtp":
+                                // this.log.debug('Got: inbound-rtp');
+                                // this.log.debug(report);
+                                // Packets
+                                totalReport.inboundPacketsReceived = report.packetsReceived;
+                                deltaReport.inboundPacketsReceived = report.packetsReceived - this._currentReport.inboundPacketsReceived;
+                                // Bytes
+                                totalReport.inboundBytesReceived = report.bytesReceived;
+                                deltaReport.inboundBytesReceived = report.bytesReceived - this._currentReport.inboundBytesReceived;
+                                // Loss
+                                totalReport.inboundPacketsLost = report.packetsLost;
+                                deltaReport.inboundPacketsLost = report.packetsLost - this._currentReport.inboundPacketsLost;
+                                // Jitter
+                                totalReport.inboundJitter = report.jitter * 1000;
+                                deltaReport.inboundJitter = report.jitter * 1000;
+                                break;
+
+                            case "remote-inbound-rtp":
+                                // this.log.debug('Got: remote-inbound-rtp');
+                                // this.log.debug(report);
+                                // Loss
+                                totalReport.outboundPacketsLost = report.packetsLost;
+                                deltaReport.outboundPacketsLost = report.packetsLost - this._currentReport.outboundPacketsLost;
+                                // Jitter
+                                totalReport.outboundJitter = report.jitter * 1000;
+                                deltaReport.outboundJitter = report.jitter * 1000;
+                                // RTT
+                                totalReport.roundTripTime = report.roundTripTime * 1000;
+                                deltaReport.roundTripTime = report.roundTripTime * 1000;
+                                break;
+                        }
+                    }
+
+                    this._currentReport = this._calcReportMetrics(totalReport);
+
+                    // We have to wait for RTT before firing the first event
+                    if (totalReport.roundTripTime) {
+                        // Do current report metrics
+                        const finalReport = {
+                            total: this._currentReport,
+                            delta: this._calcReportMetrics(deltaReport),
+                        };
+
+                        try {
+                            this.emit("callQualityReportUpdate", finalReport);
+                        } catch (e) {
+                            this.log.error("Exception in call quality report update event: " + e);
+                        }
+                    }
+                });
+            }, 5000);
+        }
+    }
+
+    // Return quality string based on R-factor
+    _calcReportMetrics(report) {
+        // Packet loss
+        report.outboundPacketLossPct = report.outboundPacketsLost / report.outboundPacketsSent;
+        report.inboundPacketLossPct = report.inboundPacketsLost / report.inboundPacketsReceived;
+
+        // Effective latency
+        report.effectiveLatency = report.roundTripTime + (report.inboundJitter + report.outboundJitter) + 10;
+
+        // R-Factor and mos
+        const lossRate = (report.outboundPacketLossPct + report.inboundPacketLossPct) * 100;
+        const lossEffect = (95.0 * lossRate) / (lossRate + 10);
+        const latencyEffect = report.effectiveLatency * 0.1;
+        // this.log.debug(`R factor loss effect ${lossEffect} / latency effect ${latencyEffect}`);
+
+        report.rFactor = Math.max(0, 100 - lossEffect - latencyEffect);
+        report.mos = 1 + 0.035 * report.rFactor + 0.000007 * report.rFactor * (report.rFactor - 60) * (100 - report.rFactor);
+
+        // Quality string
+        switch (true) {
+            case report.rFactor < 50:
+                report.qualityString = "Bad";
+                break;
+            case report.rFactor < 70:
+                report.qualityString = "Poor";
+                break;
+            case report.rFactor < 80:
+                report.qualityString = "Fair";
+                break;
+            case report.rFactor < 90:
+                report.qualityString = "Good";
+                break;
+            case report.rFactor <= 100:
+                report.qualityString = "Excellent";
+                break;
+            default:
+                report.qualityString = "Error";
+        }
+
+        return report;
+    }
+
+    /**
+     * @typedef SESSION_STATE {string}
+     * @property {string} INITIALIZING Session is initializing (Gather ICE candidates)
+     * @property {string} CALLING Sending INVITE to server
+     * @property {string} PROGRESS Call progress received ('event.code' has new progress status)
+     * @property {string} ACTIVE Call is active (answered)
+     * @property {string} TERMINATED Call ended
+     * @property {string} FAILED Call failed (see 'event.cause' for more info)
+     * @property {string} ON_HOLD Call is on-hold
+     * @property {string} INCOMING Incoming call is waiting
+     * @property {string} PLAYBACK Playback with pending hangup in progress
+     */
+
+    // Set session state and emit event
+    _setSessionState(state, info = null) {
+        /**
+         * @event sessionStateChange
+         * @type {object}
+         * @param {SESSION_STATE} state - The current session state
+         * @param {uuid} uuid - Call UUID for session
+         * @param {string} originName - Originating name of call [INCOMING only]
+         * @param {string} originatingNumber - Originating phone number of call [INCOMING only]
+         * @param {string} destinationNumber - Destination number of call
+         * @param {string} cause - Fail cause [FAILED only]
+         * @param {string} message - Fail message description [FAILED only]
+         *
+         */
+
+        this.log.debug("Session state: " + state);
+        if (info) {
+            this.log.debug(info);
+        }
+
+        this._sessionState = state;
+        try {
+            this.emit(
+                "sessionStateChange",
+                Object.assign(
+                    {
+                        state: state,
+                        uuid: this._callUUID,
+                    },
+                    info,
+                ),
+            );
+        } catch (e) {
+            this.log.error("Exception in sessionStateChange event:" + e);
+        }
+
+        // Trigger callDataAvailable dummy event
+        if (state === "TERMINATED") {
+            this._callDisposition = this._manualDisposition || "NORMAL";
+            this._callFinished();
+        }
+
+        if (state === "FAILED") {
+            if (info.cause === "Unavailable") {
+                this._callDisposition = "TEMP_UNAVAIL";
+                if (this._phone.options.playSignalTones) {
+                    this._phone._startRepeatTone(ST_TEMP_UNAVAIL);
+                }
+            }
+
+            if (info.cause === "Not Found") {
+                this._callDisposition = "INVALID_NUMBER";
+                if (this._phone.options.playSignalTones) {
+                    this._phone._startRepeatTone(ST_INVALID_NUMBER);
+                }
+            }
+
+            if (info.cause === "Canceled") {
+                this._callDisposition = this._manualDisposition || "NO_ANSWER";
+            }
+
+            if (info.cause === "Rejected") {
+                if (this.direction === "INBOUND") {
+                    this._callDisposition = "REJECTED";
+                } else {
+                    this._callDisposition = "BARRED";
+                }
+            }
+
+            if (info.cause === "Busy") {
+                this._callDisposition = "BUSY";
+                if (this._phone.options.playSignalTones) {
+                    this._phone._startRepeatTone(ST_BUSY);
+                }
+            }
+
+            // If session is incoming and failed, we don't fire calldataAvailable event
+            if (this._webRTCSession.direction === "incoming") ;
+
+            this._callFinished();
+        }
+    }
+
+    /**
+     * @typedef {string} CALL_DIRECTION
+     * @property {string} INBOUND Incoming call
+     * @property {string} OUTBOUND Outgoing call
+     * @property {string} TRANSFER Transferred call
+     * @property {string} LOCAL Local call
+     * @property {string} AUTOMATED Call triggered from api / server
+     * @property {string} LISTEN Listen call
+     */
+
+    /**
+     * @typedef {string} CALL_DISPOSITION
+     * @property {string} BUSY Number was busy
+     * @property {string} INVALID_NUMBER Number call does not exist
+     * @property {string} NO_ANSWER Call was not picked up before cancelling
+     * @property {string} TEMP_UNAVAIL Remote is temporarily unavailable
+     * @property {string} NORMAL Call was terminated normally
+     * @property {string} FAILED There was a failure connecting the call
+     * @property {string} BARRED Call was prohibited by server
+     * @property {string} REJECTED Incoming call was rejected
+     */
+    _callFinished() {
+        this.log.info("Call finished");
+
+        // Fire callEnded event
+        this._fireCallEndedEvent();
+
+        // Stop duration update timer
+        clearInterval(this._durationUpdTimerObj);
+
+        // Stop rtcp stats uptime timer
+        clearInterval(this._rtcpStatsTimer);
+
+        // Remove session from active sessions
+        this._phone._sessionTerminated(this);
+    }
+
+    // Set answer call timeout
+    _setAnswerCallTimeout(timeout) {
+        this.log.debug("Setting answer call timeout to: " + timeout);
+        this._answerCallTimeout = timeout;
+    }
+
+    // Fire recording state event
+    _fireRecordingStateEvent() {
+        /**
+         * @event recordingStateChange
+         * @type {object}
+         * @property {boolean} state - New recording state
+         */
+        try {
+            this.emit("recordingStateChange", { state: this._isRecording, error: this._recordingError });
+        } catch (e) {
+            this.log.error("Exception in recording state change event: " + e);
+        }
+    }
+
+    // Fire mic mute state event
+    _fireMuteStateEvent() {
+        /**
+         * @event muteStateChange
+         * @type {object}
+         * @property {boolean} state - Mute state (true = muted / false = unmuted)
+         */
+        try {
+            this.emit("muteStateChange", { state: this._isMuted });
+        } catch (e) {
+            this.log.error("Exception in mute state change event: " + e);
+        }
+    }
+
+    // Fire recording state event
+    _fireHoldStateEvent() {
+        /**
+         * @event holdStateChange
+         * @type {object}
+         * @property {boolean} state - New hold state
+         */
+        try {
+            this.emit("holdStateChange", { state: this._isOnHold });
+        } catch (e) {
+            this.log.error("Exception in hold state change event: " + e);
+        }
+    }
+
+    // Fire whisper mode event
+    _fireWhisperModeChangeEvent() {
+        /**
+         * @event whisperModeChange
+         * @type {object}
+         * @property {boolean} mode - New whisper mode (0 = No whisper / 1 = Local only / 2 = Three way)
+         */
+        try {
+            this.emit("whisperModeChange", { mode: this._whisperMode });
+        } catch (e) {
+            this.log.error("Exception in whisper mode change event: " + e);
+        }
+    }
+
+    // Fire call data event to subscribers
+    _fireCallEndedEvent() {
+        /**
+         * @event callEnded
+         *
+         * @type {object}
+         * @property {uuid} uuid - Customer Call UUID for session
+         * @param {CALL_DIRECTION} direction - Call direction
+         * @param {CALL_DISPOSITION} disposition - The final call disposition
+         * @param {string} originatingNumber - Caller ID number (a-number) used for call
+         * @param {string} destinationNumber - Destination number (b-number) used for call
+         * @param {Date} startTime - Start time of call
+         * @param {Date} answerTime - Time call was answered
+         * @param {Date} endTime - End time of call
+         * @param {number} duration - Total duration of the call (including call setup and remote answer time) (millisec)
+         * @param {String} durationStr - Total duration of the call formatted as (mm:ss)
+         * @param {Number} answerDuration - Time before call was answered (millisec)
+         * @param {String} answerDurationStr - Time before call was answered formatted as (mm:ss)
+         * @param {Number} activeDuration - Active duration of the call (time spend talking) (millisec)
+         * @param {String} activeDurationStr - Active duration of the call formatted as (mm:ss)
+         * @param {object} callQualityReport - Call quality report (see callQualityReportUpdate event for details)
+         */
+
+        let e;
+
+        e = {
+            uuid: this._callUUID,
+            direction: this.direction,
+            disposition: this._callDisposition,
+            originatingNumber: this._originatingNumber,
+            destinationNumber: this._destinationNumber,
+
+            // Calc durations
+            duration: this._callEndTime - this._callBeginTime,
+            answerDuration: this._callAnswerTime ? this._callAnswerTime - this._callBeginTime : null,
+            activeDuration: this._callAnswerTime ? this._callEndTime - this._callAnswerTime : null,
+
+            // Convert timestamp into ISO8601
+            startTime: new Date(this._callBeginTime).toISOString(),
+            endTime: new Date(this._callEndTime).toISOString(),
+            answerTime: this._callAnswerTime ? new Date(this._callAnswerTime).toISOString() : null,
+        };
+
+        // Add some extra convenience fields
+        e.durationStr = createDurationString(e.duration);
+        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : "";
+        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : "";
+        e.callQualityReport = this._currentReport;
+
+        try {
+            this.emit("callEnded", e);
+        } catch (e) {
+            this.log.error("Exception in callEnded event: " + e);
+        }
+    }
+
+    // Setup handling of remote audio
+    _handleRemoteAudio(session) {
+        // Stop any repeating tones if audio comes
+        this._phone._endRepeatTone();
+
+        const self = this;
+        session.connection.ontrack = function (event) {
+            self.log.debug("Start media output (track):");
+            self.log.debug(event);
+            self._phone._remoteAudioElement.srcObject = event.streams[0];
+        };
+    }
+}
+
+export { EventClient, InvalidMediaDevice, InvalidOptions, InvalidParameter, LOGLVL$1 as LOGLVL, LogHandler, MediaNotPrepared, NoActiveSession, NotAllowed, NotReady, Phone, Request, Requestor, Session, UnableToConnect, browserIsChrome, browserIsEdge, browserIsFirefox, browserIsOpera, browserIsSafari, compareObjects, createDurationString, createUUID };