@flashphoner/websdk 2.0.271 → 2.0.274

package/flashphoner-room-api.js

@@ -9679,6 +9679,34 @@ var getMediaDevices = function (mediaProvider, labels, kind, deviceConstraints)
     return MediaProvider[mediaProvider].listDevices(labels, kind, deviceConstraints);
 };
 
+/**
+ * Get mobile local media devices
+ *
+ * @param {String=} mediaProvider Media provider that will be asked for device list
+ * @param {Flashphoner.constants.MEDIA_DEVICE_KIND} kind Media devices kind to access:
+ * MEDIA_DEVICE_KIND.INPUT (default) get access to input devices only (camera, mic).
+ * MEDIA_DEVICE_KIND.OUTPUT get access to output devices only (speaker, headphone).
+ * MEDIA_DEVICE_KIND.ALL get access to all devices (cam, mic, speaker, headphone).
+ * @param {Object=} deviceConstraints
+ * If {audio: true, video: false}, then access to the camera will not be requested.
+ * If {audio: false, video: true}, then access to the microphone will not be requested.
+ * @returns {Promise.<Flashphoner.MediaDeviceList>} Promise with media device list on fulfill
+ * @throws {Error} Error if API is not initialized
+ * @memberof Flashphoner
+ */
+var getMobileDevices = function (mediaProvider, kind, deviceConstraints) {
+    if (!initialized) {
+        throw new Error("Flashphoner API is not initialized");
+    }
+    if (!mediaProvider) {
+        mediaProvider = getMediaProviders()[0];
+    }
+    if (MediaProvider[mediaProvider].getMobileDevices) {
+        return MediaProvider[mediaProvider].getMobileDevices(kind, deviceConstraints);
+    }
+    return [];
+};
+
 /**
  * Get access to local media
  *
@@ -10116,33 +10144,19 @@ var createSession = function (options) {
                         streamRefreshHandlers[obj.mediaSessionId](obj);
                     }
                     break;
-                case `webRTCMetricsDescriptionUpdate`:
-                    if (obj.ids) {
-                        obj.ids.forEach((id) => {
-                            if (streamRefreshHandlers[id]) {
-                                streamRefreshHandlers[id](obj);
-                            }
-                        });
-                    } else {
-                        if (obj.compression) {
-                            webRTCMetricsServerDescription.compression = obj.compression;
-                        }
-                        if (obj.batchSize) {
-                            webRTCMetricsServerDescription.batchSize = obj.batchSize;
-                        }
-                        if (obj.sampling) {
-                            webRTCMetricsServerDescription.sampling = obj.sampling;
-                        }
-                        if (obj.types) {
-                            webRTCMetricsServerDescription.types = obj.types;
-                        }
-                        if (obj.collect) {
-                            webRTCMetricsServerDescription.collect = obj.collect;
-                        }
-                        for (const [id, handler] of Object.entries(streamRefreshHandlers)) {
-                            handler(obj);
-                        }
-                    }
+                case 'webRTCMetricsDescriptionUpdate':
+                    handleWebRTCMetricsUpdate(obj, {
+                        compression: "compression",
+                        batchSize: "batchSize",
+                        sampling: "sampling",
+                        types: "types",
+                        collect: "collect"
+                    });
+                    break;
+                case 'webRTCMetricsTokenRefresh':
+                    handleWebRTCMetricsUpdate(obj, {
+                        authorization: "authorization"
+                    });
                     break;
                 default:
                     logger.info(LOG_PREFIX, "Unknown server message " + data.message);
@@ -10153,6 +10167,26 @@ var createSession = function (options) {
         };
     }
 
+    function handleWebRTCMetricsUpdate(obj, updateFields = {}) {
+        if (obj.ids) {
+            obj.ids.forEach((id) => {
+                if (streamRefreshHandlers[id]) {
+                    streamRefreshHandlers[id](obj);
+                }
+            });
+        } else {
+            Object.entries(updateFields).forEach(([key, value]) => {
+                if (obj[value] !== undefined) {
+                    webRTCMetricsServerDescription[key] = obj[value];
+                }
+            });
+
+            for (const [id, handler] of Object.entries(streamRefreshHandlers)) {
+                handler(obj);
+            }
+        }
+    }
+
     //WebSocket send helper
     function send(message, data) {
         if (wsConnection.readyState === WebSocket.OPEN) {
@@ -11306,6 +11340,11 @@ var createSession = function (options) {
                 }
             }
 
+            if (streamInfo.authorization && statsCollector && statsCollector.description.ingestPoint) {
+                statsCollector.description.authorization = streamInfo.authorization;
+                statsCollector.updateHttpConnection(statsCollector.description.ingestPoint, statsCollector.description.authorization);
+            }
+
             // Pause or resume metrics collection
             if (!streamInfo.status && streamInfo.collect !== undefined && statsCollector) {
                 statsCollector.update(streamInfo);
@@ -12526,6 +12565,7 @@ module.exports = {
     isUsingTemasys: isUsingTemasys,
     getMediaProviders: getMediaProviders,
     getMediaDevices: getMediaDevices,
+    getMobileDevices: getMobileDevices,
     getMediaAccess: getMediaAccess,
     releaseLocalMedia: releaseLocalMedia,
     getSessions: getSessions,
@@ -13333,6 +13373,11 @@ const StreamStatsCollector = function(description, id, mediaConnection, wsConnec
                 }
             }
         },
+        updateHttpConnection: function(url, authorization) {
+            if (url.startsWith(CONNECTION_TYPE.HTTP) && authorization) {
+                statCollector.connection.http.setAuthorization(authorization);
+            }
+        },
         checkForCompression: async function(compression) {
             try {
                 await util.compress(compression, "test", false);
@@ -13373,6 +13418,9 @@ const StreamStatsCollector = function(description, id, mediaConnection, wsConnec
                 statCollector.metricsBatch = null;
             }
         },
+        isMetricValid: function(value) {
+            return value != null && value !== "" && value !== "undefined" && value !== "null";
+        },
         collectMetrics: async function() {
             if (statCollector.timer && !statCollector.timerBusy) {
                 // Unfortunately there are no real atomics in JS unless SharedArrayBuffer is used
@@ -13402,7 +13450,7 @@ const StreamStatsCollector = function(description, id, mediaConnection, wsConnec
                                 }
                             }
                         }
-                        if (value) {
+                        if (statCollector.isMetricValid(value)) {
                             metrics.push(value);
                         } else {
                             lostMetrics.push(descriptor);
@@ -13576,6 +13624,9 @@ const HttpConnection = function(url, headers) {
     const connection = {
         url: addSlash(url),
         headers: headers,
+        setAuthorization(token) {
+            this.headers.Authorization = token;
+        },
         send: async function(message, data) {
             let code = CONNECTION_STATUS.BAD_REQUEST;
             if (connection.url) {
@@ -16344,6 +16395,63 @@ var available = function () {
     return ('getUserMedia' in navigator && 'RTCPeerConnection' in window);
 };
 
+/**
+ * Helper function to get media devices list in id, label, type form
+ *
+ * @param devices
+ * @param kind
+ * @param videoFilter
+ * @returns {{audio: *[], video: *[]}}
+ */
+const getList = function (devices, kind, videoFilter = null) {
+    var list = {
+        audio: [],
+        video: []
+    };
+
+    var micCount = 0;
+    var outputCount = 0;
+    var camCount = 0;
+    for (var i = 0; i < devices.length; i++) {
+        var device = devices[i];
+        var ret = {
+            id: device.deviceId,
+            label: device.label
+        };
+        if (device.kind.indexOf("audio" + kind) === 0 && device.deviceId !== "communications") {
+            ret.type = (device.kind === "audioinput") ? "mic" : "speaker";
+            if (ret.type === "mic" && ret.label === "") {
+                ret.label = 'microphone' + ++micCount;
+            }
+            if (ret.type === "speaker" && ret.label === "") {
+                ret.label = 'speaker' + ++outputCount;
+            }
+            list.audio.push(ret);
+        } else if (device.kind.indexOf("video" + kind) === 0) {
+            if (!videoFilter || videoFilter.find((id) => id === device.deviceId)) {
+                if (ret.label === "") {
+                    ret.label = 'camera' + ++camCount;
+                }
+                ret.type = "camera";
+                list.video.push(ret);
+            } else {
+                logger.debug(LOG_PREFIX, "Video device " + device.deviceId + "does not conform the filter " + JSON.stringify(videoFilter));
+            }
+        } else {
+            logger.debug(LOG_PREFIX, "unknown device " + device.kind + " id " + device.deviceId);
+        }
+    }
+    return list;
+}
+
+/**
+ * Get media devices list
+ *
+ * @param labels
+ * @param kind
+ * @param deviceConstraints
+ * @returns {Promise<{audio: [], video: []}>}
+ */
 var listDevices = function (labels, kind, deviceConstraints) {
     //WCS-1963. added deviceConstraints.
     if (!deviceConstraints) {
@@ -16354,7 +16462,7 @@ var listDevices = function (labels, kind, deviceConstraints) {
     }
     if (!kind) {
         kind = constants.MEDIA_DEVICE_KIND.INPUT;
-    } else if (kind == "all") {
+    } else if (kind === constants.MEDIA_DEVICE_KIND.ALL) {
         kind = "";
     }
     var getConstraints = function (devices) {
@@ -16362,9 +16470,9 @@ var listDevices = function (labels, kind, deviceConstraints) {
         for (var i = 0; i < devices.length; i++) {
             var device = devices[i];
             if (device.kind.indexOf("audio" + kind) === 0 && deviceConstraints.audio) {
-                constraints.audio = true;
+                constraints.audio = deviceConstraints.audio;
             } else if (device.kind.indexOf("video" + kind) === 0 && deviceConstraints.video) {
-                constraints.video = true;
+                constraints.video = deviceConstraints.video;
             } else {
                 logger.debug(LOG_PREFIX, "unknown device " + device.kind + " id " + device.deviceId);
             }
@@ -16372,43 +16480,6 @@ var listDevices = function (labels, kind, deviceConstraints) {
         return constraints;
     };
 
-    var getList = function (devices) {
-        var list = {
-            audio: [],
-            video: []
-        };
-
-        var micCount = 0;
-        var outputCount = 0;
-        var camCount = 0;
-        for (var i = 0; i < devices.length; i++) {
-            var device = devices[i];
-            var ret = {
-                id: device.deviceId,
-                label: device.label
-            };
-            if (device.kind.indexOf("audio" + kind) === 0 && device.deviceId != "communications") {
-                ret.type = (device.kind == "audioinput") ? "mic" : "speaker";
-                if (ret.type == "mic" && ret.label == "") {
-                    ret.label = 'microphone' + ++micCount;
-                }
-                if (ret.type == "speaker" && ret.label == "") {
-                    ret.label = 'speaker' + ++outputCount;
-                }
-                list.audio.push(ret);
-            } else if (device.kind.indexOf("video" + kind) === 0) {
-                if (ret.label == "") {
-                    ret.label = 'camera' + ++camCount;
-                }
-                ret.type = "camera";
-                list.video.push(ret);
-            } else {
-                logger.debug(LOG_PREFIX, "unknown device " + device.kind + " id " + device.deviceId);
-            }
-        }
-        return list;
-    };
-
     return new Promise(function (resolve, reject) {
         navigator.mediaDevices.enumerateDevices().then(function (devices) {
             if (labels) {
@@ -16420,19 +16491,96 @@ var listDevices = function (labels, kind, deviceConstraints) {
                 }
                 navigator.getUserMedia(constraints, function (stream) {
                     navigator.mediaDevices.enumerateDevices().then(function (devicesWithLabels) {
-                        resolve(getList(devicesWithLabels));
+                        resolve(getList(devicesWithLabels, kind));
                         stream.getTracks().forEach(function (track) {
                             track.stop();
                         });
                     }, reject);
                 }, reject);
             } else {
-                resolve(getList(devices));
+                resolve(getList(devices, kind));
             }
         }, reject);
-
     });
-};
+}
+
+const getMobileDevices = async function (kind, deviceConstraints = null) {
+    let constraints = {};
+    let videoFilter = [];
+    let list = null;
+    if (!kind) {
+        kind = constants.MEDIA_DEVICE_KIND.INPUT;
+    } else if (kind === constants.MEDIA_DEVICE_KIND.ALL) {
+        kind = "";
+    }
+    if (deviceConstraints && deviceConstraints.audio) {
+        constraints.audio = deviceConstraints.audio;
+    } else {
+        constraints.audio = true;
+    }
+    if (deviceConstraints && deviceConstraints.video) {
+        if (typeof deviceConstraints.video === 'object') {
+            constraints.video = deviceConstraints.video;
+        }
+        else {
+            constraints.video = {};
+        }
+    } else {
+        constraints.video = {};
+    }
+
+    const getCamera = async function (constraints, facingMode) {
+        let deviceId = null;
+        let mediaConstraints = {
+            audio: false,
+            video: constraints.video
+        };
+        mediaConstraints.video.facingMode = facingMode;
+        try {
+            stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
+            if (stream) {
+                if (stream.getVideoTracks().length > 0) {
+                    deviceId = stream.getVideoTracks()[0].getSettings().deviceId;
+                }
+                stream.getTracks().forEach((track) =>  {
+                    track.stop();
+                });
+            }
+        } catch (error) {
+            logger.error(LOG_PREFIX, "Can't get device access with video constraints " + JSON.stringify(constraints.video) + ", error " + error);
+        }
+        return deviceId;
+    }
+
+    let front = await getCamera(constraints, { ideal: 'user' });
+    if (front && front !== "") {
+        logger.debug(LOG_PREFIX, "Front camera id: " + front);
+        videoFilter.push(front);
+    }
+    let back = await getCamera(constraints, { ideal: 'environment' });
+    if (back && back !== "") {
+        logger.debug(LOG_PREFIX, "Back camera id: " + back);
+        videoFilter.push(back);
+    }
+
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia(constraints);
+        if (stream) {
+            const mediaDevices = await navigator.mediaDevices.enumerateDevices();
+            if (mediaDevices) {
+                logger.debug(LOG_PREFIX, "mediaDevices: " + JSON.stringify(mediaDevices));
+                list = getList(mediaDevices, kind, videoFilter);
+            }
+            stream.getTracks().forEach(function (track) {
+                track.stop();
+            });
+        }
+    } catch (error) {
+        logger.error(LOG_PREFIX, "Can't get device access with constraints " + JSON.stringify(constraints) + ", error " + error);
+    }
+
+    return list;
+}
 
 function normalizeConstraints(constraints) {
     //WCS-2010. fixed TypeError after publish->stop->publish
@@ -16554,6 +16702,7 @@ module.exports = {
     getMediaAccess: getMediaAccess,
     releaseMedia: releaseMedia,
     listDevices: listDevices,
+    getMobileDevices: getMobileDevices,
     playFirstSound: playFirstSound,
     playFirstVideo: playFirstVideo,
     available: available,