Source: flashphoner-core.js

  1. 'use strict';
  3. const { v1: uuid_v1 } = require('uuid');
  4. const constants = require("./constants");
  5. const util = require('./util');
  6. const LoggerObject = require('./util').logger;
  7. const clientInfo = require('./client-info');
  8. const Promise = require('promise-polyfill');
  9. const KalmanFilter = require('kalmanjs');
  10. const browserDetails = require('webrtc-adapter').default.browserDetails;
  11. const LOG_PREFIX = "core";
  12. var coreLogger;
  13. var loggerConf = {push: false, severity: "INFO"};
  14. var isUsingTemasysPlugin = false;
  15. var clientUAData;
  17. /**
  18.  * @namespace Flashphoner
  19.  */
  21. const SESSION_STATUS = constants.SESSION_STATUS;
  22. const STREAM_EVENT = constants.STREAM_EVENT;
  23. const STREAM_EVENT_TYPE = constants.STREAM_EVENT_TYPE;
  24. const STREAM_STATUS = constants.STREAM_STATUS;
  25. const CALL_STATUS = constants.CALL_STATUS;
  26. const CONNECTION_QUALITY = constants.CONNECTION_QUALITY;
  27. const ERROR_INFO = constants.ERROR_INFO;
  28. const VIDEO_RATE_GOOD_QUALITY_PERCENT_DIFFERENCE = 20;
  29. const VIDEO_RATE_BAD_QUALITY_PERCENT_DIFFERENCE = 50;
  30. const LOW_VIDEO_RATE_THRESHOLD_BAD_PERFECT = 50000;
  31. const LOW_VIDEO_RATE_BAD_QUALITY_PERCENT_DIFFERENCE = 150;
  32. const OUTBOUND_VIDEO_RATE = "outboundVideoRate";
  33. const INBOUND_VIDEO_RATE = "inboundVideoRate";
  34. const CONSTRAINT_AUDIO = "audio";
  35. const CONSTRAINT_AUDIO_STEREO = "stereo";
  36. const CONSTRAINT_AUDIO_BITRATE = "bitrate";
  37. const CONSTRAINT_AUDIO_FEC = "fec";
  38. const CONSTRAINT_AUDIO_OUTPUT_ID = "outputId";
  39. const CONSTRAINT_VIDEO = "video";
  40. const CONSTRAINT_VIDEO_BITRATE = "video.bitrate";
  41. const CONSTRAINT_VIDEO_MIN_BITRATE = "video.minBitrate";
  42. const CONSTRAINT_VIDEO_MAX_BITRATE = "video.maxBitrate";
  43. const CONSTRAINT_VIDEO_QUALITY = "video.quality";
  44. const CONSTRAINT_VIDEO_WIDTH = "video.width";
  45. const CONSTRAINT_VIDEO_HEIGHT = "video.height";
  46. var MediaProvider = {};
  47. var sessions = {};
  48. var initialized = false;
  49. var disableConnectionQualityCalculation;
  51. /**
  52.  * Static initializer.
  53.  *
  54.  * @param {Object} options Global api options
  55.  * @param {Function=} options.mediaProvidersReadyCallback Callback of initialized WebRTC Plugin
  56.  * @param {String=} options.flashMediaProviderSwfLocation Location of media-provider.swf file
  57.  * @param {string=} options.preferredMediaProvider DEPRECATED: Use preferred media provider if available
  58.  * @param {Array=} options.preferredMediaProviders Use preferred media providers order
  59.  * @param {String=} options.receiverLocation Location of WSReceiver.js file
  60.  * @param {String=} options.decoderLocation Location of video-worker2.js file
  61.  * @param {String=} options.screenSharingExtensionId Chrome screen sharing extension id
  62.  * @param {Object=} options.constraints Default local media constraints
  63.  * @param {Object=} options.logger Core logger options
  64.  * @param {Boolean=} options.collectClientInfo Collect client OS and system data available for debugging purposes
  65.  * @throws {Error} Error if none of MediaProviders available
  66.  * @memberof Flashphoner
  67.  */
  68. var init = async function (options) {
  69.     if (!initialized) {
  70.         if (!options) {
  71.             options = {};
  72.         }
  73.         // init global logger
  74.         coreLogger = createLogger(options.logger);
  75.         var waitingTemasys = false;
  76.         try {
  77.             var audioContext = new (window.AudioContext || window.webkitAudioContext)();
  78.         } catch (e) {
  79.             console.warn("Failed to create audio context");
  80.         }
  81.         disableConnectionQualityCalculation = options.disableConnectionQualityCalculation;
  82.         var webRtcProvider = require("./webrtc-media-provider");
  83.         if (webRtcProvider && webRtcProvider.hasOwnProperty('available') && webRtcProvider.available()) {
  84.             MediaProvider.WebRTC = webRtcProvider;
  85.             // WCS-2996 Fix audio-video out of sync in case of using Samsung browser
  86.             var enableGainNode = util.Browser.isSamsungBrowser() || util.Browser.isAndroidFirefox() ? false : options.createMicGainNode;
  87.             var webRtcConf = {
  88.                 constraints: options.constraints || getDefaultMediaConstraints(),
  89.                 extensionId: options.screenSharingExtensionId,
  90.                 audioContext: audioContext,
  91.                 logger: coreLogger,
  92.                 createMicGainNode: enableGainNode
  93.             };
  94.             webRtcProvider.configure(webRtcConf);
  95.         } else {
  96.             webRtcProvider = require("./temasys-media-provider");
  97.             if (webRtcProvider && webRtcProvider.hasOwnProperty('available') && AdapterJS) {
  98.                 waitingTemasys = true;
  99.                 AdapterJS.webRTCReady(function (isUsingPlugin) {
  100.                     isUsingTemasysPlugin = isUsingPlugin;
  101.                     if (isUsingPlugin || webRtcProvider.available()) {
  102.                         MediaProvider.WebRTC = webRtcProvider;
  103.                         var webRtcConf = {
  104.                             constraints: options.constraints || getDefaultMediaConstraints(),
  105.                             extensionId: options.screenSharingExtensionId,
  106.                             logger: coreLogger
  107.                         };
  108.                         webRtcProvider.configure(webRtcConf);
  110.                         // Just reorder media provider list
  111.                         var _MediaProvider = {};
  112.                         _MediaProvider.WebRTC = MediaProvider.WebRTC;
  113.                         for (var p in MediaProvider) {
  114.                             _MediaProvider[p] = MediaProvider[p];
  115.                         }
  116.                         MediaProvider = _MediaProvider;
  117.                     }
  118.                     if (options.mediaProvidersReadyCallback) {
  119.                         options.mediaProvidersReadyCallback(Object.keys(MediaProvider));
  120.                     }
  121.                 });
  122.             }
  123.         }
  125.         // flashMediaProvider is disables by default due to end of support in the most browsers #WCS-3577
  126.         var flashProvider = null;
  127.         if (flashProvider && flashProvider.hasOwnProperty('available') && flashProvider.available() &&
  128.             (!MediaProvider.WebRTC || (options.preferredMediaProviders && options.preferredMediaProviders.indexOf("Flash") >= 0))) {
  129.             MediaProvider.Flash = flashProvider;
  130.             var flashConf = {
  131.                 constraints: options.constraints || getDefaultMediaConstraints(),
  132.                 flashMediaProviderSwfLocation: options.flashMediaProviderSwfLocation,
  133.                 logger: coreLogger
  134.             };
  135.             flashProvider.configure(flashConf);
  136.         }
  137.         var mediaSourceMediaProvider = require("./media-source-media-provider");
  138.         if (mediaSourceMediaProvider && mediaSourceMediaProvider.hasOwnProperty('available') && mediaSourceMediaProvider.available()) {
  139.             MediaProvider.MSE = mediaSourceMediaProvider;
  140.             var mseConf = {
  141.                 audioContext: audioContext,
  142.                 browserDetails: browserDetails.browser
  143.             };
  144.             mediaSourceMediaProvider.configure(mseConf);
  145.         }
  146.         var websocketProvider = require("./websocket-media-provider");
  147.         if (websocketProvider && websocketProvider.hasOwnProperty('available') && websocketProvider.available(audioContext)) {
  148.             MediaProvider.WSPlayer = websocketProvider;
  149.             var wsConf = {
  150.                 receiverLocation: options.receiverLocation,
  151.                 decoderLocation: options.decoderLocation,
  152.                 audioContext: audioContext,
  153.                 logger: coreLogger
  154.             };
  155.             websocketProvider.configure(wsConf);
  156.         }
  158.         //check at least 1 provider available
  159.         if (getMediaProviders().length == 0) {
  160.             throw new Error('None of MediaProviders available');
  161.         } else if (options.preferredMediaProvider) {
  162.             if (MediaProvider.hasOwnProperty(options.preferredMediaProvider)) {
  163.                 if (getMediaProviders()[0] != options.preferredMediaProvider) {
  164.                     // Just reorder media provider list
  165.                     var _MediaProvider = {};
  166.                     _MediaProvider[options.preferredMediaProvider] = MediaProvider[options.preferredMediaProvider];
  167.                     for (var p in MediaProvider) {
  168.                         _MediaProvider[p] = MediaProvider[p];
  169.                     }
  170.                     MediaProvider = _MediaProvider;
  171.                 }
  172.             } else {
  173.                 corelogger.warn(LOG_PREFIX, "Preferred media provider is not available.");
  174.             }
  175.         }
  176.         if (options.preferredMediaProviders && options.preferredMediaProviders.length > 0) {
  177.             var newMediaProvider = {};
  178.             for (var i in options.preferredMediaProviders) {
  179.                 if (options.preferredMediaProviders.hasOwnProperty(i)) {
  180.                     var pMP = options.preferredMediaProviders[i];
  181.                     if (MediaProvider.hasOwnProperty(pMP)) {
  182.                         newMediaProvider[pMP] = MediaProvider[pMP];
  183.                     }
  184.                 }
  185.             }
  186.             if (util.isEmptyObject(newMediaProvider)) {
  187.                 throw new Error("None of preferred MediaProviders available");
  188.             } else {
  189.                 MediaProvider = newMediaProvider;
  190.             }
  192.         }
  193.         if (!waitingTemasys && options.mediaProvidersReadyCallback) {
  194.             options.mediaProvidersReadyCallback(Object.keys(MediaProvider));
  195.         }
  197.         coreLogger.info(LOG_PREFIX, "Initialized");
  198.         initialized = true;
  200.         if (options.collectClientInfo === undefined || options.collectClientInfo) {
  201.             clientUAData = await clientInfo.getClientInfo(window.navigator);
  202.             coreLogger.info(LOG_PREFIX, "Client system data: " + JSON.stringify(clientUAData));
  203.         }
  204.     }
  205. };
  207. /**
  208.  * Get available MediaProviders.
  209.  *
  210.  * @returns {Array} Available MediaProviders
  211.  * @memberof Flashphoner
  212.  */
  213. var getMediaProviders = function () {
  214.     return Object.keys(MediaProvider);
  215. };
  217. /**
  218.  * Play audio chunk
  219.  * @param {boolean} noise Use noise in playing
  220.  * @memberof Flashphoner
  221.  */
  223. var playFirstSound = function(noise) {
  224.     var mediaProvider = getMediaProviders()[0];
  225.     MediaProvider[mediaProvider].playFirstSound(noise);
  226. };
  228. /**
  229.  * Play video chunk
  230.  *
  231.  * @memberof Flashphoner
  232.  */
  233. var playFirstVideo = function (display, isLocal, src, useControls) {
  234.     for (var mp in MediaProvider) {
  235.         return MediaProvider[mp].playFirstVideo(display, isLocal, src, useControls);
  236.     }
  237. };
  239. /**
  240.  * Get core logger
  241.  *
  242.  * @returns {Object} Logger
  243.  * @memberof Flashphoner
  244.  */
  245. var getLogger = function () {
  246.     if (!initialized) {
  247.         console.warn("Initialize API first.");
  248.     } else {
  249.         return coreLogger;
  250.     }
  251. }
  253. /**
  254.  * @typedef Flashphoner.MediaDeviceList
  255.  * @type Object
  256.  * @property {Flashphoner.MediaDevice[]} audio Audio devices (microphones)
  257.  * @property {Flashphoner.MediaDevice[]} video Video devices (cameras)
  258.  */
  260. /**
  261.  * @typedef Flashphoner.MediaDevice
  262.  * @type Object
  263.  * @property {String} type Type of device: mic, camera, screen
  264.  * @property {String} id Unique id
  265.  * @property {String} label Device label
  266.  */
  268. /**
  269.  * Get available local media devices
  270.  *
  271.  * @param {String=} mediaProvider Media provider that will be asked for device list
  272.  * @param {Boolean=} labels Ask user for microphone access before getting device list.
  273.  * This will make device label available.
  274.  * @param {Flashphoner.constants.MEDIA_DEVICE_KIND} kind Media devices kind to access:
  275.  * MEDIA_DEVICE_KIND.INPUT (default) get access to input devices only (camera, mic).
  276.  * MEDIA_DEVICE_KIND.OUTPUT get access to output devices only (speaker, headphone).
  277.  * MEDIA_DEVICE_KIND.ALL get access to all devices (cam, mic, speaker, headphone).
  278.  * @param {Object=} deviceConstraints If labels == true.
  279.  * If {audio: true, video: false}, then access to the camera will not be requested.
  280.  * If {audio: false, video: true}, then access to the microphone will not be requested.
  281.  * @returns {Promise.<Flashphoner.MediaDeviceList>} Promise with media device list on fulfill
  282.  * @throws {Error} Error if API is not initialized
  283.  * @memberof Flashphoner
  284.  */
  285. var getMediaDevices = function (mediaProvider, labels, kind, deviceConstraints) {
  286.     if (!initialized) {
  287.         throw new Error("Flashphoner API is not initialized");
  288.     }
  289.     if (!mediaProvider) {
  290.         mediaProvider = getMediaProviders()[0];
  291.     }
  292.     return MediaProvider[mediaProvider].listDevices(labels, kind, deviceConstraints);
  293. };
  295. /**
  296.  * Get access to local media
  297.  *
  298.  * @param {Object} constraints Media constraints
  299.  * @param {Object} constraints.audio Audio constraints
  300.  * @param {String=} constraints.audio.deviceId Audio device id
  301.  * @param {Object} constraints.video Video constraints
  302.  * @param {String=} constraints.video.deviceId Video device id
  303.  * @param {number} constraints.video.width Video width
  304.  * @param {number} constraints.video.height Video height
  305.  * @param {number} constraints.video.frameRate Video fps
  306.  * @param {String} constraints.video.type Video device type: camera, screen
  307.  * @param {String} constraints.video.mediaSource Video source type for FF: screen, window
  308.  * @param {HTMLElement} display Div element local media should be displayed in
  309.  * @param {String} mediaProvider Media provider type
  310.  * @param {Boolean} disableConstraintsNormalization Disable constraints normalization
  311.  * @returns {Promise.<HTMLElement>} Promise with display on fulfill
  312.  * @throws {Error} Error if API is not initialized
  313.  * @memberof Flashphoner
  314.  */
  316. var getMediaAccess = function (constraints, display, mediaProvider, disableConstraintsNormalization) {
  317.     if (!initialized) {
  318.         throw new Error("Flashphoner API is not initialized");
  319.     }
  320.     if (!mediaProvider) {
  321.         mediaProvider = getMediaProviders()[0];
  322.     }
  323.     return MediaProvider[mediaProvider].getMediaAccess(constraints, display, disableConstraintsNormalization);
  324. };
  326. //default constraints helper
  327. //WCS-3016 16:9 ratio
  328. var getDefaultMediaConstraints = function () {
  329.     if (browserDetails.browser == "safari") {
  330.         return {
  331.             audio: true,
  332.             video: {
  333.                 width: {min: 320, max: 640},
  334.                 height: {min: 180, max: 360}
  335.             }
  336.         };
  337.     }
  338.     else {
  339.         return {
  340.             audio: true,
  341.             video: {
  342.                 width: 320,
  343.                 height: 240
  344.             }
  345.         }
  346.     }
  347. };
  349. function getConstraintsProperty(constraints, property, defaultValue) {
  350.     if (!constraints || !property) return defaultValue;
  351.     var res;
  352.     var properties = property.split(".");
  353.     for (var prop in constraints) {
  354.         if (prop == properties[0]) {
  355.             res = constraints[prop];
  356.             if (properties.length > 1) res = getConstraintsProperty(constraints[prop], properties[1], defaultValue);
  357.         } else if (typeof constraints[prop] === "object") {
  358.             for (var p in constraints[prop]) {
  359.                 if (p == property) res = constraints[prop][p];
  360.             }
  361.         }
  362.     }
  363.     if (typeof res === "boolean") return res;
  364.     return res || defaultValue;
  365. }
  367. /**
  368.  * Release local media
  369.  *
  370.  * @param {HTMLElement} display Div element with local media
  371.  * @param {String=} mediaProvider Media provider type
  372.  * @returns {Boolean} True if media was found and released
  373.  * @throws {Error} Error if API is not initialized
  374.  * @memberof Flashphoner
  375.  */
  377. var releaseLocalMedia = function (display, mediaProvider) {
  378.     if (!initialized) {
  379.         throw new Error("Flashphoner API is not initialized");
  380.     }
  381.     if (!mediaProvider) {
  382.         mediaProvider = getMediaProviders()[0];
  383.     }
  384.     return MediaProvider[mediaProvider].releaseMedia(display);
  385. };
  387. /**
  388.  * Get active sessions.
  389.  *
  390.  * @returns {Session[]} Array containing active sessions
  391.  * @memberof Flashphoner
  392.  */
  393. var getSessions = function () {
  394.     return util.copyObjectToArray(sessions);
  395. };
  397. /**
  398.  * Get session by id.
  399.  *
  400.  * @param {string} id Session id
  401.  * @returns {Session} Session
  402.  * @memberof Flashphoner
  403.  */
  404. var getSession = function (id) {
  405.     return sessions[id];
  406. };
  408. // Get logger configuration from options
  409. var getLoggerConf = function(loggerOptions) {
  410.     var conf = loggerOptions || loggerConf;
  411.     if (loggerOptions !== null) {
  412.       conf.enableLogs = true;
  413.     }
  414.     return conf;
  415. }
  417. // Create a new logger object
  418. var createLogger = function(loggerOptions, parentLogger = coreLogger) {
  419.     var newLogger = parentLogger;
  420.     if (newLogger === undefined || loggerOptions != undefined) {
  421.         var loggerConf = getLoggerConf(loggerOptions);
  422.         newLogger = new LoggerObject;
  423.         newLogger.init(loggerConf.severity || "INFO", loggerConf.push || false, loggerConf.customLogger, loggerConf.enableLogs);
  424.     }
  425.     return newLogger;
  426. }
  428. /**
  429.  * Create new session and connect to server.
  430.  *
  431.  * @param {Object} options Session options
  432.  * @param {string} options.urlServer Server address in form of [ws,wss]://host.domain:port
  433.  * @param {string} options.authToken Token for auth on server with keepalived client
  434.  * @param {Boolean=} options.keepAlive Keep alive client on server after disconnect
  435.  * @param {string=} options.lbUrl Load-balancer address
  436.  * @param {string=} options.flashProto Flash protocol [rtmp,rtmfp]
  437.  * @param {Integer=} options.flashPort Flash server port [1935]
  438.  * @param {string=} options.appKey REST App key
  439.  * @param {Object=} options.custom User provided custom object that will be available in REST App code
  440.  * @param {Object=} options.sipOptions Sip configuration
  441.  * @param {Object=} options.mediaOptions Media connection configuration
  442.  * @param {Integer=} options.timeout Connection timeout in milliseconds
  443.  * @param {Integer=} options.pingInterval Server ping interval in milliseconds [0]
  444.  * @param {Integer=} options.receiveProbes A maximum subsequental pings received missing count [0]
  445.  * @param {Integer=} options.probesInterval Interval to check subsequental pings received [0]
  446.  * @param {Object=} options.logger Session logger options
  447.  * @param {Boolean=} options.sendClientInfo Send client system info for debugging purposes
  448.  * @returns {Session} Created session
  449.  * @throws {Error} Error if API is not initialized
  450.  * @throws {TypeError} Error if options.urlServer is not specified
  451.  * @memberof Flashphoner
  452.  */
  453. var createSession = function (options) {
  454.     if (!initialized) {
  455.         throw new Error("Flashphoner API is not initialized");
  456.     }
  458.     if (!options || !options.urlServer) {
  459.         throw new TypeError("options.urlServer must be provided");
  460.     }
  462.     // Set session logger #WCS-2434
  463.     var sessionLogger = createLogger(options.logger)
  464.     // Override logger for all low level operations
  465.     var logger = sessionLogger;
  467.     var id_ = uuid_v1();
  468.     var sessionStatus = SESSION_STATUS.PENDING;
  469.     var urlServer = options.urlServer;
  470.     var lbUrl = options.lbUrl;
  471.     var flashProto = options.flashProto || "rtmfp";
  472.     var flashPort = options.flashPort || 1935;
  473.     var appKey = options.appKey || "defaultApp";
  474.     var mediaOptions = options.mediaOptions;
  475.     var keepAlive = options.keepAlive;
  476.     var timeout = options.timeout;
  477.     var sendClientInfo = options.sendClientInfo !== undefined ? options.sendClientInfo : true;
  478.     var wsPingSender = new WSPingSender(options.pingInterval || 0);
  479.     var wsPingReceiver = new WSPingReceiver(options.receiveProbes || 0, options.probesInterval || 0);
  480.     var connectionTimeout;
  482.     var cConfig;
  483.     //SIP config
  484.     var sipConfig;
  485.     if (options.sipOptions) {
  486.         sipConfig = {
  487.             sipLogin: options.sipOptions.login,
  488.             sipAuthenticationName: options.sipOptions.authenticationName,
  489.             sipPassword: options.sipOptions.password,
  490.             sipDomain: options.sipOptions.domain,
  491.             sipOutboundProxy: options.sipOptions.outboundProxy,
  492.             sipProxy: options.sipOptions.proxy,
  493.             sipPort: options.sipOptions.port,
  494.             sipRegisterRequired: options.sipOptions.registerRequired
  495.         }
  496.     }
  497.     //media provider auth token received from server
  498.     var authToken = options.authToken;
  499.     //object for storing new and active streams
  500.     var streams = {};
  501.     var calls = {};
  502.     var mediaConnections = {};
  503.     //session to stream event callbacks
  504.     var streamEventRefreshHandlers = {};
  505.     //session to stream callbacks
  506.     var streamRefreshHandlers = {};
  507.     //session to call callbacks
  508.     var callRefreshHandlers = {};
  509.     /**
  510.      * Represents connection to REST App.
  511.      * Can create and store Streams.
  512.      *
  513.      * @see Flashphoner.createSession
  514.      * @namespace Session
  515.      */
  516.     var session = {};
  517.     //callbacks added using session.on()
  518.     var callbacks = {};
  520.     var wsConnection;
  522.     if (lbUrl) {
  523.         requestURL(lbUrl);
  524.     } else {
  525.         createWS(urlServer)
  526.     }
  528.     //todo remove
  529.     var remoteSdpCache = {};
  531.     //Request URL from load-balancer
  532.     function requestURL(url) {
  533.         var request = new XMLHttpRequest();
  534.         request.open('GET', url, true);
  535.         request.timeout = 5000;
  536.         request.ontimeout = function () {
  537.             logger.warn(LOG_PREFIX, "Timeout during geting url from balancer!");
  538.             createWS(urlServer);
  539.         }
  540.         request.error = function () {
  541.             logger.warn(LOG_PREFIX, "Error during geting url from balancer!")
  542.             createWS(urlServer);
  543.         }
  544.         request.onload = function (e) {
  545.             if (request.status == 200 && request.readyState == 4) {
  546.                 var result = JSON.parse(request.responseText);
  547.                 if (urlServer.indexOf("wss://") !== -1) {
  548.                     urlServer = "wss://" + result.server + ":" + result.wss;
  549.                 } else {
  550.                     urlServer = "ws://" + result.server + ":" + result.ws;
  551.                 }
  552.                 flashPort = result.flash;
  553.                 logger.debug(LOG_PREFIX, "Got url from load balancer " + result.server);
  554.                 createWS(urlServer);
  555.             }
  556.         }
  557.         request.send();
  558.     }
  560.     //connect session to server
  561.     function createWS(url) {
  562.         wsConnection = new WebSocket(url);
  563.         if (timeout != undefined && timeout > 0) {
  564.           connectionTimeout = setTimeout(function() {
  565.             if (wsConnection.readyState == 0) {
  566.               logger.warn(LOG_PREFIX, "WS connection timeout");
  567.               wsConnection.close();
  568.             }
  569.           }, timeout);
  570.         }
  571.         wsConnection.onerror = function () {
  572.             onSessionStatusChange(SESSION_STATUS.FAILED);
  573.         };
  574.         wsConnection.onclose = function () {
  575.             if (sessionStatus !== SESSION_STATUS.FAILED) {
  576.                 onSessionStatusChange(SESSION_STATUS.DISCONNECTED);
  577.             }
  578.         };
  579.         wsConnection.onopen = function () {
  580.             onSessionStatusChange(SESSION_STATUS.CONNECTED);
  581.             clearTimeout(connectionTimeout);
  582.             cConfig = {
  583.                 appKey: appKey,
  584.                 mediaProviders: Object.keys(MediaProvider),
  585.                 keepAlive: keepAlive,
  586.                 authToken: authToken,
  587.                 clientVersion: "2.0",
  588.                 clientOSVersion: window.navigator.appVersion,
  589.                 clientBrowserVersion: window.navigator.userAgent,
  590.                 msePacketizationVersion: 2,
  591.                 custom: options.custom
  592.             };
  593.             if (sendClientInfo && clientUAData) {
  594.                 cConfig.clientInfo = clientUAData;
  595.             }
  596.             if (sipConfig) {
  597.                 util.copyObjectPropsToAnotherObject(sipConfig, cConfig);
  598.             }
  599.             //connect to REST App
  600.             send("connection", cConfig);
  601.             logger.setConnection(wsConnection);
  602.             // Send ping messages to server to check if connection is still alive #WCS-3410
  603.             wsPingSender.start();
  604.             // Check subsequintel pings received from server to check if connection is still alive #WCS-3410
  605.             wsPingReceiver.start();
  606.         };
  607.         wsConnection.onmessage = function (event) {
  608.             var data = {};
  609.             if (event.data instanceof Blob) {
  610.                 data.message = "binaryData";
  611.             } else {
  612.                 data = JSON.parse(event.data);
  613.                 var obj = data.data[0];
  614.             }
  615.             switch (data.message) {
  616.                 case 'ping':
  617.                     logger.debug(LOG_PREFIX, "<<< ping");
  618.                     send("pong", null);
  619.                     logger.debug(LOG_PREFIX, ">>> pong");
  620.                     break;
  621.                 case 'getUserData':
  622.                     authToken = obj.authToken;
  623.                     cConfig = obj;
  624.                     onSessionStatusChange(SESSION_STATUS.ESTABLISHED, obj);
  625.                     break;
  626.                 case 'setRemoteSDP':
  627.                     var mediaSessionId = data.data[0];
  628.                     var sdp = data.data[1];
  629.                     if (streamRefreshHandlers[mediaSessionId]) {
  630.                         //pass server's sdp to stream
  631.                         streamRefreshHandlers[mediaSessionId](null, sdp);
  632.                     } else if (callRefreshHandlers[mediaSessionId]) {
  633.                         //pass server's sdp to call
  634.                         callRefreshHandlers[mediaSessionId](null, sdp);
  635.                     } else {
  636.                         remoteSdpCache[mediaSessionId] = sdp;
  637.                         logger.info(LOG_PREFIX, "Media not found, id " + mediaSessionId);
  638.                     }
  639.                     break;
  640.                 case 'notifyVideoFormat':
  641.                 case 'notifyStreamStatusEvent':
  642.                     if (streamRefreshHandlers[obj.mediaSessionId]) {
  643.                         //update stream status
  644.                         streamRefreshHandlers[obj.mediaSessionId](obj);
  645.                     }
  646.                     break;
  647.                 case 'notifyStreamEvent':
  648.                     if (streamEventRefreshHandlers[obj.mediaSessionId]) {
  649.                         //update stream status
  650.                         streamEventRefreshHandlers[obj.mediaSessionId](obj);
  651.                     }
  652.                     break;
  653.                 case 'DataStatusEvent':
  654.                     restAppCommunicator.resolveData(obj);
  655.                     break;
  656.                 case 'OnDataEvent':
  657.                     if (callbacks[SESSION_STATUS.APP_DATA]) {
  658.                         callbacks[SESSION_STATUS.APP_DATA](obj);
  659.                     }
  660.                     break;
  661.                 case 'fail':
  662.                     if (obj.apiMethod && obj.apiMethod == "StreamStatusEvent") {
  663.                         if (streamRefreshHandlers[obj.id]) {
  664.                             //update stream status
  665.                             streamRefreshHandlers[obj.id](obj);
  666.                         }
  667.                     }
  668.                     if (callbacks[SESSION_STATUS.WARN]) {
  669.                         callbacks[SESSION_STATUS.WARN](obj);
  670.                     }
  671.                     break;
  672.                 case 'registered':
  673.                     onSessionStatusChange(SESSION_STATUS.REGISTERED);
  674.                     break;
  675.                 case 'notifyAudioCodec':
  676.                     // This case for Flash only
  677.                     var mediaSessionId = data.data[0];
  678.                     var codec = data.data[1];
  679.                     if (callRefreshHandlers[mediaSessionId]) {
  680.                         callRefreshHandlers[mediaSessionId](null, null, codec);
  681.                     }
  682.                     break;
  683.                 case 'notifyTransferEvent':
  684.                     callRefreshHandlers[obj.callId](null, null, null, obj);
  685.                     break;
  686.                 case 'notifyTryingResponse':
  687.                 case 'hold':
  688.                 case 'ring':
  689.                 case 'talk':
  690.                 case 'finish':
  691.                     if (callRefreshHandlers[obj.callId]) {
  692.                         //update call status
  693.                         callRefreshHandlers[obj.callId](obj);
  694.                     }
  695.                     break;
  696.                 case 'notifyIncomingCall':
  697.                     if (callRefreshHandlers[obj.callId]) {
  698.                         logger.error(LOG_PREFIX, "Call already exists, id " + obj.callId);
  699.                     }
  700.                     if (callbacks[SESSION_STATUS.INCOMING_CALL]) {
  701.                         callbacks[SESSION_STATUS.INCOMING_CALL](createCall(obj));
  702.                     } else {
  703.                         //todo hangup call
  704.                     }
  705.                     break;
  706.                 case 'notifySessionDebugEvent':
  707.                     logger.info(LOG_PREFIX, "Session debug status " + obj.status);
  708.                     if (callbacks[SESSION_STATUS.DEBUG]) {
  709.                         callbacks[SESSION_STATUS.DEBUG](obj);
  710.                     }
  711.                     break;
  712.                 case 'availableStream':
  713.                     var availableStream = {};
  714.                     availableStream.mediaSessionId = obj.id;
  715.                     availableStream.available = obj.status;
  716.                     availableStream.reason = obj.info;
  717.                     if (streamRefreshHandlers[availableStream.mediaSessionId]) {
  718.                         streamRefreshHandlers[availableStream.mediaSessionId](availableStream);
  719.                     }
  720.                     break;
  721.                 case OUTBOUND_VIDEO_RATE:
  722.                 case INBOUND_VIDEO_RATE:
  723.                     if (streamRefreshHandlers[obj.mediaSessionId]) {
  724.                         obj.status = data.message;
  725.                         streamRefreshHandlers[obj.mediaSessionId](obj);
  726.                     }
  727.                     break;
  728.                 default:
  729.                     logger.info(LOG_PREFIX, "Unknown server message " + data.message);
  730.             }
  731.             // Reset missing pings counter on any message received successfully #WCS-4343
  732.             logger.debug(LOG_PREFIX, "Reset missing pings counter by " + data.message + " message");
  733.             wsPingReceiver.success();
  734.         };
  735.     }
  737.     //WebSocket send helper
  738.     function send(message, data) {
  739.         wsConnection.send(JSON.stringify({
  740.             message: message,
  741.             data: [data]
  742.         }));
  743.     }
  745.     //Session status update helper
  746.     function onSessionStatusChange(newStatus, obj) {
  747.         sessionStatus = newStatus;
  748.         if (sessionStatus == SESSION_STATUS.DISCONNECTED || sessionStatus == SESSION_STATUS.FAILED) {
  749.             // Stop pinging server #WCS-3410
  750.             wsPingSender.stop();
  751.             // Stop checking pings received #WCS-3410
  752.             wsPingReceiver.stop();
  753.             //remove streams
  754.             for (var prop in streamRefreshHandlers) {
  755.                 if (streamRefreshHandlers.hasOwnProperty(prop) && typeof streamRefreshHandlers[prop] === 'function') {
  756.                     streamRefreshHandlers[prop]({status: STREAM_STATUS.FAILED});
  757.                 }
  758.             }
  759.             //remove session from list
  760.             delete sessions[id_];
  761.         }
  762.         if (callbacks[sessionStatus]) {
  763.             callbacks[sessionStatus](session, obj);
  764.         }
  765.     }
  767.     // Websocket periodic ping sender
  768.     function WSPingSender(interval) {
  769.         this.interval = interval || 0;
  770.         this.intervalId = null;
  771.         this.start = function() {
  772.             if (this.interval > 0) {
  773.                 this.intervalId = setInterval(function() {
  774.                     send("ping", null);
  775.                 }, this.interval);
  776.             }
  777.         };
  778.         this.stop = function() {
  779.             if (this.intervalId) {
  780.                 clearInterval(this.intervalId);
  781.             }
  782.         };
  783.         
  784.         return(this);
  785.     }
  787.     // Websocket ping receive prober
  788.     function WSPingReceiver(receiveProbes, probesInterval) {
  789.         this.maxPings = receiveProbes || 0;
  790.         this.interval = probesInterval || 0;
  791.         this.intervalId = null;
  792.         this.pingsMissing = 0;
  793.         this.start = function() {
  794.             if (this.maxPings > 0 && this.interval > 0) {
  795.                 let receiver = this;
  796.                 this.intervalId = setInterval(function() {
  797.                     receiver.checkPingsReceived();
  798.                 }, this.interval);
  799.             }
  800.         };
  801.         this.stop = function() {
  802.             if (this.intervalId) {
  803.                 clearInterval(this.intervalId);
  804.             }
  805.             this.pingsMissing = 0;
  806.         };
  807.         this.checkPingsReceived = function() {
  808.             this.pingsMissing++;
  809.             if (this.pingsMissing >= this.maxPings) {
  810.                 this.failure();
  811.             }
  812.         };
  813.         this.success = function() {
  814.             this.pingsMissing = 0;
  815.         };
  816.         this.failure = function() {
  817.             logger.info(LOG_PREFIX, "Missing " + this.pingsMissing + " pings from server, connection seems to be down");
  818.             onSessionStatusChange(SESSION_STATUS.FAILED);
  819.             wsConnection.close();
  820.         };
  822.         return(this);
  823.     }
  826.     /**
  827.      * @callback sdpHook
  828.      * @param {Object} sdp Callback options
  829.      * @param {String} sdp.sdpString Sdp from the server
  830.      * @returns {String} sdp New sdp
  831.      */
  833.     /**
  834.      * Create call.
  835.      *
  836.      * @param {Object} options Call options
  837.      * @param {string} options.callee Call remote party id
  838.      * @param {string=} options.visibleName Call caller visible name
  839.      * @param {Object} options.constraints Call constraints
  840.      * @param {string} options.mediaProvider MediaProvider type to use with this call
  841.      * @param {Boolean=} options.receiveAudio Receive audio
  842.      * @param {Boolean=} options.receiveVideo Receive video
  843.      * @param {Boolean=} options.cacheLocalResources Display will contain local video after call release
  844.      * @param {HTMLElement} options.localVideoDisplay Div element local video should be displayed in
  845.      * @param {HTMLElement} options.remoteVideoDisplay Div element remote video should be displayed in
  846.      * @param {Object=} options.custom User provided custom object that will be available in REST App code
  847.      * @param {string=} options.stripCodecs Comma separated strings of codecs which should be stripped from WebRTC SDP (ex. "SILK,G722")
  848.      * @param {Array<string>=} options.sipSDP Array of custom SDP params (ex. bandwidth (b=))
  849.      * @param {Array<string>=} options.sipHeaders Array of custom SIP headers
  850.      * @param {string=} options.videoContentHint Video content hint for browser ('motion' by default to maintain bitrate and fps), {@link Flashphoner.constants.CONTENT_HINT_TYPE}
  851.      * @param {Boolean=} options.useControls Use a standard HTML5 video controls (play, pause, fullscreen). May be a workaround for fullscreen mode to work in Safari 16
  852.      * @param {Object=} options.logger Call logger options
  853.      * @param {Boolean=} options.collectDeviceInfo Collect a media devices info when publishing a WebRTC stream
  854.      * @param {sdpHook} sdpHook The callback that handles sdp from the server
  855.      * @returns {Call} Call
  856.      * @throws {TypeError} Error if no options provided
  857.      * @throws {Error} Error if session state is not REGISTERED
  858.      * @memberof Session
  859.      * @inner
  860.      */
  861.     var createCall = function (options) {
  862.         //check session state
  863.         if (sessionStatus !== SESSION_STATUS.REGISTERED && sessionStatus !== SESSION_STATUS.ESTABLISHED) {
  864.             throw new Error('Invalid session state ' + sessionStatus);
  865.         }
  867.         //check options
  868.         if (!options) {
  869.             throw new TypeError("options must be provided");
  870.         }
  872.         // Set call logger #WCS-2434
  873.         var callLogger = createLogger(options.logger, sessionLogger);
  874.         // Override logger for all low level operations
  875.         var logger = callLogger;
  877.         var login = (appKey == 'clickToCallApp') ? '' : cConfig.sipLogin;
  878.         var caller_ = (options.incoming) ? options.caller : login;
  879.         var callee_ = options.callee;
  880.         var visibleName_ = options.visibleName || login;
  882.         var id_ = options.callId || uuid_v1();
  883.         var mediaProvider = options.mediaProvider || getMediaProviders()[0];
  884.         var mediaConnection;
  885.         var localDisplay = options.localVideoDisplay;
  886.         var remoteDisplay = options.remoteVideoDisplay;
  888.         var info_;
  889.         var errorInfo_;
  890.         // Constraints
  891.         if (options.constraints) {
  892.             var constraints = options.constraints;
  893.         }
  894.         if (options.disableConstraintsNormalization) {
  895.             var disableConstraintsNormalization = options.disableConstraintsNormalization;
  896.         }
  898.         var audioOutputId;
  899.         var audioProperty = getConstraintsProperty(constraints, CONSTRAINT_AUDIO, undefined);
  900.         if (typeof audioProperty === 'object') {
  901.             audioOutputId = getConstraintsProperty(audioProperty, CONSTRAINT_AUDIO_OUTPUT_ID, 0);
  902.         }
  904.         var stripCodecs = options.stripCodecs || [];
  905.         // Receive media
  906.         var receiveAudio = (typeof options.receiveAudio !== 'undefined') ? options.receiveAudio : true;
  907.         var receiveVideo = (typeof options.receiveVideo !== 'undefined') ? options.receiveVideo : true;
  909.         var cacheLocalResources = options.cacheLocalResources;
  910.         var status_ = CALL_STATUS.NEW;
  911.         var callbacks = {};
  912.         var hasTransferredCall = false;
  913.         var sdpHook = options.sdpHook;
  914.         var sipSDP = options.sipSDP;
  915.         var sipHeaders = options.sipHeaders;
  916.         var videoContentHint = options.videoContentHint;
  917.         var useControls = options.useControls;
  918.         var collectDeviceInfo = options.collectDeviceInfo !== undefined ? options.collectDeviceInfo : true;
  920.         var minBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MIN_BITRATE, 0);
  921.         var maxBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MAX_BITRATE, 0);
  923.         /**
  924.          * Represents sip call.
  925.          *
  926.          * @namespace Call
  927.          * @see Session~createCall
  928.          */
  929.         var call = {};
  930.         callRefreshHandlers[id_] = function (callInfo, sdp, codec, transfer) {
  931.             if (transfer) {
  932.                 if (!mediaConnections[id_]) {
  933.                     mediaConnections[id_] = mediaConnection;
  934.                 }
  935.                 if (transfer.status == "COMPLETED") {
  936.                     delete mediaConnections[id_];
  937.                 }
  938.                 return;
  939.             }
  941.             //transferred call
  942.             if (!mediaConnection && Object.keys(mediaConnections).length != 0) {
  943.                 for (var mc in mediaConnections) {
  944.                     mediaConnection = mediaConnections[mc];
  945.                     hasTransferredCall = true;
  946.                     delete mediaConnections[mc];
  947.                 }
  948.             }
  949.             //set audio codec (Flash only)
  950.             if (codec) {
  951.                 if (mediaProvider == "Flash") {
  952.                     mediaConnection.changeAudioCodec(codec.name);
  953.                 }
  954.                 return;
  955.             }
  956.             //set remote sdp
  957.             if (sdp && sdp !== '') {
  958.                 sdp = sdpHookHandler(sdp, sdpHook);
  959.                 // Adjust publishing bitrate #WCS-4013
  960.                 sdp = util.setPublishingBitrate(sdp, mediaConnection, minBitrate, maxBitrate);
  961.                 mediaConnection.setRemoteSdp(sdp, hasTransferredCall, id_).then(function () {});
  962.                 return;
  963.             }
  964.             var event = callInfo.status;
  965.             status_ = event;
  966.             //release call
  967.             if (event == CALL_STATUS.FAILED || event == CALL_STATUS.FINISH ||
  968.                 event == CALL_STATUS.BUSY) {
  969.                 delete calls[id_];
  970.                 delete callRefreshHandlers[id_];
  971.                 if (Object.keys(calls).length == 0) {
  972.                     if (mediaConnection)
  973.                         mediaConnection.close(cacheLocalResources);
  974.                 }
  975.             }
  976.             //fire call event
  977.             if (callbacks[event]) {
  978.                 callbacks[event](call);
  979.             }
  980.         };
  982.         /**
  983.          * Initiate outgoing call.
  984.          *
  985.          * @throws {Error} Error if call status is not {@link Flashphoner.constants.CALL_STATUS.NEW}
  986.          * @memberof Call
  987.          * @name call
  988.          * @inner
  989.          */
  990.         var call_ = function () {
  991.             if (status_ !== CALL_STATUS.NEW) {
  992.                 throw new Error("Invalid call state");
  993.             }
  994.             status_ = CALL_STATUS.PENDING;
  995.             var hasAudio = true;
  996.             //get access to camera
  997.             MediaProvider[mediaProvider].getMediaAccess(constraints, localDisplay, disableConstraintsNormalization).then(function () {
  998.                 if (status_ == CALL_STATUS.FAILED) {
  999.                     //call failed while we were waiting for media access, release media
  1000.                     if (!cacheLocalResources) {
  1001.                         releaseLocalMedia(localDisplay, mediaProvider);
  1002.                     }
  1003.                     return;
  1004.                 }
  1005.                 //create mediaProvider connection
  1006.                 MediaProvider[mediaProvider].createConnection({
  1007.                     id: id_,
  1008.                     localDisplay: localDisplay,
  1009.                     remoteDisplay: remoteDisplay,
  1010.                     authToken: authToken,
  1011.                     mainUrl: urlServer,
  1012.                     flashProto: flashProto,
  1013.                     flashPort: flashPort,
  1014.                     bidirectional: true,
  1015.                     login: login,
  1016.                     constraints: constraints,
  1017.                     connectionConfig: mediaOptions,
  1018.                     audioOutputId: audioOutputId,
  1019.                     videoContentHint: videoContentHint,
  1020.                     useControls: useControls,
  1021.                     logger: logger
  1022.                 }).then(function (newConnection) {
  1023.                     mediaConnection = newConnection;
  1024.                     return mediaConnection.createOffer({
  1025.                         sendAudio: true,
  1026.                         sendVideo: true,
  1027.                         receiveAudio: receiveAudio,
  1028.                         receiveVideo: receiveVideo,
  1029.                         stripCodecs: stripCodecs
  1030.                     });
  1031.                 }).then(function (offer) {
  1032.                     let callData = {
  1033.                         callId: id_,
  1034.                         incoming: false,
  1035.                         hasVideo: offer.hasVideo,
  1036.                         hasAudio: offer.hasAudio,
  1037.                         status: status_,
  1038.                         mediaProvider: mediaProvider,
  1039.                         sdp: offer.sdp,
  1040.                         sipSDP: sipSDP,
  1041.                         caller: login,
  1042.                         callee: callee_,
  1043.                         custom: options.custom,
  1044.                         visibleName: visibleName_
  1045.                     };
  1046.                     // Get local media info to send in publishStream message
  1047.                     if (collectDeviceInfo) {
  1048.                         callData.localMediaInfo = collectLocalMediaInfo(MediaProvider[mediaProvider], localDisplay);
  1049.                     }
  1050.                     send("call", callData);
  1051.                 });
  1052.             }).catch(function (error) {
  1053.                 logger.error(LOG_PREFIX, error);
  1054.                 status_ = CALL_STATUS.FAILED;
  1055.                 info_ = ERROR_INFO.LOCAL_ERROR;
  1056.                 errorInfo_ = error.message;
  1057.                 callRefreshHandlers[id_]({status: CALL_STATUS.FAILED});
  1058.                 hangup();
  1059.             });
  1060.         };
  1062.         /**
  1063.          * Hangup call.
  1064.          *
  1065.          * @memberof Call
  1066.          * @inner
  1067.          */
  1068.         var hangup = function () {
  1069.             if (status_ == CALL_STATUS.NEW) {
  1070.                 callRefreshHandlers[id_]({status: CALL_STATUS.FAILED});
  1071.                 return;
  1072.             } else if (status_ == CALL_STATUS.PENDING) {
  1073.                 if (!cacheLocalResources) {
  1074.                     releaseLocalMedia(localDisplay, mediaProvider);
  1075.                 }
  1076.                 callRefreshHandlers[id_]({status: CALL_STATUS.FAILED});
  1077.                 if (options.incoming) {
  1078.                     send("hangup", {
  1079.                         callId: id_
  1080.                     });
  1081.                 }
  1082.                 return;
  1083.             }
  1085.             send("hangup", {
  1086.                 callId: id_
  1087.             });
  1088.             //free media provider
  1089.             if (mediaConnection) {
  1090.                 mediaConnection.close(cacheLocalResources);
  1091.             }
  1092.         };
  1094.         /**
  1095.          * @callback sdpHook
  1096.          * @param {Object} sdp Callback options
  1097.          * @param {String} sdp.sdpString Sdp from the server
  1098.          * @returns {String} sdp New sdp
  1099.          */
  1101.         /**
  1102.          * Answer incoming call.
  1103.          * @param {Object} answerOptions Call options
  1104.          * @param {HTMLElement} answerOptions.localVideoDisplay Div element local video should be displayed in
  1105.          * @param {HTMLElement} answerOptions.remoteVideoDisplay Div element remote video should be displayed in
  1106.          * @param {Boolean=} answerOptions.receiveAudio Receive audio
  1107.          * @param {Boolean=} answerOptions.receiveVideo Receive video
  1108.          * @param {String=} answerOptions.constraints Answer call with constraints
  1109.          * @param {String=} answerOptions.stripCodecs Comma separated string of codecs which should be stripped from WebRTC SDP (ex. "SILK,G722")
  1110.          * @param {Array<string>=} answerOptions.sipSDP Array of custom SDP params (ex. bandwidth (b=))
  1111.          * @param {Array<string>=} answerOptions.sipHeaders Array of custom SIP headers
  1112.          * @param {sdpHook} sdpHook The callback that handles sdp from the server
  1113.          * @throws {Error} Error if call status is not {@link Flashphoner.constants.CALL_STATUS.NEW}
  1114.          * @memberof Call
  1115.          * @name call
  1116.          * @inner
  1117.          */
  1118.         var answer = function (answerOptions) {
  1119.             if (status_ !== CALL_STATUS.NEW && status_ !== CALL_STATUS.RING) {
  1120.                 throw new Error("Invalid call state");
  1121.             }
  1122.             localDisplay = answerOptions.localVideoDisplay;
  1123.             remoteDisplay = answerOptions.remoteVideoDisplay;
  1124.             constraints = answerOptions.constraints || getDefaultMediaConstraints();
  1125.             status_ = CALL_STATUS.PENDING;
  1126.             var sdp;
  1127.             var sdpHook = answerOptions.sdpHook;
  1128.             var minBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MIN_BITRATE, 0);
  1129.             var maxBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MAX_BITRATE, 0);
  1130.             sipSDP = answerOptions.sipSDP;
  1131.             sipHeaders = answerOptions.sipHeaders;
  1132.             if (!remoteSdpCache[id_]) {
  1133.                 logger.error(LOG_PREFIX, "No remote sdp available");
  1134.                 throw new Error("No remote sdp available");
  1135.             } else {
  1136.                 sdp = sdpHookHandler(remoteSdpCache[id_], sdpHook);
  1137.                 // Adjust publishing bitrate #WCS-4013
  1138.                 sdp = util.setPublishingBitrate(sdp, null, minBitrate, maxBitrate);
  1139.                 delete remoteSdpCache[id_];
  1140.             }
  1141.             if (util.SDP.matchPrefix(sdp, "m=video").length == 0) {
  1142.                 constraints.video = false;
  1143.             }
  1144.             var stripCodecs = answerOptions.stripCodecs || [];
  1145.             var hasAudio = true;
  1146.             //get access to camera
  1147.             MediaProvider[mediaProvider].getMediaAccess(constraints, localDisplay, disableConstraintsNormalization).then(function () {
  1148.                 if (status_ == CALL_STATUS.FAILED) {
  1149.                     //call failed while we were waiting for media access, release media
  1150.                     if (!cacheLocalResources) {
  1151.                         releaseLocalMedia(localDisplay, mediaProvider);
  1152.                     }
  1153.                     return;
  1154.                 }
  1155.                 //create mediaProvider connection
  1156.                 MediaProvider[mediaProvider].createConnection({
  1157.                     id: id_,
  1158.                     localDisplay: localDisplay,
  1159.                     remoteDisplay: remoteDisplay,
  1160.                     authToken: authToken,
  1161.                     mainUrl: urlServer,
  1162.                     flashProto: flashProto,
  1163.                     flashPort: flashPort,
  1164.                     bidirectional: true,
  1165.                     login: cConfig.sipLogin,
  1166.                     constraints: constraints,
  1167.                     connectionConfig: mediaOptions,
  1168.                     audioOutputId: audioOutputId,
  1169.                     useControls: useControls
  1170.                 }).then(function (newConnection) {
  1171.                     mediaConnection = newConnection;
  1172.                     // Set publishing bitrate via sender encodings if SDP feature is not supported
  1173.                     mediaConnection.setPublishingBitrate(minBitrate, maxBitrate);
  1174.                     return mediaConnection.setRemoteSdp(sdp);
  1175.                 }).then(function () {
  1176.                     return mediaConnection.createAnswer({
  1177.                         receiveAudio: options.receiveAudio,
  1178.                         receiveVideo: options.receiveVideo,
  1179.                         stripCodecs: stripCodecs
  1180.                     });
  1181.                 }).then(function (sdp) {
  1182.                     if (status_ != CALL_STATUS.FINISH && status_ != CALL_STATUS.FAILED) {
  1183.                         let callData = {
  1184.                             callId: id_,
  1185.                             incoming: true,
  1186.                             hasVideo: true,
  1187.                             hasAudio: hasAudio,
  1188.                             status: status_,
  1189.                             mediaProvider: mediaProvider,
  1190.                             sdp: sdp,
  1191.                             sipSDP: sipSDP,
  1192.                             caller: cConfig.login,
  1193.                             callee: callee_,
  1194.                             custom: options.custom
  1195.                         };
  1196.                         // Get local media info to send in publishStream message
  1197.                         if (collectDeviceInfo) {
  1198.                             callData.localMediaInfo = collectLocalMediaInfo(MediaProvider[mediaProvider], localDisplay);
  1199.                         }
  1200.                         send("answer", callData);
  1201.                     } else {
  1202.                         hangup();
  1203.                     }
  1204.                 });
  1205.             }).catch(function (error) {
  1206.                 logger.error(LOG_PREFIX, error);
  1207.                 info_ = ERROR_INFO.LOCAL_ERROR;
  1208.                 errorInfo_ = error.message;
  1209.                 status_ = CALL_STATUS.FAILED;
  1210.                 callRefreshHandlers[id_]({status: CALL_STATUS.FAILED});
  1211.             });
  1212.         };
  1214.         /**
  1215.          * Get call status.
  1216.          *
  1217.          * @returns {string} One of {@link Flashphoner.constants.CALL_STATUS}
  1218.          * @memberof Call
  1219.          * @inner
  1220.          */
  1221.         var status = function () {
  1222.             return status_;
  1223.         };
  1225.         /**
  1226.          * Get call id.
  1227.          *
  1228.          * @returns {string} Call id
  1229.          * @memberof Call
  1230.          * @inner
  1231.          */
  1232.         var id = function () {
  1233.             return id_;
  1234.         };
  1235.         /**
  1236.          * Get caller id.
  1237.          *
  1238.          * @returns {string} Caller id
  1239.          * @memberof Call
  1240.          * @inner
  1241.          */
  1242.         var caller = function () {
  1243.             return caller_;
  1244.         };
  1245.         /**
  1246.          * Get callee id.
  1247.          *
  1248.          * @returns {string} Callee id
  1249.          * @memberof Call
  1250.          * @inner
  1251.          */
  1252.         var callee = function () {
  1253.             return callee_;
  1254.         };
  1255.         /**
  1256.          * Get caller visible name.
  1257.          *
  1258.          * @returns {string} Caller visible name
  1259.          * @memberof Call
  1260.          * @inner
  1261.          */
  1262.         var visibleName = function () {
  1263.             return visibleName_;
  1264.         };
  1265.         /**
  1266.          * Media controls
  1267.          */
  1269.         /**
  1270.          * Set other oupout audio device
  1271.          *
  1272.          * @param {string} id Id of output device
  1273.          * @memberof Call
  1274.          * @inner
  1275.          */
  1276.         var setAudioOutputId = function(id) {
  1277.             audioOutputId = id;
  1278.             if (mediaConnection && mediaConnection.setAudioOutputId) {
  1279.                 return mediaConnection.setAudioOutputId(id);
  1280.             }
  1281.         };
  1283.         /**
  1284.          * Set volume of remote media
  1285.          *
  1286.          * @param {number} volume Volume between 0 and 100
  1287.          * @memberof Call
  1288.          * @inner
  1289.          */
  1290.         var setVolume = function (volume) {
  1291.             if (mediaConnection) {
  1292.                 mediaConnection.setVolume(volume);
  1293.             }
  1294.         };
  1296.         /**
  1297.          * Get current volume
  1298.          *
  1299.          * @returns {number} Volume or -1 if audio is not available
  1300.          * @memberof Call
  1301.          * @inner
  1302.          */
  1303.         var getVolume = function () {
  1304.             if (mediaConnection) {
  1305.                 return mediaConnection.getVolume();
  1306.             }
  1307.             return -1;
  1308.         };
  1310.         /**
  1311.          * Mute outgoing audio
  1312.          *
  1313.          * @memberof Call
  1314.          * @inner
  1315.          */
  1316.         var muteAudio = function () {
  1317.             if (mediaConnection) {
  1318.                 mediaConnection.muteAudio();
  1319.             }
  1320.         };
  1322.         /**
  1323.          * Unmute outgoing audio
  1324.          *
  1325.          * @memberof Call
  1326.          * @inner
  1327.          */
  1328.         var unmuteAudio = function () {
  1329.             if (mediaConnection) {
  1330.                 mediaConnection.unmuteAudio();
  1331.             }
  1332.         };
  1334.         /**
  1335.          * Check outgoing audio mute state
  1336.          *
  1337.          * @returns {boolean} True if audio is muted or not available
  1338.          * @memberof Call
  1339.          * @inner
  1340.          */
  1341.         var isAudioMuted = function () {
  1342.             if (mediaConnection) {
  1343.                 return mediaConnection.isAudioMuted();
  1344.             }
  1345.             return true;
  1346.         };
  1348.         /**
  1349.          * Mute outgoing video
  1350.          *
  1351.          * @memberof Call
  1352.          * @inner
  1353.          */
  1354.         var muteVideo = function () {
  1355.             if (mediaConnection) {
  1356.                 mediaConnection.muteVideo();
  1357.             }
  1358.         };
  1360.         /**
  1361.          * Unmute outgoing video
  1362.          *
  1363.          * @memberof Call
  1364.          * @inner
  1365.          */
  1366.         var unmuteVideo = function () {
  1367.             if (mediaConnection) {
  1368.                 mediaConnection.unmuteVideo();
  1369.             }
  1370.         };
  1372.         /**
  1373.          * Check outgoing video mute state
  1374.          *
  1375.          * @returns {boolean} True if video is muted or not available
  1376.          * @memberof Call
  1377.          * @inner
  1378.          */
  1379.         var isVideoMuted = function () {
  1380.             if (mediaConnection) {
  1381.                 return mediaConnection.isVideoMuted();
  1382.             }
  1383.             return true;
  1384.         };
  1385.         /**
  1386.          * @callback callbackFn
  1387.          * @param {Object} result
  1388.          */
  1389.         /**
  1390.          * Get statistics
  1391.          *
  1392.          * @param {callbackFn} callbackFn The callback that handles response
  1393.          * @param {Boolean} nativeStats  If true, use native browser statistics
  1394.          * @returns {Object} Call audio\video statistics
  1395.          * @memberof Call
  1396.          * @inner
  1397.          */
  1398.         var getStats = function (callbackFn, nativeStats) {
  1399.             if (mediaConnection) {
  1400.                 mediaConnection.getStats(callbackFn, nativeStats);
  1401.             }
  1402.         };
  1403.         /**
  1404.          * Place call on hold
  1405.          *
  1406.          * @memberof Call
  1407.          * @inner
  1408.          */
  1409.         var hold = function () {
  1410.             send("hold", {callId: id_});
  1411.         }
  1412.         /**
  1413.          * Place call on hold for transfer
  1414.          *
  1415.          * @memberof Call
  1416.          * @inner
  1417.          */
  1418.         var holdForTransfer = function () {
  1419.             send("hold", {callId: id_, holdForTransfer: true});
  1420.         }
  1421.         /**
  1422.          * Unhold the call
  1423.          *
  1424.          * @memberof Call
  1425.          * @inner
  1426.          */
  1427.         var unhold = function () {
  1428.             send("unhold", {callId: id_});
  1429.         }
  1430.         /**
  1431.          * Send DTMF
  1432.          *
  1433.          * @param {number} number Number
  1434.          * @param {string=} type DTMF Type (RFC2833, INFO, INFO_RELAY)
  1435.          * @memberof Call
  1436.          * @inner
  1437.          */
  1438.         var sendDTMF = function (number, type) {
  1439.             send("sendDtmf", {
  1440.                 callId: id_,
  1441.                 type: type || "RFC2833",
  1442.                 dtmf: number
  1443.             });
  1444.         }
  1445.         /**
  1446.          * Transfer call
  1447.          *
  1448.          * @param {String} traget Transfer target
  1449.          * @memberof Call
  1450.          * @inner
  1451.          */
  1452.         var transfer = function (target) {
  1453.             send("transfer", {callId: id_, target: target});
  1454.         }
  1455.         /**
  1456.          * Call event callback.
  1457.          *
  1458.          * @callback Call~eventCallback
  1459.          * @param {Call} call Call that corresponds to the event
  1460.          */
  1462.         /**
  1463.          * Add call event callback.
  1464.          *
  1465.          * @param {string} event One of {@link Flashphoner.constants.CALL_STATUS} events
  1466.          * @param {Call~eventCallback} callback Callback function
  1467.          * @returns {Call} Call callback was attached to
  1468.          * @throws {TypeError} Error if event is not specified
  1469.          * @throws {Error} Error if callback is not a valid function
  1470.          * @memberof Call
  1471.          * @inner
  1472.          */
  1473.         var on = function (event, callback) {
  1474.             if (!event) {
  1475.                 throw new TypeError("Event can't be null");
  1476.             }
  1477.             if (!callback || typeof callback !== 'function') {
  1478.                 throw new Error("Callback needs to be a valid function");
  1479.             }
  1480.             callbacks[event] = callback;
  1481.             return call;
  1482.         };
  1484.         /**
  1485.          * Switch camera in real-time.
  1486.          * Works only with WebRTC
  1487.          *
  1488.          * @memberOf Call
  1489.          * @inner
  1490.          * @throws {Error} Error if call status is not {@link Flashphoner.constants.CALL_STATUS.ESTABLISHED} and not {@link Flashphoner.constants.CALL_STATUS.HOLD}
  1491.          */
  1492.         var switchCam = function(deviceId) {
  1493.             if(status_ !== CALL_STATUS.ESTABLISHED && !constraints.video && status_ !== CALL_STATUS.HOLD){
  1494.                 throw new Error('Invalid call state');
  1495.             }
  1496.             return mediaConnection.switchCam(deviceId);
  1497.         };
  1499.         /**
  1500.          * Switch mic in real-time.
  1501.          * Works only with WebRTC
  1502.          *
  1503.          * @memberOf Call
  1504.          * @inner
  1505.          * @throws {Error} Error if call status is not {@link Flashphoner.constants.CALL_STATUS.ESTABLISHED} and not {@link Flashphoner.constants.CALL_STATUS.HOLD}
  1506.          */
  1507.         var switchMic = function(deviceId) {
  1508.             if(status_ !== CALL_STATUS.ESTABLISHED && status_ !== CALL_STATUS.HOLD){
  1509.                 throw new Error('Invalid call state');
  1510.             }
  1511.             return mediaConnection.switchMic(deviceId);
  1512.         };
  1514.         /**
  1515.          * Switch to screen in real-time.
  1516.          * Works only with WebRTC
  1517.          *
  1518.          * @param {String} source Screen sharing source (for firefox)
  1519.          * @param {Boolean} woExtension Screen sharing without extension (for chrome)
  1520.          * @memberOf Call
  1521.          * @inner
  1522.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  1523.          */
  1524.         var switchToScreen = function (source, woExtension) {
  1525.             if(status_ !== CALL_STATUS.ESTABLISHED && status_ !== CALL_STATUS.HOLD){
  1526.                 throw new Error('Invalid call state');
  1527.             }
  1528.             return mediaConnection.switchToScreen(source, woExtension);
  1529.         };
  1531.         /**
  1532.          * Switch to cam in real-time.
  1533.          * Works only with WebRTC
  1534.          *
  1535.          * @memberOf Call
  1536.          * @inner
  1537.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  1538.          */
  1539.         var switchToCam = function () {
  1540.             if(status_ !== CALL_STATUS.ESTABLISHED && status_ !== CALL_STATUS.HOLD){
  1541.                 throw new Error('Invalid call state');
  1542.             }
  1543.             mediaConnection.switchToCam();
  1544.         };
  1546.         /**
  1547.          * Get call info
  1548.          * @returns {string} Info
  1549.          * @memberof Call
  1550.          * @inner
  1551.          */
  1552.         var getInfo = function () {
  1553.             return info_;
  1554.         };
  1556.         /**
  1557.          * Get stream error info
  1558.          * @returns {string} Error info
  1559.          * @memberof Call
  1560.          * @inner
  1561.          */
  1562.         var getErrorInfo = function () {
  1563.             return errorInfo_;
  1564.         };
  1566.         /**
  1567.          * Get call logger
  1568.          *
  1569.          * @returns {Object} Logger
  1570.          * @memberof Call
  1571.          */
  1572.         var getLogger = function () {
  1573.             return callLogger;
  1574.         };
  1576.         call.call = call_;
  1577.         call.answer = answer;
  1578.         call.hangup = hangup;
  1579.         call.id = id;
  1580.         call.getInfo = getInfo;
  1581.         call.getErrorInfo = getErrorInfo;
  1582.         call.status = status;
  1583.         call.getStats = getStats;
  1584.         call.setAudioOutputId = setAudioOutputId;
  1585.         call.setVolume = setVolume;
  1586.         call.getVolume = getVolume;
  1587.         call.muteAudio = muteAudio;
  1588.         call.unmuteAudio = unmuteAudio;
  1589.         call.isAudioMuted = isAudioMuted;
  1590.         call.muteVideo = muteVideo;
  1591.         call.unmuteVideo = unmuteVideo;
  1592.         call.isVideoMuted = isVideoMuted;
  1593.         call.caller = caller;
  1594.         call.callee = callee;
  1595.         call.visibleName = visibleName;
  1596.         call.hold = hold;
  1597.         call.holdForTransfer = holdForTransfer;
  1598.         call.unhold = unhold;
  1599.         call.sendDTMF = sendDTMF;
  1600.         call.transfer = transfer;
  1601.         call.on = on;
  1602.         call.switchCam = switchCam;
  1603.         call.switchMic = switchMic;
  1604.         call.switchToScreen = switchToScreen;
  1605.         call.switchToCam = switchToCam;
  1606.         call.getLogger = getLogger;
  1607.         calls[id_] = call;
  1608.         return call;
  1609.     };
  1611.     /**
  1612.      * @callback sdpHook
  1613.      * @param {Object} sdp Callback options
  1614.      * @param {String} sdp.sdpString Sdp from the server
  1615.      * @returns {String} sdp New sdp
  1616.      */
  1618.     /**
  1619.      * Create stream.
  1620.      *
  1621.      * @param {Object} options Stream options
  1622.      * @param {string} options.name Stream name
  1623.      * @param {Object=} options.constraints Stream constraints
  1624.      * @param {Boolean|Object} [options.constraints.audio=true] Specifies if published stream should have audio. Played stream always should have audio: the property should not be set to false in that case.
  1625.      * @param {string=} [options.constraints.audio.outputId] Set width to publish or play stream with this value
  1626.      * @param {Boolean|Object} [options.constraints.video=true] Specifies if published or played stream should have video, or sets video constraints
  1627.      * @param {Integer} [options.constraints.video.width=0] Set width to publish or play stream with this value
  1628.      * @param {Integer} [options.constraints.video.height=0] Set height to publish or play stream with this value
  1629.      * @param {Integer} [options.constraints.video.bitrate=0] DEPRECATED FOR PUBLISH: Set bitrate to publish or play stream with this value
  1630.      * @param {Integer} [options.constraints.video.minBitrate=0] Set minimal bitrate to publish stream with this value
  1631.      * @param {Integer} [options.constraints.video.maxBitrate=0] Set maximal bitrate to publish stream with this value
  1632.      * @param {Integer} [options.constraints.video.quality=0] Set quality to play stream with this value
  1633.      * @param {MediaStream} [options.constraints.customStream] Set a MediaStream  for publish stream from canvas.
  1634.      * @param {Boolean=} options.receiveAudio DEPRECATED: Receive audio
  1635.      * @param {Boolean=} options.receiveVideo DEPRECATED: Receive video
  1636.      * @param {Integer=} options.playWidth DEPRECATED: Set width to play stream with this value
  1637.      * @param {Integer=} options.playHeight DEPRECATED: Set height to play stream with this value
  1638.      * @param {string=} options.mediaProvider MediaProvider type to use with this stream
  1639.      * @param {Boolean} [options.record=false] Enable stream recording
  1640.      * @param {Boolean=} options.cacheLocalResources Display will contain local video after stream release
  1641.      * @param {HTMLElement} options.display Div element stream should be displayed in
  1642.      * @param {Object=} options.custom User provided custom object that will be available in REST App code
  1643.      * @param {Integer} [options.flashBufferTime=0] Specifies how long to buffer messages before starting to display the stream (Flash-only)
  1644.      * @param {string=} options.stripCodecs Comma separated string of codecs which should be stripped from WebRTC SDP (ex. "H264,PCMA,PCMU,G722")
  1645.      * @param {string=} options.rtmpUrl Rtmp url stream should be forwarded to
  1646.      * @param {Object=} options.mediaConnectionConstraints Stream specific constraints for underlying RTCPeerConnection
  1647.      * @param {Boolean=} options.flashShowFullScreenButton Show full screen button in flash
  1648.      * @param {string=} options.transport Transport to be used by server for WebRTC media, {@link Flashphoner.constants.TRANSPORT_TYPE}
  1649.      * @param {Boolean=} options.cvoExtension Enable rtp video orientation extension
  1650.      * @param {Integer=} options.playoutDelay Time delay between network reception of media and playout
  1651.      * @param {string=} options.useCanvasMediaStream EXPERIMENTAL: when publish bind browser's media stream to the canvas. It can be useful for image filtering
  1652.      * @param {string=} options.videoContentHint Video content hint for browser ('motion' by default to maintain bitrate and fps), {@link Flashphoner.constants.CONTENT_HINT_TYPE}
  1653.      * @param {Boolean=} options.unmutePlayOnStart Unmute playback on start. May be used after user gesture only, so set 'unmutePlayOnStart: false' for autoplay
  1654.      * @param {Boolean=} options.useControls Use a standard HTML5 video controls (play, pause, fullscreen). May be a workaround for fullscreen mode to work in Safari 16
  1655.      * @param {Object=} options.logger Stream logger options
  1656.      * @param {Boolean=} options.collectDeviceInfo Collect a media devices info when publishing a WebRTC stream
  1657.      * @param {sdpHook} sdpHook The callback that handles sdp from the server
  1658.      * @returns {Stream} Stream
  1659.      * @throws {TypeError} Error if no options provided
  1660.      * @throws {TypeError} Error if options.name is not specified
  1661.      * @throws {Error} Error if session state is not ESTABLISHED
  1662.      * @memberof Session
  1663.      * @inner
  1664.      */
  1665.     var createStream = function (options) {
  1667.         //Array to transmit promises from stream.available() to streamRefreshHandlers
  1668.         var availableCallbacks = [];
  1669.         //check session state
  1670.         if (sessionStatus !== SESSION_STATUS.ESTABLISHED) {
  1671.             throw new Error('Invalid session state ' + sessionStatus);
  1672.         }
  1674.         //check options
  1675.         if (!options) {
  1676.             throw new TypeError("options must be provided");
  1677.         }
  1678.         if (!options.name) {
  1679.             throw new TypeError("options.name must be provided");
  1680.         }
  1682.         // Set stream logger #WCS-2434
  1683.         var streamLogger = createLogger(options.logger, sessionLogger);
  1684.         // Override logger for all low level operations
  1685.         var logger = streamLogger;
  1687.         var clientKf = new KalmanFilter();
  1688.         var serverKf = new KalmanFilter();
  1690.         var id_ = uuid_v1();
  1691.         var name_ = options.name;
  1692.         var mediaProvider = options.mediaProvider || getMediaProviders()[0];
  1693.         var mediaConnection;
  1694.         var display = options.display;
  1695.         // Constraints
  1696.         if (options.constraints && Object.keys(options.constraints).length != 0) {
  1697.             var constraints = options.constraints;
  1698.         }
  1699.         if (options.disableConstraintsNormalization) {
  1700.             var disableConstraintsNormalization = options.disableConstraintsNormalization;
  1701.         }
  1703.         var mediaConnectionConstraints = options.mediaConnectionConstraints;
  1704.         // Receive media
  1705.         var receiveAudio;
  1706.         var audioOutputId;
  1707.         var audioProperty = getConstraintsProperty(constraints, CONSTRAINT_AUDIO, undefined);
  1708.         if (typeof audioProperty === 'boolean') {
  1709.             receiveAudio = audioProperty;
  1710.         } else if (typeof audioProperty === 'object') {
  1711.             receiveAudio = true;
  1712.             var _stereo = getConstraintsProperty(audioProperty, CONSTRAINT_AUDIO_STEREO, 0);
  1713.             var _bitrate = getConstraintsProperty(audioProperty, CONSTRAINT_AUDIO_BITRATE, 0);
  1714.             var _fec = getConstraintsProperty(audioProperty, CONSTRAINT_AUDIO_FEC, 0);
  1715.             audioOutputId = getConstraintsProperty(audioProperty, CONSTRAINT_AUDIO_OUTPUT_ID, 0);
  1716.             var _codecOptions = "";
  1717.             if (_bitrate) _codecOptions += "maxaveragebitrate=" + _bitrate + ";";
  1718.             if (_stereo) _codecOptions += "stereo=1;sprop-stereo=1;";
  1719.             if (_fec) _codecOptions += "useinbandfec=1;";
  1720.         } else {
  1721.             receiveAudio = (typeof options.receiveAudio !== 'undefined') ? options.receiveAudio : true;
  1722.         }
  1723.         var receiveVideo;
  1724.         var videoProperty = getConstraintsProperty(constraints, CONSTRAINT_VIDEO, undefined);
  1725.         if (typeof videoProperty === 'boolean') {
  1726.             receiveVideo = videoProperty;
  1727.         } else if (typeof videoProperty === 'object') {
  1728.             receiveVideo = true;
  1729.         } else {
  1730.             receiveVideo = (typeof options.receiveVideo !== 'undefined') ? options.receiveVideo : true;
  1731.         }
  1732.         // Bitrate
  1733.         var bitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_BITRATE, 0);
  1734.         var minBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MIN_BITRATE, 0);
  1735.         var maxBitrate = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_MAX_BITRATE, 0);
  1737.         // Quality
  1738.         var quality = getConstraintsProperty(constraints, CONSTRAINT_VIDEO_QUALITY, 0);
  1739.         if (quality > 100) quality = 100;
  1740.         // Play resolution
  1741.         var playWidth = (typeof options.playWidth !== 'undefined') ? options.playWidth : getConstraintsProperty(constraints, CONSTRAINT_VIDEO_WIDTH, 0);
  1742.         var playHeight = (typeof options.playHeight !== 'undefined') ? options.playHeight : getConstraintsProperty(constraints, CONSTRAINT_VIDEO_HEIGHT, 0);
  1743.         var stripCodecs = options.stripCodecs || [];
  1744.         var resolution = {};
  1746.         var published_ = false;
  1747.         var record_ = options.record || false;
  1748.         var recordFileName = null;
  1749.         var cacheLocalResources = options.cacheLocalResources;
  1750.         var status_ = STREAM_STATUS.NEW;
  1751.         var rtmpUrl = options.rtmpUrl;
  1752.         var info_;
  1753.         var errorInfo_;
  1754.         var remoteBitrate = -1;
  1755.         var networkBandwidth = -1;
  1756.         var sdpHook = options.sdpHook;
  1757.         var transportType = options.transport;
  1758.         var cvoExtension = options.cvoExtension;
  1759.         var remoteVideo = options.remoteVideo;
  1760.         //callbacks added using stream.on()
  1761.         var callbacks = {};
  1762.         var playoutDelay = options.playoutDelay;
  1763.         var useCanvasMediaStream = options.useCanvasMediaStream;
  1764.         var videoContentHint = options.videoContentHint;
  1765.         var unmutePlayOnStart = options.unmutePlayOnStart;
  1766.         var useControls = options.useControls;
  1767.         var collectDeviceInfo = options.collectDeviceInfo !== undefined ? options.collectDeviceInfo : true;
  1769.         var audioState_;
  1770.         var videoState_;
  1772.         var connectionQuality;
  1774.         var videoBytes = 0;
  1776.         /**
  1777.          * Represents media stream.
  1778.          *
  1779.          * @namespace Stream
  1780.          * @see Session~createStream
  1781.          */
  1782.         var stream = {};
  1784.         streamEventRefreshHandlers[id_] = function (streamEvent) {
  1785.             if (streamEvent.type == STREAM_EVENT_TYPE.NOT_ENOUGH_BANDWIDTH) {
  1786.                 var info = streamEvent.payload.info.split("/");
  1787.                 remoteBitrate = info[0];
  1788.                 networkBandwidth = info[1];
  1789.             } else if (streamEvent.type == STREAM_EVENT_TYPE.RESIZE) {
  1790.                 resolution.width = streamEvent.payload.streamerVideoWidth;
  1791.                 resolution.height = streamEvent.payload.streamerVideoHeight;
  1792.             }
  1793.             if (callbacks[STREAM_EVENT]) {
  1794.                 callbacks[STREAM_EVENT](streamEvent);
  1795.             }
  1796.         }
  1798.         streamRefreshHandlers[id_] = function (streamInfo, sdp) {
  1799.             //set remote sdp
  1800.             if (sdp && sdp !== '') {
  1801.                 var _sdp = sdp;
  1802.                 if (_codecOptions) _sdp = util.SDP.writeFmtp(sdp, _codecOptions, "opus");
  1803.                 _sdp = sdpHookHandler(_sdp, sdpHook);
  1804.                 // Adjust publishing bitrate #WCS-4013
  1805.                 _sdp = util.setPublishingBitrate(_sdp, mediaConnection, minBitrate, maxBitrate);
  1806.                 mediaConnection.setRemoteSdp(_sdp).then(function () {});
  1807.                 return;
  1808.             }
  1810.             if (streamInfo.available != undefined) {
  1811.                 for (var i = 0; i < availableCallbacks.length; i++) {
  1812.                     info_ = streamInfo.reason;
  1813.                     if (streamInfo.available == "true") {
  1814.                         availableCallbacks[i].resolve(stream);
  1815.                     } else {
  1816.                         availableCallbacks[i].reject(stream);
  1817.                     }
  1818.                 }
  1819.                 availableCallbacks = [];
  1820.                 return;
  1821.             }
  1823.             var event = streamInfo.status;
  1825.             if (event === INBOUND_VIDEO_RATE || event === OUTBOUND_VIDEO_RATE) {
  1826.                 detectConnectionQuality(event, streamInfo);
  1827.                 return;
  1828.             }
  1830.             if (event === STREAM_EVENT) {
  1831.                 if (!streamInfo.mediaSessionId)
  1832.                     streamInfo.mediaSessionId = id_;
  1833.                 streamEventRefreshHandlers[id_](streamInfo);
  1834.                 return;
  1835.             }
  1837.             //Deprecated. WCS-3228: RESIZE, SNAPSHOT_COMPLETE and NOT_ENOUGH_BANDWIDTH moved to STREAM_EVENT
  1838.             if (event === STREAM_STATUS.RESIZE) {
  1839.                 resolution.width = streamInfo.streamerVideoWidth;
  1840.                 resolution.height = streamInfo.streamerVideoHeight;
  1841.             } else if (event === STREAM_STATUS.SNAPSHOT_COMPLETE) {
  1843.             } else if (event === STREAM_STATUS.NOT_ENOUGH_BANDWIDTH) {
  1844.                 var info = streamInfo.info.split("/");
  1845.                 remoteBitrate = info[0];
  1846.                 networkBandwidth = info[1];
  1847.             } else {
  1848.                 status_ = event;
  1849.             }
  1851.             if (streamInfo.audioState)
  1852.                 audioState_ = streamInfo.audioState;
  1853.             if (streamInfo.videoState)
  1854.                 videoState_ = streamInfo.videoState;
  1856.             if (streamInfo.info)
  1857.                 info_ = streamInfo.info;
  1859.             //release stream
  1860.             if (event === STREAM_STATUS.FAILED || event === STREAM_STATUS.STOPPED ||
  1861.                 event === STREAM_STATUS.UNPUBLISHED) {
  1863.                 delete streams[id_];
  1864.                 delete streamRefreshHandlers[id_];
  1865.                 delete streamEventRefreshHandlers[id_];
  1866.                 if (mediaConnection) {
  1867.                     mediaConnection.close(cacheLocalResources);
  1868.                 }
  1869.             }
  1870.             if (record_ && typeof streamInfo.recordName !== 'undefined') {
  1871.                 recordFileName = streamInfo.recordName;
  1872.             }
  1873.             //fire stream event
  1874.             if (callbacks[event]) {
  1875.                 callbacks[event](stream);
  1876.             }
  1877.         };
  1879.         var detectConnectionQuality = function (event, streamInfo) {
  1880.             if (disableConnectionQualityCalculation) {
  1881.                 return;
  1882.             }
  1883.             mediaConnection.getStats(function (stats) {
  1884.                 var bytesSentReceived = 0;
  1885.                 if (stats) {
  1886.                     if (event == OUTBOUND_VIDEO_RATE && stats.inboundStream && stats.inboundStream.video && stats.inboundStream.video.bytesReceived > 0) {
  1887.                         bytesSentReceived = stats.inboundStream.video.bytesReceived;
  1888.                     } else if (stats.outboundStream && stats.outboundStream.video && stats.outboundStream.video.bytesSent > 0) {
  1889.                         bytesSentReceived = stats.outboundStream.video.bytesSent;
  1890.                     } else {
  1891.                         return;
  1892.                     }
  1893.                 }
  1895.                 if (!videoBytes) {
  1896.                     videoBytes = bytesSentReceived;
  1897.                     return;
  1898.                 }
  1900.                 var currentVideoRate = ((bytesSentReceived - videoBytes) * 8);
  1901.                 if (currentVideoRate == 0) {
  1902.                     return;
  1903.                 }
  1905.                 var clientFiltered = clientKf.filter(currentVideoRate);
  1906.                 var serverFiltered = serverKf.filter(streamInfo.videoRate);
  1908.                 var videoRateDifference = Math.abs((serverFiltered - clientFiltered) / ((serverFiltered + clientFiltered) / 2)) * 100;
  1909.                 var currentQuality;
  1910.                 if (serverFiltered < LOW_VIDEO_RATE_THRESHOLD_BAD_PERFECT || clientFiltered < LOW_VIDEO_RATE_THRESHOLD_BAD_PERFECT) {
  1911.                     if (videoRateDifference > LOW_VIDEO_RATE_BAD_QUALITY_PERCENT_DIFFERENCE) {
  1912.                         currentQuality = CONNECTION_QUALITY.BAD;
  1913.                     } else {
  1914.                         currentQuality = CONNECTION_QUALITY.PERFECT;
  1915.                     }
  1916.                 } else {
  1917.                     if (videoRateDifference > VIDEO_RATE_BAD_QUALITY_PERCENT_DIFFERENCE) {
  1918.                         currentQuality = CONNECTION_QUALITY.BAD;
  1919.                     } else if (videoRateDifference > VIDEO_RATE_GOOD_QUALITY_PERCENT_DIFFERENCE) {
  1920.                         currentQuality = CONNECTION_QUALITY.GOOD;
  1921.                     } else {
  1922.                         currentQuality = CONNECTION_QUALITY.PERFECT;
  1923.                     }
  1924.                 }
  1925.                 if (callbacks[CONNECTION_QUALITY.UPDATE]) {
  1926.                     connectionQuality = currentQuality;
  1927.                     callbacks[CONNECTION_QUALITY.UPDATE](connectionQuality, clientFiltered, serverFiltered);
  1928.                 }
  1929.                 videoBytes = bytesSentReceived;
  1930.             });
  1931.             return;
  1932.         };
  1934.         /**
  1935.          * Play stream.
  1936.          *
  1937.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.NEW}
  1938.          * @memberof Stream
  1939.          * @inner
  1940.          */
  1941.         var play = function () {
  1942.             logger.debug(LOG_PREFIX, "Play stream " + name_);
  1943.             if (status_ !== STREAM_STATUS.NEW) {
  1944.                 throw new Error("Invalid stream state " + status_);
  1945.             }
  1946.             status_ = STREAM_STATUS.PENDING;
  1947.             //create mediaProvider connection
  1948.             MediaProvider[mediaProvider].createConnection({
  1949.                 id: id_,
  1950.                 display: display,
  1951.                 authToken: authToken,
  1952.                 mainUrl: urlServer,
  1953.                 flashProto: flashProto,
  1954.                 flashPort: flashPort,
  1955.                 flashBufferTime: options.flashBufferTime || 0,
  1956.                 flashShowFullScreenButton: options.flashShowFullScreenButton || false,
  1957.                 connectionConfig: mediaOptions,
  1958.                 connectionConstraints: mediaConnectionConstraints,
  1959.                 audioOutputId: audioOutputId,
  1960.                 remoteVideo: remoteVideo,
  1961.                 playoutDelay: playoutDelay,
  1962.                 unmutePlayOnStart: unmutePlayOnStart,
  1963.                 useControls: useControls,
  1964.                 logger: logger,
  1965.                 unmuteRequiredEvent: fireUnmuteEvent
  1966.             }, streamRefreshHandlers[id_]).then(function (newConnection) {
  1967.                 mediaConnection = newConnection;
  1968.                 try {
  1969.                     streamRefreshHandlers[id_]({status: status_});
  1970.                 } catch(e) {
  1971.                     console.warn(e);
  1972.                 }
  1973.                 return mediaConnection.createOffer({
  1974.                     receiveAudio: receiveAudio,
  1975.                     receiveVideo: receiveVideo,
  1976.                     stripCodecs: stripCodecs,
  1977.                     stereo: _stereo
  1978.                 });
  1979.             }).then(function (offer) {
  1980.                 logger.debug(LOG_PREFIX, "Offer SDP:\n" + offer.sdp);
  1981.                 //request stream with offer sdp from server
  1982.                 send("playStream", {
  1983.                     mediaSessionId: id_,
  1984.                     name: name_,
  1985.                     published: published_,
  1986.                     hasVideo: true,
  1987.                     hasAudio: true,
  1988.                     status: status_,
  1989.                     record: false,
  1990.                     width: playWidth,
  1991.                     height: playHeight,
  1992.                     mediaProvider: mediaProvider,
  1993.                     sdp: offer.sdp,
  1994.                     custom: options.custom,
  1995.                     bitrate: bitrate,
  1996.                     minBitrate: minBitrate,
  1997.                     maxBitrate: maxBitrate,
  1998.                     quality: quality,
  1999.                     constraints: constraints,
  2000.                     transport: transportType,
  2001.                     cvoExtension: cvoExtension
  2002.                 });
  2003.                 if (offer.player) {
  2004.                     offer.player.play(id_);
  2005.                 }
  2006.             }).catch(function (error) {
  2007.                 //todo fire stream failed status
  2008.                 throw error;
  2009.             });
  2010.         };
  2012.         /**
  2013.          * Publish stream.
  2014.          *
  2015.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.NEW}
  2016.          * @memberof Stream
  2017.          * @inner
  2018.          */
  2019.         var publish = function () {
  2020.             logger.debug(LOG_PREFIX, "Publish stream " + name_);
  2021.             if (status_ !== STREAM_STATUS.NEW) {
  2022.                 throw new Error("Invalid stream state " + status_);
  2023.             }
  2024.             status_ = STREAM_STATUS.PENDING;
  2025.             published_ = true;
  2026.             var hasAudio = true;
  2028.             if (constraints && constraints.video && constraints.video.type && constraints.video.type == "screen") {
  2029.                 hasAudio = false;
  2030.             }
  2032.             //get access to camera
  2033.             MediaProvider[mediaProvider].getMediaAccess(constraints, display, disableConstraintsNormalization, useCanvasMediaStream).then(function () {
  2034.                 if (status_ == STREAM_STATUS.FAILED) {
  2035.                     //stream failed while we were waiting for media access, release media
  2036.                     if (!cacheLocalResources) {
  2037.                         releaseLocalMedia(display, mediaProvider);
  2038.                     }
  2039.                     return;
  2040.                 }
  2042.                 //create mediaProvider connection
  2043.                 MediaProvider[mediaProvider].createConnection({
  2044.                     id: id_,
  2045.                     display: display,
  2046.                     authToken: authToken,
  2047.                     mainUrl: urlServer,
  2048.                     flashProto: flashProto,
  2049.                     flashPort: flashPort,
  2050.                     constraints: constraints,
  2051.                     connectionConfig: mediaOptions,
  2052.                     connectionConstraints: mediaConnectionConstraints,
  2053.                     customStream: constraints && constraints.customStream ? constraints.customStream : false,
  2054.                     videoContentHint: videoContentHint,
  2055.                     useControls: useControls,
  2056.                     logger: logger
  2057.                 }).then(function (newConnection) {
  2058.                     mediaConnection = newConnection;
  2059.                     return mediaConnection.createOffer({
  2060.                         stripCodecs: stripCodecs
  2061.                     });
  2062.                 }).then(function (offer) {
  2063.                     logger.debug(LOG_PREFIX, "Offer SDP:\n" + offer.sdp);
  2064.                     let publishStreamData = {
  2065.                         mediaSessionId: id_,
  2066.                         name: name_,
  2067.                         published: published_,
  2068.                         hasVideo: offer.hasVideo,
  2069.                         hasAudio: offer.hasAudio,
  2070.                         status: status_,
  2071.                         record: record_,
  2072.                         mediaProvider: mediaProvider,
  2073.                         sdp: offer.sdp,
  2074.                         custom: options.custom,
  2075.                         bitrate: bitrate,
  2076.                         minBitrate: minBitrate,
  2077.                         maxBitrate: maxBitrate,
  2078.                         rtmpUrl: rtmpUrl,
  2079.                         constraints: constraints,
  2080.                         transport: transportType,
  2081.                         cvoExtension: cvoExtension
  2082.                     };
  2083.                     // Get local media info to send in publishStream message
  2084.                     if (collectDeviceInfo) {
  2085.                         publishStreamData.localMediaInfo = collectLocalMediaInfo(MediaProvider[mediaProvider], display);
  2086.                     }
  2087.                     //publish stream with offer sdp to server
  2088.                     send("publishStream", publishStreamData);
  2089.                 });
  2090.             }).catch(function (error) {
  2091.                 logger.warn(LOG_PREFIX, error);
  2092.                 info_ = ERROR_INFO.LOCAL_ERROR;
  2093.                 errorInfo_ = error.message;
  2094.                 status_ = STREAM_STATUS.FAILED;
  2095.                 //fire stream event
  2096.                 if (callbacks[status_]) {
  2097.                     callbacks[status_](stream);
  2098.                 }
  2099.             });
  2100.         };
  2102.         /**
  2103.          * Switch camera in real-time.
  2104.          * Works only with WebRTC
  2105.          *
  2106.          * @memberOf Stream
  2107.          * @inner
  2108.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2109.          */
  2110.         var switchCam = function(deviceId) {
  2111.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2112.                 throw new Error('Invalid stream state');
  2113.             }
  2114.             return mediaConnection.switchCam(deviceId);
  2115.         };
  2117.         /**
  2118.          * Switch microphone in real-time.
  2119.          * Works only with WebRTC
  2120.          *
  2121.          * @memberOf Stream
  2122.          * @inner
  2123.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2124.          */
  2125.         var switchMic = function(deviceId) {
  2126.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2127.                 throw new Error('Invalid stream state');
  2128.             }
  2129.             return mediaConnection.switchMic(deviceId);
  2130.         };
  2133.         /**
  2134.          * Switch to screen in real-time.
  2135.          * Works only with WebRTC
  2136.          *
  2137.          * @param {String} source Screen sharing source (for firefox)
  2138.          * @param {Boolean} woExtension Screen sharing without extension (for chrome)
  2139.          * @memberOf Stream
  2140.          * @inner
  2141.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2142.          */
  2143.         var switchToScreen = function (source, woExtension) {
  2144.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2145.                 throw new Error('Invalid stream state');
  2146.             }
  2147.             return mediaConnection.switchToScreen(source, woExtension);
  2148.         };
  2150.         /**
  2151.          * Switch to cam in real-time.
  2152.          * Works only with WebRTC
  2153.          *
  2154.          * @memberOf Stream
  2155.          * @inner
  2156.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2157.          */
  2158.         var switchToCam = function () {
  2159.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2160.                 throw new Error('Invalid stream state');
  2161.             }
  2162.             mediaConnection.switchToCam();
  2163.         };
  2166.         /**
  2167.          * Send data from published stream.
  2168.          *
  2169.          * @param {Object} payload Any object
  2170.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2171.          * @memberof Stream
  2172.          * @inner
  2173.          */
  2174.         var sendData = function (payload) {
  2175.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2176.                 throw new Error('Invalid stream state');
  2177.             }
  2178.             sendStreamEvent(STREAM_EVENT_TYPE.DATA, payload);
  2179.         };
  2182.         /**
  2183.          * Unmute remote audio
  2184.          *
  2185.          * @memberOf Stream
  2186.          * @inner
  2187.          */
  2188.         var unmuteRemoteAudio = function () {
  2189.             if(mediaConnection && mediaProvider != 'Flash') {
  2190.                 mediaConnection.unmuteRemoteAudio();
  2191.             }
  2192.         };
  2194.         /**
  2195.          * Mute remote audio
  2196.          *
  2197.          * @memberOf Stream
  2198.          * @inner
  2199.          */
  2200.         var muteRemoteAudio = function () {
  2201.             if(mediaConnection && mediaProvider != 'Flash') {
  2202.                 mediaConnection.muteRemoteAudio();
  2203.             }
  2204.         };
  2206.         /**
  2207.          * Is remote audio muted
  2208.          *
  2209.          * @memberOf Stream
  2210.          * @inner
  2211.          */
  2212.         var isRemoteAudioMuted = function () {
  2213.           if(mediaConnection && mediaProvider != 'Flash') {
  2214.               return mediaConnection.isRemoteAudioMuted();
  2215.           }
  2216.           return false;
  2217.         };
  2219.         /**
  2220.          * Set Microphone Gain
  2221.          *
  2222.          * @memberOf Stream
  2223.          * @inner
  2224.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.PUBLISHING}
  2225.          */
  2226.         var setMicrophoneGain = function (volume) {
  2227.             if(status_ !== STREAM_STATUS.PUBLISHING){
  2228.                 throw new Error('Invalid stream state');
  2229.             }
  2230.             mediaConnection.setMicrophoneGain(volume);
  2231.         };
  2233.         /**
  2234.          * Stop stream.
  2235.          *
  2236.          * @memberof Stream
  2237.          * @inner
  2238.          */
  2239.         var stop = function () {
  2240.             logger.debug(LOG_PREFIX, "Stop stream " + name_);
  2241.             if (status_ == STREAM_STATUS.NEW) {
  2242.                 //trigger FAILED status
  2243.                 streamRefreshHandlers[id_]({status: STREAM_STATUS.FAILED});
  2244.                 return;
  2245.             } else if (status_ == STREAM_STATUS.PENDING) {
  2246.                 logger.warn(LOG_PREFIX, "Stopping stream before server response " + id_);
  2247.                 setTimeout(stop, 200);
  2248.                 return;
  2249.             } else if (status_ == STREAM_STATUS.FAILED) {
  2250.                 logger.warn(LOG_PREFIX, "Stream status FAILED");
  2251.                 return;
  2252.             }
  2253.             if (published_) {
  2254.                 send("unPublishStream", {
  2255.                     mediaSessionId: id_,
  2256.                     name: name_,
  2257.                     published: published_,
  2258.                     hasVideo: true,
  2259.                     hasAudio: true,
  2260.                     status: status_,
  2261.                     record: false
  2262.                 });
  2263.             } else {
  2264.                 send("stopStream", {
  2265.                     mediaSessionId: id_,
  2266.                     name: name_,
  2267.                     published: published_,
  2268.                     hasVideo: true,
  2269.                     hasAudio: true,
  2270.                     status: status_,
  2271.                     record: false
  2272.                 });
  2273.             }
  2274.             //free media provider
  2275.             if (mediaConnection) {
  2276.                 mediaConnection.close(cacheLocalResources);
  2277.             }
  2278.         };
  2280.         /**
  2281.          * Request remote stream snapshot.
  2282.          * @throws {Error} Error if stream status is not {@link Flashphoner.constants.STREAM_STATUS.NEW}
  2283.          * @memberof Stream
  2284.          * @inner
  2285.          */
  2286.         var snapshot = function () {
  2287.             logger.debug(LOG_PREFIX, "Request snapshot, stream " + name_);
  2288.             if (status_ !== STREAM_STATUS.NEW && status_ !== STREAM_STATUS.PLAYING && status_ !== STREAM_STATUS.PUBLISHING) {
  2289.                 throw new Error("Invalid stream state");
  2290.             }
  2291.             send("snapshot", {
  2292.                 name: name_,
  2293.                 mediaSessionId: id_
  2294.             });
  2295.         };
  2297.         /**
  2298.          * Get stream status.
  2299.          *
  2300.          * @returns {string} One of {@link Flashphoner.constants.STREAM_STATUS}
  2301.          * @memberof Stream
  2302.          * @inner
  2303.          */
  2304.         var status = function () {
  2305.             return status_;
  2306.         };
  2308.         /**
  2309.          * Get stream id.
  2310.          *
  2311.          * @returns {string} Stream id
  2312.          * @memberof Stream
  2313.          * @inner
  2314.          */
  2315.         var id = function () {
  2316.             return id_;
  2317.         };
  2319.         /**
  2320.          * Get stream name.
  2321.          *
  2322.          * @returns {string} Stream name
  2323.          * @memberof Stream
  2324.          * @inner
  2325.          */
  2326.         var name = function () {
  2327.             return name_;
  2328.         };
  2330.         /**
  2331.          * Is stream published.
  2332.          *
  2333.          * @returns {Boolean} True if stream published, otherwise false
  2334.          * @memberof Stream
  2335.          * @inner
  2336.          */
  2337.         var published = function () {
  2338.             return published_;
  2339.         };
  2341.         /**
  2342.          * Get record file name
  2343.          * @returns {string} File name
  2344.          * @memberof Stream
  2345.          * @inner
  2346.          */
  2347.         var getRecordInfo = function () {
  2348.             return recordFileName;
  2349.         };
  2351.         /**
  2352.          * Get stream info
  2353.          * @returns {string} Info
  2354.          * @memberof Stream
  2355.          * @inner
  2356.          */
  2357.         var getInfo = function () {
  2358.             return info_;
  2359.         };
  2361.         /**
  2362.          * Get stream error info
  2363.          * @returns {string} Error info
  2364.          * @memberof Stream
  2365.          * @inner
  2366.          */
  2367.         var getErrorInfo = function () {
  2368.             return errorInfo_;
  2369.         };
  2371.         /**
  2372.          * Get stream video size
  2373.          * @returns {Object} Video size
  2374.          * @memberof Stream
  2375.          * @inner
  2376.          */
  2377.         var videoResolution = function () {
  2378.             if (!published_) {
  2379.                 return resolution;
  2380.             } else {
  2381.                 throw new Error("This function available only on playing stream");
  2382.             }
  2383.         };
  2385.         /**
  2386.          * Media controls
  2387.          */
  2389.         /**
  2390.          * Set other oupout audio device
  2391.          *
  2392.          * @param {string} id Id of output device
  2393.          * @memberof Call
  2394.          * @inner
  2395.          */
  2396.         var setAudioOutputId = function(id) {
  2397.             audioOutputId = id;
  2398.             if (mediaConnection && mediaConnection.setAudioOutputId) {
  2399.                 return mediaConnection.setAudioOutputId(id);
  2400.             }
  2401.         };
  2403.         /**
  2404.          * Set volume of remote media
  2405.          *
  2406.          * @param {number} volume Volume between 0 and 100
  2407.          * @memberof Stream
  2408.          * @inner
  2409.          */
  2410.         var setVolume = function (volume) {
  2411.             if (mediaConnection) {
  2412.                 mediaConnection.setVolume(volume);
  2413.             }
  2414.         };
  2416.         /**
  2417.          * Get current volume
  2418.          *
  2419.          * @returns {number} Volume or -1 if audio is not available
  2420.          * @memberof Stream
  2421.          * @inner
  2422.          */
  2423.         var getVolume = function () {
  2424.             if (mediaConnection) {
  2425.                 return mediaConnection.getVolume();
  2426.             }
  2427.             return -1;
  2428.         };
  2430.         function sendStreamEvent(type, payload) {
  2431.             send("sendStreamEvent", {
  2432.                 mediaSessionId: id_,
  2433.                 type: type,
  2434.                 payload: payload
  2435.             });
  2436.         }
  2438.         /**
  2439.          * Mute outgoing audio
  2440.          *
  2441.          * @memberof Stream
  2442.          * @inner
  2443.          */
  2444.         var muteAudio = function () {
  2445.             if (mediaConnection) {
  2446.                 mediaConnection.muteAudio();
  2447.                 sendStreamEvent(STREAM_EVENT_TYPE.AUDIO_MUTED);
  2448.             }
  2449.         };
  2451.         /**
  2452.          * Unmute outgoing audio
  2453.          *
  2454.          * @memberof Stream
  2455.          * @inner
  2456.          */
  2457.         var unmuteAudio = function () {
  2458.             if (mediaConnection) {
  2459.                 mediaConnection.unmuteAudio();
  2460.                 sendStreamEvent(STREAM_EVENT_TYPE.AUDIO_UNMUTED);
  2461.             }
  2462.         };
  2464.         /**
  2465.          * Check outgoing audio mute state
  2466.          *
  2467.          * @returns {boolean} True if audio is muted or not available
  2468.          * @memberof Stream
  2469.          * @inner
  2470.          */
  2471.         var isAudioMuted = function () {
  2472.             if (mediaConnection) {
  2473.                 return mediaConnection.isAudioMuted();
  2474.             }
  2475.             return true;
  2476.         };
  2478.         /**
  2479.          * Mute outgoing video
  2480.          *
  2481.          * @memberof Stream
  2482.          * @inner
  2483.          */
  2484.         var muteVideo = function () {
  2485.             if (mediaConnection) {
  2486.                 mediaConnection.muteVideo();
  2487.                 sendStreamEvent(STREAM_EVENT_TYPE.VIDEO_MUTED);
  2488.             }
  2489.         };
  2491.         /**
  2492.          * Unmute outgoing video
  2493.          *
  2494.          * @memberof Stream
  2495.          * @inner
  2496.          */
  2497.         var unmuteVideo = function () {
  2498.             if (mediaConnection) {
  2499.                 mediaConnection.unmuteVideo();
  2500.                 sendStreamEvent(STREAM_EVENT_TYPE.VIDEO_UNMUTED);
  2502.             }
  2503.         };
  2505.         /**
  2506.          * Check outgoing video mute state
  2507.          *
  2508.          * @returns {boolean} True if video is muted or not available
  2509.          * @memberof Stream
  2510.          * @inner
  2511.          */
  2512.         var isVideoMuted = function () {
  2513.             if (mediaConnection) {
  2514.                 return mediaConnection.isVideoMuted();
  2515.             }
  2516.             return true;
  2517.         };
  2519.         /**
  2520.          * Get statistics
  2521.          *
  2522.          * @param {callbackFn} callbackFn The callback that handles response
  2523.          * @param {Boolean} nativeStats If true, use native browser statistics
  2524.          * @returns {Object} Stream audio\video statistics
  2525.          * @memberof Stream
  2526.          * @inner
  2527.          */
  2528.         var getStats = function (callbackFn, nativeStats) {
  2529.             if (mediaConnection) {
  2530.                 mediaConnection.getStats(callbackFn, nativeStats);
  2531.             }
  2532.         };
  2534.         /**
  2535.          * Get remote bitrate reported by server, works only for subscribe Stream
  2536.          *
  2537.          * @returns {number} Remote bitrate in bps or -1
  2538.          * @memberof Stream
  2539.          * @inner
  2540.          */
  2541.         var getRemoteBitrate = function () {
  2542.             return remoteBitrate;
  2543.         };
  2545.         /**
  2546.          * Get network bandwidth reported by server, works only for subscribe Stream
  2547.          *
  2548.          * @returns {number} Network bandwidth in bps or -1
  2549.          * @memberof Stream
  2550.          * @inner
  2551.          */
  2552.         var getNetworkBandwidth = function () {
  2553.             return networkBandwidth;
  2554.         };
  2556.         /**
  2557.          * Get audio state (muted)
  2558.          *
  2559.          * @returns AudioState
  2560.          * @memberof Stream
  2561.          * @inner
  2562.          */
  2563.         var getAudioState = function () {
  2564.             return audioState_;
  2565.         };
  2567.         /**
  2568.          * Get video state (muted)
  2569.          *
  2570.          * @returns VideoState
  2571.          * @memberof Stream
  2572.          * @inner
  2573.          */
  2574.         var getVideoState = function () {
  2575.             return videoState_;
  2576.         };
  2577.         /**
  2578.          * Request full screen for player stream
  2579.          * @memberof Stream
  2580.          * @inner
  2581.          */
  2582.         var fullScreen = function () {
  2583.             if (published()) {
  2584.                 logger.warn(LOG_PREFIX, "Full screen is allowed only for played streams");
  2585.             } else {
  2586.                 if (mediaConnection)
  2587.                     mediaConnection.fullScreen();
  2588.             }
  2589.         };
  2591.         /**
  2592.          * Stream status event callback.
  2593.          *
  2594.          * @callback Stream~eventCallback
  2595.          * @param {Stream} stream Stream that corresponds to the event
  2596.          */
  2598.         /**
  2599.          * Add stream status event callback.
  2600.          *
  2601.          * @param {string} event One of {@link Flashphoner.constants.STREAM_STATUS} events
  2602.          * @param {Stream~eventCallback} callback Callback function
  2603.          * @returns {Stream} Stream callback was attached to
  2604.          * @throws {TypeError} Error if event is not specified
  2605.          * @throws {Error} Error if callback is not a valid function
  2606.          * @memberof Stream
  2607.          * @inner
  2608.          */
  2609.         var on = function (event, callback) {
  2610.             if (!event) {
  2611.                 throw new TypeError("Event can't be null");
  2612.             }
  2613.             if (!callback || typeof callback !== 'function') {
  2614.                 throw new Error("Callback needs to be a valid function");
  2615.             }
  2616.             callbacks[event] = callback;
  2617.             return stream;
  2618.         };
  2620.         /**
  2621.          * Сhecks the availability of stream on the server
  2622.          *
  2623.          * @returns {Promise} Resolves if is stream available, otherwise rejects
  2624.          * @memberof Stream
  2625.          * @inner
  2626.          */
  2627.         var available = function(){
  2628.             return new Promise(function(resolve, reject){
  2629.                 send("availableStream", {
  2630.                     mediaSessionId: id_,
  2631.                     name: name_
  2632.                 });
  2633.                 var promise = {};
  2634.                 promise.resolve = resolve;
  2635.                 promise.reject = reject;
  2636.                 availableCallbacks.push(promise);
  2637.             });
  2638.         };
  2640.         /**
  2641.          * Get stream logger
  2642.          *
  2643.          * @returns {Object} Logger
  2644.          * @memberof Stream
  2645.          */
  2646.         var getLogger = function () {
  2647.             return streamLogger;
  2648.         };
  2650.         var fireUnmuteEvent = function() {
  2651.             if (isRemoteAudioMuted()) {
  2652.                 if (streamRefreshHandlers[id_] && typeof streamRefreshHandlers[id_] === 'function') {
  2653.                     streamRefreshHandlers[id_]({status: STREAM_EVENT, type: STREAM_EVENT_TYPE.UNMUTE_REQUIRED});
  2654.                 }
  2655.             }
  2656.         };
  2658.         stream.play = play;
  2659.         stream.publish = publish;
  2660.         stream.stop = stop;
  2661.         stream.id = id;
  2662.         stream.status = status;
  2663.         stream.name = name;
  2664.         stream.published = published;
  2665.         stream.getRecordInfo = getRecordInfo;
  2666.         stream.getInfo = getInfo;
  2667.         stream.getErrorInfo = getErrorInfo;
  2668.         stream.videoResolution = videoResolution;
  2669.         stream.setAudioOutputId = setAudioOutputId;
  2670.         stream.setVolume = setVolume;
  2671.         stream.unmuteRemoteAudio = unmuteRemoteAudio;
  2672.         stream.muteRemoteAudio = muteRemoteAudio;
  2673.         stream.isRemoteAudioMuted = isRemoteAudioMuted;
  2674.         stream.setMicrophoneGain = setMicrophoneGain;
  2675.         stream.getVolume = getVolume;
  2676.         stream.muteAudio = muteAudio;
  2677.         stream.unmuteAudio = unmuteAudio;
  2678.         stream.isAudioMuted = isAudioMuted;
  2679.         stream.muteVideo = muteVideo;
  2680.         stream.unmuteVideo = unmuteVideo;
  2681.         stream.isVideoMuted = isVideoMuted;
  2682.         stream.getStats = getStats;
  2683.         stream.snapshot = snapshot;
  2684.         stream.getAudioState = getAudioState;
  2685.         stream.getVideoState = getVideoState;
  2686.         stream.getNetworkBandwidth = getNetworkBandwidth;
  2687.         stream.getRemoteBitrate = getRemoteBitrate;
  2688.         stream.fullScreen = fullScreen;
  2689.         stream.on = on;
  2690.         stream.available = available;
  2691.         stream.switchCam = switchCam;
  2692.         stream.switchMic = switchMic;
  2693.         stream.switchToScreen = switchToScreen;
  2694.         stream.switchToCam = switchToCam;
  2695.         stream.sendData = sendData;
  2696.         stream.getLogger = getLogger;
  2698.         streams[id_] = stream;
  2699.         return stream;
  2701.     };
  2703.     /**
  2704.      * Disconnect session.
  2705.      *
  2706.      * @memberof Session
  2707.      * @inner
  2708.      */
  2709.     var disconnect = function () {
  2710.         if (wsConnection) {
  2711.             wsConnection.close();
  2712.         }
  2713.     };
  2715.     /**
  2716.      * Get session id
  2717.      *
  2718.      * @returns {string} session id
  2719.      * @memberof Session
  2720.      * @inner
  2721.      */
  2722.     var id = function () {
  2723.         return id_;
  2724.     };
  2726.     /**
  2727.      * Get server address
  2728.      *
  2729.      * @returns {string} Server url
  2730.      * @memberof Session
  2731.      * @inner
  2732.      */
  2733.     var getServerUrl = function () {
  2734.         return urlServer;
  2735.     };
  2737.     /**
  2738.      * Get session status
  2739.      *
  2740.      * @returns {string} One of {@link Flashphoner.constants.SESSION_STATUS}
  2741.      * @memberof Session
  2742.      * @inner
  2743.      */
  2744.     var status = function () {
  2745.         return sessionStatus;
  2746.     };
  2748.     /**
  2749.      * Get stream by id.
  2750.      *
  2751.      * @param {string} streamId Stream id
  2752.      * @returns {Stream} Stream
  2753.      * @memberof Session
  2754.      * @inner
  2755.      */
  2756.     var getStream = function (streamId) {
  2757.         return streams[streamId];
  2758.     };
  2760.     /**
  2761.      * Get streams.
  2762.      *
  2763.      * @returns {Array<Stream>} Streams
  2764.      * @memberof Session
  2765.      * @inner
  2766.      */
  2767.     var getStreams = function () {
  2768.         return util.copyObjectToArray(streams);
  2769.     };
  2771.     /**
  2772.      * Submit bug report.
  2773.      *
  2774.      * @param {Object} reportObject Report object
  2775.      * @memberof Session
  2776.      * @inner
  2777.      */
  2778.     var submitBugReport = function (reportObject) {
  2779.         send("submitBugReport", reportObject);
  2780.     }
  2782.     /**
  2783.      * Start session debug
  2784.      * @memberof Session
  2785.      * @inner
  2786.      */
  2788.     var startDebug = function () {
  2789.         logger.setPushLogs(true);
  2790.         logger.setLevel("DEBUG");
  2791.         send("sessionDebug", {command: "start"});
  2792.     }
  2794.     /**
  2795.      * Stop session debug
  2796.      * @memberof Session
  2797.      * @inner
  2798.      */
  2800.     var stopDebug = function () {
  2801.         logger.setLevel("INFO");
  2802.         send("sessionDebug", {command: "stop"});
  2803.     }
  2805.     /**
  2806.      * Session event callback.
  2807.      *
  2808.      * @callback Session~eventCallback
  2809.      * @param {Session} session Session that corresponds to the event
  2810.      */
  2812.     /**
  2813.      * Add session event callback.
  2814.      *
  2815.      * @param {string} event One of {@link Flashphoner.constants.SESSION_STATUS} events
  2816.      * @param {Session~eventCallback} callback Callback function
  2817.      * @returns {Session} Session
  2818.      * @throws {TypeError} Error if event is not specified
  2819.      * @throws {Error} Error if callback is not a valid function
  2820.      * @memberof Session
  2821.      * @inner
  2822.      */
  2823.     var on = function (event, callback) {
  2824.         if (!event) {
  2825.             throw new Error("Event can't be null", "TypeError");
  2826.         }
  2827.         if (!callback || typeof callback !== 'function') {
  2828.             throw new Error("Callback needs to be a valid function");
  2829.         }
  2830.         callbacks[event] = callback;
  2831.         return session;
  2832.     };
  2834.     var restAppCommunicator = function () {
  2835.         var pending = {};
  2836.         var exports = {};
  2837.         /**
  2838.          * Send data to REST App
  2839.          *
  2840.          * @param {Object} data Object to send
  2841.          * @returns {Promise} Resolves if data accepted, otherwise rejects
  2842.          * @memberof Session
  2843.          * @name sendData
  2844.          * @method
  2845.          * @inner
  2846.          */
  2847.         exports.sendData = function (data) {
  2848.             return new Promise(function (resolve, reject) {
  2849.                 var obj = {
  2850.                     operationId: uuid_v1(),
  2851.                     payload: data
  2852.                 };
  2853.                 pending[obj.operationId] = {
  2854.                     FAILED: function (info) {
  2855.                         reject(info);
  2856.                     },
  2857.                     ACCEPTED: function (info) {
  2858.                         resolve(info);
  2859.                     }
  2860.                 };
  2861.                 send("sendData", obj);
  2862.             });
  2863.         };
  2864.         exports.resolveData = function (data) {
  2865.             if (pending[data.operationId]) {
  2866.                 var handler = pending[data.operationId];
  2867.                 delete pending[data.operationId];
  2868.                 delete data.operationId;
  2869.                 handler[data.status](data);
  2870.             }
  2871.         };
  2872.         return exports;
  2873.     }();
  2875.     var sdpHookHandler = function(sdp, sdpHook){
  2876.         if (sdpHook != undefined && typeof sdpHook == 'function') {
  2877.             var sdpObject = {sdpString: sdp};
  2878.             var newSdp = sdpHook(sdpObject);
  2879.             if (newSdp != null && newSdp != "") {
  2880.                 return newSdp;
  2881.             }
  2882.             return sdp;
  2883.         }
  2884.         return sdp;
  2885.     }
  2887.     /**
  2888.      * Get session logger
  2889.      *
  2890.      * @returns {Object} Logger
  2891.      * @memberof Session
  2892.     */
  2893.     var getLogger = function () {
  2894.         return sessionLogger;
  2895.     };
  2897.     const collectLocalMediaInfo = function (mediaProvider, display) {
  2898.         // Get devices available
  2899.         let videoCams = [];
  2900.         let mics = [];
  2902.         if (mediaProvider.videoCams) {
  2903.             mediaProvider.videoCams.forEach((device) => {
  2904.                 videoCams.push({
  2905.                     id: device.id,
  2906.                     label: encodeURI(device.label),
  2907.                     type: device.type
  2908.                 });
  2909.             });
  2910.         }
  2912.         if (mediaProvider.mics) {
  2913.             mediaProvider.mics.forEach((device) => {
  2914.                 mics.push({
  2915.                     id: device.id,
  2916.                     label: encodeURI(device.label),
  2917.                     type: device.type
  2918.                 });
  2919.             });
  2920.         }
  2922.         if (videoCams.length) {
  2923.             logger.info(LOG_PREFIX, "Video inputs available: " + JSON.stringify(videoCams));
  2924.         }
  2925.         if (mics.length) {
  2926.             logger.info(LOG_PREFIX, "Audio inputs available: " + JSON.stringify(mics));
  2927.         }
  2929.         // Get track labels to identify publishing device
  2930.         let audioTracks = [];
  2931.         let videoTracks = [];
  2932.         let localVideo;
  2933.         if (mediaProvider.getCacheInstance) {
  2934.             localVideo = mediaProvider.getCacheInstance(display);
  2935.         }
  2936.         if (!localVideo && mediaProvider.getVideoElement) {
  2937.             localVideo = mediaProvider.getVideoElement(display);
  2938.         }
  2939.         // PR #19 from GitHub to prevent Sentry issue #WCS-4239
  2940.         if (localVideo && localVideo.srcObject) {
  2941.             localVideo.srcObject.getAudioTracks().forEach((track) => {
  2942.                 let device = track.label;
  2943.                 if (device === "MediaStreamAudioDestinationNode" && mediaProvider.getAudioSourceDevice) {
  2944.                     device = mediaProvider.getAudioSourceDevice();
  2945.                 }
  2946.                 audioTracks.push({
  2947.                     trackId: track.id,
  2948.                     device: encodeURI(device)
  2949.                 });
  2950.             });
  2951.             localVideo.srcObject.getVideoTracks().forEach((track) => {
  2952.                 videoTracks.push({
  2953.                     trackId: track.id,
  2954.                     device: encodeURI(track.label)
  2955.                 });
  2956.             });
  2957.         }
  2958.         if (videoTracks.length) {
  2959.             logger.info(LOG_PREFIX, "Video tracks captured: " + JSON.stringify(videoTracks));
  2960.         }
  2961.         if (audioTracks.length) {
  2962.             logger.info(LOG_PREFIX, "Audio tracks captured: " + JSON.stringify(audioTracks));
  2963.         }
  2965.         return {
  2966.             devices: {
  2967.                 video: videoCams,
  2968.                 audio: mics
  2969.             },
  2970.             tracks: {
  2971.                 video: videoTracks,
  2972.                 audio: audioTracks
  2973.             }
  2974.         };
  2975.     }
  2977.     //export Session
  2978.     session.id = id;
  2979.     session.status = status;
  2980.     session.getServerUrl = getServerUrl;
  2981.     session.createStream = createStream;
  2982.     session.createCall = createCall;
  2983.     session.getStream = getStream;
  2984.     session.getStreams = getStreams;
  2985.     session.sendData = restAppCommunicator.sendData;
  2986.     session.disconnect = disconnect;
  2987.     session.submitBugReport = submitBugReport;
  2988.     session.startDebug = startDebug;
  2989.     session.stopDebug = stopDebug;
  2990.     session.on = on;
  2991.     session.getLogger = getLogger;
  2993.     //save interface to global map
  2994.     sessions[id_] = session;
  2995.     return session;
  2996. };
  2998. var isUsingTemasys = function () {
  2999.     return isUsingTemasysPlugin;
  3000. };
  3002. module.exports = {
  3003.     init: init,
  3004.     isUsingTemasys: isUsingTemasys,
  3005.     getMediaProviders: getMediaProviders,
  3006.     getMediaDevices: getMediaDevices,
  3007.     getMediaAccess: getMediaAccess,
  3008.     releaseLocalMedia: releaseLocalMedia,
  3009.     getSessions: getSessions,
  3010.     getSession: getSession,
  3011.     createSession: createSession,
  3012.     playFirstSound: playFirstSound,
  3013.     playFirstVideo: playFirstVideo,
  3014.     getLogger: getLogger,
  3015.     constants: constants,
  3016.     /**
  3017.      * The Screensharing whitelist is no longer needed to share your screen or windows starting Firefox 52
  3018.      * https://wiki.mozilla.org/Screensharing
  3019.      */
  3020.     firefoxScreenSharingExtensionInstalled: true,
  3021.     Browser: util.Browser
  3022. };