@telegenta/webclient 3.1.1 → 3.2.0

package/README.md

@@ -39,63 +39,49 @@ and you are ready to go. The client has no external requirements (like jQuery an
 
 Before starting, you will need an account on telegenta.com, to create sip accounts and api tokens.
 
-#### Example 1: Simple phone with static account
+Runnable examples live in `demos/`. They load the browser bundle from `../dist/telegenta.min.js`, so
+run `npm run build` first, then serve the directory over https. WebRTC requires a secure context;
+`localhost` counts as secure, but opening a demo as `file://...` does not - media permissions are not
+remembered there, so you will be prompted for the microphone every time.
 
-In this example we will use a normal SIP User account, as it does not require you to use our API service.
+#### Example: phone with a provisioning token
 
-Log into the administration frontend (https://admin.telegenta.com) and create a "SIP User account", this will provide
-you with credentials (username and password). Once you have these open the embedded html client provided with this
-library /embedded_client/index.html and modify the credentials:
+`demos/phone_client.html` is a complete softphone - start/stop, outbound calls, transfer, listen-in,
+incoming calls and the event client.
 
-```
-// SIP account username and password
-var USERNAME='your username';
-var PASSWORD='your password';
-
-window.onload = function () {
-...
-```
+First create a static API token in the admin interface
+(https://admin.telegenta.com/integration/access-tokens). Open the demo and paste the token in; it then
 
-Now open the file (index.html) in your browser. After you have been prompted for permission to use the audio devices,
-you should have a working phone.
-Note: If you are viewing a file using "file://index.html", it is not considered a secure connection by the browser
-and media permissions are not remembered, so you will be prompted every time you open the file.
-However, once you move the file to a secure webserver (https), this will no longer be an issue.
+1. requests a short-lived provisioning token with `GET /api/get-call-session/?id=<account id>`, and
+2. starts the phone with that token:
 
-#### Example 2: Using SIP Flex accounts
-
-When using SIP flex accounts, you need to use our API service to retrieve account information first.
-This approach solves the authentication problem and provides you with short-lived sip accounts used in client sessions.
-For this example we need a backend service and we provide a simple example in PHP using the built in Webserver.
+```
+const opts = {
+    // Enable event client
+    connectEventService: true,
 
-First go to the admin interface and create following 2 items:
+    // Subscribe to detailed information about call after processing
+    useCallDataInfoEvent: true,
 
-1. SIP Flex account with "flex account identification" set to 'test'
-2. A static api token (https://admin.telegenta.com/integration/access-tokens).
+    // Enable incoming calls (you must set a phone number to call the account also)
+    register: true,
 
-Now open the file /embedded_client/server.html and insert the API token at the top of the file:
+    // Configure client with provision token
+    provisionToken: data.provision_token,
+};
 
+phoneClient.start(opts);
 ```
-// Your API Token
-$api_auth_token = '<your api token>';
 
-// The flex account identification (this is set when configuring your flex accounts)
-// It possible to have multiple sip flex accounts with different configurations
-$flex_identification = 'test';
-...
-```
+Issuing the provisioning token from your own backend is the recommended integration: the short-lived
+token is all that reaches the browser, and your API token stays on the server.
 
-Once you have added the token, you can start the php Webserver (requires php v5.4+) like this:
+The remaining demos cover narrower cases:
 
-```
-cd embedded_client
-php -S localhost:9000
-```
-
-Now open the URL http://localhost:9000/server.php and you should see the phone and be able to perform calls.
-Note: If you use any other host than localhost, you won't be able to call because the built in php webserver does not
-support secure (https) connections and this is required by the browser to use WebRTC. If needed, you can tunnel to
-localhost using your ssh client for testing.
+- `demos/event_client.html` - the event client on its own, without a phone
+- `demos/calldata_available.html` - subscribing to call data after a call completes
+- `demos/add_phone_number.html` - adding a phone number through the API
+- `demos/embedded_config.html` - embedding the admin config pages with a config token
 
 ## Approaching the integration
 
@@ -106,15 +92,10 @@ Depending on how much flexibility you need, you can choose between the following
     We believe in using standard protocols as much as possible and it will work nicely, but you need to address most
     of the issues we listed above in the previous section yourself.
 
-2.  Use our free library (lib/telegenta.min.js) and provide your own frontend
-    This way you just need to handle events and use javascript methods like call, hangup, startRecord, etc..
-
-3.  Use our complete embedded phone client with frontend.
-    We have made a simple phone with frontend, which can be easily included in your own project. Just grab the
-    index.html, style.css and embedded_phone.js and insert it into your own project.
-    We named the JS and CSS to try and avoid any potential conflicts.
-    You only need to provide it with credentials or provisioning token (as in the example above) from you backend and
-    you are set to start calling.
+2.  Use our free library and provide your own frontend.
+    Load `dist/telegenta.min.js` in the browser (global `Telegenta`) or import the package in your
+    bundler, then handle events and use javascript methods like call, hangup, startRecord, etc..
+    `demos/phone_client.html` shows the whole flow end to end.
 
 ## Migrating from 2.x
 
@@ -161,6 +142,33 @@ If you are migrating from 1.7.x release into 2.x, some code breaking changes nee
 
 This library uses the JsSIP library (www.jssip.net) created by José Luis Milàn, Iñaki Baz Castillo and Saúl Ibarra Corretgé
 
+## Changelog
+
+3.2.0
+- Phone.setCallToken(token): replace the call token without restarting (tokens expire after 30 min).
+  With useCallDataInfoEvent, the callDataInfo subscription keeps the token from start(); call
+  start() again to move it to the new token.
+- Phone.prepareMedia({ deviceId }) and Phone.setInputDevice(deviceId): microphone selection
+- Phone.prepareMedia() without a deviceId resets a microphone previously chosen with setInputDevice()
+- Phone.setOutputDevice(deviceId) and Phone.outputDeviceSelectionSupported: speaker selection
+- prepareMedia() releases the microphone after the permission probe
+- Phone.resumeAudio(): resumes the signal-tone AudioContext; call it from a user-gesture handler,
+  since a phone started on page load gets a "suspended" context and plays no tones. Tones also
+  try to resume it themselves. One AudioContext per Phone is now reused across start()/stop()
+  (previously every start() created a new one that was never closed)
+- prepareMedia() now rejects instead of throwing synchronously, and a failed request no longer
+  changes the selected microphone or media-permission state unless the browser actually denied
+  permission (NotAllowedError/SecurityError)
+- start() no longer mutates the shared default options between Phone instances
+- stop() now always marks the phone stopped
+- Phone.register(): re-sends REGISTER without restarting the phone or dropping active calls
+  (throws NotReady if not started) - for recovering a REGISTER refresh that failed for a reason
+  other than bad credentials, which JsSIP does not retry on its own
+- connectionStateChange now carries `cause` and `statusCode` alongside `state` when
+  state is REGISTRATION_FAILED (from JsSIP's registrationFailed event), so callers can tell a
+  transient network failure (JsSIP retries on its own) apart from an authentication/authorization
+  failure (401/403) that needs a fresh call session
+
 #### License
 
 This software is provided for free together with our service

package/dist/telegenta.js

@@ -25,23 +25,23 @@ class LogHandler {
     }
 
     debug(...args) {
-        this._doLog(LOGLVL$1.DEBUG, args);
+        this._doLog(LOGLVL.DEBUG, args);
     }
 
     info(...args) {
-        this._doLog(LOGLVL$1.INFO, args);
+        this._doLog(LOGLVL.INFO, args);
     }
 
     warn(...args) {
-        this._doLog(LOGLVL$1.WARN, args);
+        this._doLog(LOGLVL.WARN, args);
     }
 
     warning(...args) {
-        this._doLog(LOGLVL$1.WARN, args);
+        this._doLog(LOGLVL.WARN, args);
     }
 
     error(...args) {
-        this._doLog(LOGLVL$1.ERROR, args);
+        this._doLog(LOGLVL.ERROR, args);
     }
 
     _doLog(level, args) {
@@ -60,19 +60,19 @@ class LogHandler {
             this.extHandler(LOGLVLSTR[level], args);
         } else {
             switch (level) {
-                case LOGLVL$1.DEBUG:
+                case LOGLVL.DEBUG:
                     console.debug(args);
                     break;
 
-                case LOGLVL$1.INFO:
+                case LOGLVL.INFO:
                     console.info(args);
                     break;
 
-                case LOGLVL$1.WARN:
+                case LOGLVL.WARN:
                     console.warn(args);
                     break;
 
-                case LOGLVL$1.ERROR:
+                case LOGLVL.ERROR:
                     console.error(args);
                     break;
 
@@ -91,7 +91,7 @@ class LogHandler {
  * @property {number} INFO 2 Informational messages (default)
  * @property {number} DEBUG 3 Debug messages
  */
-const LOGLVL$1 = {
+const LOGLVL = {
     DEBUG: 3,
     INFO: 2,
     WARN: 1,
@@ -386,7 +386,7 @@ class Request {
 class Requestor extends EventEmitter {
     constructor(logger = null) {
         super();
-        this.log = logger ? logger : new LogHandler(LOGLVL$1.INFO);
+        this.log = logger ? logger : new LogHandler(LOGLVL.INFO);
         this._pendingRequests = [];
     }
 
@@ -401,13 +401,13 @@ class Requestor extends EventEmitter {
         let msg;
         try {
             msg = JSON.parse(message);
-        } catch (err) {
+        } catch {
             this.log.warning("Unable to parse message: " + message);
             return;
         }
 
         // Validate msg fields
-        if (!msg.hasOwnProperty("type") || !msg.hasOwnProperty("id")) {
+        if (!Object.hasOwn(msg, "type") || !Object.hasOwn(msg, "id")) {
             this.log.warning(`Invalid message received: ${msg} - missing type or id`);
             return;
         }
@@ -658,7 +658,7 @@ class EventClient {
             throw new InvalidParameter('You must specify both event spec and callback function');
         }
 
-        if (!eventSpecification.hasOwnProperty('event_name')) {
+        if (!Object.hasOwn(eventSpecification, 'event_name')) {
             throw new InvalidParameter('Your event specification must contain event name');
         }
 
@@ -1643,6 +1643,9 @@ class Phone extends EventEmitter {
         this._eventClient = null;
         this._options = null;
 
+        // getUserMedia audio constraint: true (default device) or { deviceId: { exact } }
+        this._audioConstraints = true;
+
         // List of active sessions
         this._sessionCounter = 0;
         this._activeSessions = {};
@@ -1658,15 +1661,16 @@ class Phone extends EventEmitter {
         this._repeatToneActive = false;
         this._repeatToneSequence = [];
         this._repeatToneSequencePos = 0;
+        this._toneContext = null;
         this._toneGainProcessor = null;
         this._oscillator1 = null;
         this._oscillator2 = null;
 
         // Set default logger
-        this.log = logger ? logger : new LogHandler(LOGLVL$1.INFO);
+        this.log = logger ? logger : new LogHandler(LOGLVL.INFO);
 
         // Handle jssip debug logs
-        if (this.log.level === LOGLVL$1.DEBUG) {
+        if (this.log.level === LOGLVL.DEBUG) {
             JsSIP.debug.disable('JsSIP:*');
         } else {
             JsSIP.debug.disable('JsSIP:*');
@@ -1677,29 +1681,83 @@ class Phone extends EventEmitter {
      * 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
+     * On failure the previously selected input device (see {@link setInputDevice}) and the
+     * current media-permission state are left untouched, unless the browser reports the
+     * request was actually denied (NotAllowedError / SecurityError), in which case
+     * hasMediaPermission/hasMediaPermissionError are updated to reflect that.
      *
-     */
-    prepareMedia() {
+     * @param {object} [mediaOptions]
+     * @param {string} [mediaOptions.deviceId] Microphone deviceId (from enumerateDevices); omit or leave
+     *   out to select the browser default device, which also resets a device previously chosen with
+     *   {@link setInputDevice}
+     * @return {Promise} Resolved when user accepts access to media devices; rejected (never thrown
+     *   synchronously) otherwise, e.g. when the browser denies permission or has no mediaDevices API
+     */
+    async prepareMedia(mediaOptions = {}) {
         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);
-                },
-            );
-        });
+        const deviceId = (mediaOptions || {}).deviceId || null;
+        const audioConstraints = deviceId ? { deviceId: { exact: deviceId } } : true;
+        const constraints = { audio: audioConstraints, video: false };
+
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia(constraints);
+            // Only the permission is needed here; release the device again.
+            stream.getTracks().forEach((track) => track.stop());
+            this.setInputDevice(deviceId);
+            this._mediaPermission = true;
+            this._mediaPermissionError = false;
+            this.log.info('Media permission granted');
+        } catch (err) {
+            if (err && (err.name === 'NotAllowedError' || err.name === 'SecurityError')) {
+                this._mediaPermission = false;
+                this._mediaPermissionError = true;
+                this.log.error('Denied media permission: ' + err);
+            } else {
+                this.log.error('Unable to get requested media device: ' + err);
+            }
+            throw err;
+        }
+    }
+
+    /**
+     * Select the microphone used for subsequent calls and answers.
+     * @param {string|null} deviceId Microphone deviceId, or null for the browser default
+     */
+    setInputDevice(deviceId) {
+        this._audioConstraints = deviceId ? { deviceId: { exact: deviceId } } : true;
+    }
+
+    /**
+     * Current getUserMedia audio constraint (true = default device)
+     */
+    get audioConstraints() {
+        return this._audioConstraints;
+    }
+
+    /**
+     * True when the browser can route audio to a chosen output device (HTMLMediaElement.setSinkId)
+     */
+    get outputDeviceSelectionSupported() {
+        return typeof this._remoteAudioElement.setSinkId === 'function';
+    }
+
+    /**
+     * Route call audio and signal tones to an output device.
+     * @param {string|null} deviceId Output deviceId (from enumerateDevices), or null for the default
+     * @return {Promise<boolean>} false when the browser does not support output selection
+     * @throws Rejects if the browser's HTMLMediaElement.setSinkId() call rejects, e.g. for an
+     *   unknown deviceId or one the browser is not allowed to use (NotAllowedError)
+     */
+    async setOutputDevice(deviceId) {
+        if (!this.outputDeviceSelectionSupported) {
+            return false;
+        }
+        const sinkId = deviceId || '';
+        await Promise.all([
+            this._remoteAudioElement.setSinkId(sinkId),
+            this._toneAudioElement.setSinkId(sinkId),
+        ]);
+        return true;
     }
 
     /**
@@ -1735,16 +1793,16 @@ class Phone extends EventEmitter {
         }
 
         // Apply options
-        this._options = Object.assign(options, phoneOptions);
+        this._options = Object.assign({}, options, phoneOptions);
 
         this._initToneGenerator();
 
         // Unpack provisioning token if specified
         if (this._options.provisionToken) {
-            let pt = null;
+            let pt;
             try {
                 pt = JSON.parse(atob(this._options.provisionToken));
-            } catch (err) {
+            } catch {
                 throw new InvalidOptions('provisionToken', 'Invalid token');
             }
 
@@ -1820,7 +1878,7 @@ class Phone extends EventEmitter {
             );
         }
 
-        let wsSocket = null;
+        let wsSocket;
         try {
             wsSocket = new JsSIP.WebSocketInterface(this._options.wssServer);
         } catch (err) {
@@ -1898,8 +1956,11 @@ class Phone extends EventEmitter {
             self._setConnectionState('UNREGISTERED');
         });
 
-        this._UA.on('registrationFailed', function (/* data */) {
-            self._setConnectionState('REGISTRATION_FAILED');
+        this._UA.on('registrationFailed', function (data) {
+            self._setConnectionState('REGISTRATION_FAILED', {
+                cause: data?.cause,
+                statusCode: data?.response?.status_code,
+            });
         });
 
         this._UA.start();
@@ -1924,6 +1985,11 @@ class Phone extends EventEmitter {
         this._UA.stop();
         delete this._UA;
 
+        // Always mark the phone stopped from here on, even if there is no event client to
+        // disconnect below - otherwise isStarted stays true and a later start() would try to
+        // stop() this same (already torn down) instance again.
+        this._isStarted = false;
+
         // Disconnect event client if needed
         if (!this._eventClient) {
             this.log.debug('Event client not running, not stopping');
@@ -1932,14 +1998,26 @@ class Phone extends EventEmitter {
         try {
             this._eventClient.disconnect();
             delete this._eventClient;
-        } catch (e) {
+        } catch {
             this.log.warning('Unable to disconnect event client');
         }
-
-        this._isStarted = false;
         this.log.info('Phone client successfully stopped');
     }
 
+    /**
+     * Re-send REGISTER without tearing down the websocket connection or any active calls.
+     * Use this to recover from a REGISTER refresh that failed for a reason other than bad
+     * credentials (e.g. a timeout or a 5xx from the registrar) while the transport itself stayed
+     * up - JsSIP does not retry those on its own. Safe to call during an active call.
+     * @throws NotReady - If phone is not started
+     */
+    register() {
+        if (!this._isStarted) {
+            throw new NotReady('Phone is not started');
+        }
+        this._UA.register();
+    }
+
     /**
      * Start a new call
      * If you have other active calls they will be set on hold
@@ -2023,7 +2101,7 @@ class Phone extends EventEmitter {
      */
     getSessionByUUID(uuid) {
         for (let key in this._activeSessions) {
-            if (this._activeSessions.hasOwnProperty(key)) {
+            if (Object.hasOwn(this._activeSessions, key)) {
                 if (this._activeSessions[key].uuid === uuid) {
                     return this._activeSessions[key];
                 }
@@ -2041,6 +2119,27 @@ class Phone extends EventEmitter {
         return this._options;
     }
 
+    /**
+     * Replace the call token used by subsequent calls and answers.
+     * Call tokens expire (30 min); renew via the API and pass the new token here.
+     *
+     * With useCallDataInfoEvent, the callDataInfo subscription keeps the token from start();
+     * call start() again to move it to the new token.
+     *
+     * @param {string} token New call token
+     * @throws NotReady - If phone is not started
+     * @throws InvalidOptions - If token is empty
+     */
+    setCallToken(token) {
+        if (!this._isStarted) {
+            throw new NotReady('Phone is not started');
+        }
+        if (!token) {
+            throw new InvalidOptions('callToken', 'Missing call token');
+        }
+        this._options.callToken = token;
+    }
+
     /**
      * Return list of current sessions
      * @returns [Session]
@@ -2048,7 +2147,7 @@ class Phone extends EventEmitter {
     get sessions() {
         let s = [];
         for (let key in this._activeSessions) {
-            if (this._activeSessions.hasOwnProperty(key)) {
+            if (Object.hasOwn(this._activeSessions, key)) {
                 s.push(this._activeSessions[key]);
             }
         }
@@ -2106,6 +2205,7 @@ class Phone extends EventEmitter {
      */
     playTone(duration, freq1, freq2 = 0, callback = null) {
         this.log.debug(`Playing tone ${freq1} / ${freq2} for ${duration} ms`);
+        this._resumeToneContext();
 
         this._oscillator1.frequency.value = freq1;
         this._oscillator2.frequency.value = freq2;
@@ -2172,8 +2272,35 @@ class Phone extends EventEmitter {
         }
     }
 
-    // Initialize tone generator
+    /**
+     * Resume the Web Audio context behind signal tones (ringing, ringback, busy, DTMF feedback).
+     * Browsers create an AudioContext "suspended" when it is not created during a user gesture
+     * (e.g. a phone started on page load); call this from a user-gesture handler (click, keydown)
+     * so tones are audible. Safe to call before {@link start} and any number of times.
+     * @return {Promise<boolean>} false when the browser has no Web Audio API or resuming failed
+     */
+    async resumeAudio() {
+        try {
+            this._initToneGenerator();
+        } catch {
+            return false;
+        }
+        try {
+            await this._toneContext.resume();
+            return this._toneContext.state === 'running';
+        } catch (err) {
+            this.log.warning('Unable to resume audio context: ' + err);
+            return false;
+        }
+    }
+
+    // Initialize tone generator. One AudioContext per Phone, reused across start()/stop() -
+    // browsers cap the number of live contexts and a new one per start() would leak.
     _initToneGenerator() {
+        if (this._toneContext && this._toneContext.state !== 'closed') {
+            return;
+        }
+
         // Create audio context
         const AudioContext = window.AudioContext || window.webkitAudioContext || false;
         if (!AudioContext) {
@@ -2181,6 +2308,7 @@ class Phone extends EventEmitter {
         }
 
         const ctx = new AudioContext();
+        this._toneContext = ctx;
         this._toneStreamNode = ctx.createMediaStreamDestination();
         this._toneAudioElement.srcObject = this._toneStreamNode.stream;
 
@@ -2200,6 +2328,14 @@ class Phone extends EventEmitter {
         this._oscillator2.start();
     }
 
+    // Best effort: a context created outside a user gesture is suspended until resumed.
+    _resumeToneContext() {
+        const ctx = this._toneContext;
+        if (ctx && ctx.state === 'suspended' && typeof ctx.resume === 'function') {
+            ctx.resume().catch((err) => this.log.debug('Audio context resume refused: ' + err));
+        }
+    }
+
     /**
      * Hold all active calls
      * @throws NotAllowed If there are connection calls
@@ -2213,7 +2349,7 @@ class Phone extends EventEmitter {
 
         // Iterate through all active calls and hold them
         for (let key in this._activeSessions) {
-            if (this._activeSessions.hasOwnProperty(key)) {
+            if (Object.hasOwn(this._activeSessions, key)) {
                 let session = this._activeSessions[key];
                 if (session.state === 'ACTIVE') {
                     session.hold();
@@ -2287,7 +2423,7 @@ class Phone extends EventEmitter {
     // Return true if there are calls currently connecting
     _checkForConnectingCalls() {
         for (let key in this._activeSessions) {
-            if (this._activeSessions.hasOwnProperty(key)) {
+            if (Object.hasOwn(this._activeSessions, key)) {
                 let session = this._activeSessions[key];
                 if (
                     session.state === 'INITIALIZING' ||
@@ -2312,17 +2448,23 @@ class Phone extends EventEmitter {
      * @property {string} REGISTRATION_FAILED Registration failed
      */
     // Set connection state and emit event
-    _setConnectionState(state) {
+    _setConnectionState(state, extra = {}) {
         /**
          * @event connectionStateChange
          * @type {object}
          * @param {CONNECTION_STATE} state - The current connection state
+         * @param {string} [cause] - For REGISTRATION_FAILED only: JsSIP's registrationFailed
+         *   cause, e.g. 'Connection Error', 'Request Timeout' (network/transport issues, JsSIP
+         *   will keep retrying on its own), 'Authentication Error' (401), or 'Rejected' (403 -
+         *   account disabled or credentials rejected by the registrar)
+         * @param {number} [statusCode] - For REGISTRATION_FAILED only: the SIP status code of
+         *   the failed REGISTER response, when JsSIP received one (e.g. 401, 403)
          */
 
         this.log.info('Connection state: ' + state);
         this._connectionState = state;
         try {
-            this.emit('connectionStateChange', { state: state });
+            this.emit('connectionStateChange', { state: state, ...extra });
         } catch (e) {
             this.log.error('Exception in connectionStateChange event: ' + e);
         }
@@ -2370,18 +2512,15 @@ class Phone extends EventEmitter {
          * @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);
+        // The call data event no longer carries recordings. Uploads are
+        // asynchronous, so the array was almost always empty by the time the CDR
+        // was processed, and the event cannot be re-fired once a recording lands
+        // because call_token is never persisted on the CDR. A dedicated
+        // "recording ready" event will replace it.
 
         // Event all duration fields are in seconds, convert to millisecs
         e.duration = e.duration * 1000;
@@ -2474,7 +2613,7 @@ class Session extends EventEmitter {
         this.destinationNumber = number;
 
         let options = {
-            mediaConstraints: { audio: true, video: false },
+            mediaConstraints: { audio: this._phone.audioConstraints, video: false },
             pcConfig: {
                 iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
             },
@@ -2671,7 +2810,7 @@ class Session extends EventEmitter {
                         self.log.info(`Answer call timeout after ${self._answerCallTimeout} seconds`);
                         try {
                             self.hangup();
-                        } catch (e) {
+                        } catch {
                             self.log.info('No active session, ignoring answer call timeout');
                         }
                     }, self._answerCallTimeout * 1000);
@@ -2828,7 +2967,7 @@ class Session extends EventEmitter {
      */
     answer(metaInfo = null) {
         let options = {
-            mediaConstraints: { audio: true, video: false },
+            mediaConstraints: { audio: this._phone.audioConstraints, video: false },
             pcConfig: {
                 iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
             },
@@ -3742,4 +3881,4 @@ class Session extends EventEmitter {
     }
 }
 
-export { EventClient, EventServiceNotConnected, InvalidMediaDevice, InvalidOptions, InvalidParameter, LOGLVL$1 as LOGLVL, LogHandler, MediaNotPrepared, NoActiveSession, NotAllowed, NotReady, Phone, Request, Requestor, Session, UnableToConnect, browserIsChrome, browserIsEdge, browserIsFirefox, browserIsOpera, browserIsSafari, buildCustomHeaders, compareObjects, createDurationString, createUUID };
+export { EventClient, EventServiceNotConnected, InvalidMediaDevice, InvalidOptions, InvalidParameter, LOGLVL, LogHandler, MediaNotPrepared, NoActiveSession, NotAllowed, NotReady, Phone, Request, Requestor, Session, UnableToConnect, browserIsChrome, browserIsEdge, browserIsFirefox, browserIsOpera, browserIsSafari, buildCustomHeaders, compareObjects, createDurationString, createUUID };