@flashphoner/sfusdk-examples 2.0.193 → 2.0.196

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flashphoner/sfusdk-examples",
-  "version": "2.0.193",
+  "version": "2.0.196",
   "description": "Official Flashphoner WebCallServer SFU SDK usage examples",
   "main": "dist/sfu.js",
   "types": "src/sfu.ts",
@@ -27,6 +27,6 @@
     "webpack-cli": "^4.9.2"
   },
   "dependencies": {
-    "@flashphoner/sfusdk": "^2.0.130"
+    "@flashphoner/sfusdk": "^2.0.193"
   }
 }

package/src/client/controls.js

@@ -163,12 +163,19 @@ const createControls = function(config) {
     }
 
     const roomConfig = function() {
-        return {
+        let roomConfig = {
             url: controls.entrance.url.value,
             roomName: controls.entrance.roomName.value,
             pin: controls.entrance.roomPin.value,
             nickname: controls.entrance.nickName.value
+        };
+        if (config.room.failedProbesThreshold !== undefined) {
+            roomConfig.failedProbesThreshold = config.room.failedProbesThreshold;
         }
+        if (config.room.pingInterval !== undefined) {
+            roomConfig.pingInterval = config.room.pingInterval;
+        }
+        return roomConfig;
     }
 
     const getVideoStreams = function() {
@@ -301,17 +308,28 @@ const getMedia = async function(tracks) {
         if (track.source === "mic") {
             //audio
             constraints.audio = {};
+            if (track.constraints) {
+                constraints.audio = track.constraints;
+            }
             constraints.audio.stereo = track.channels !== 1
+            if (track.channels && track.channels === 2) {
+                constraints.audio.echoCancellation = false;
+                constraints.audio.googEchoCancellation = false;
+            }
         } else if (track.source === "camera") {
-            constraints.video = {
-                width: track.width,
-                height: track.height
-            };
+            constraints.video = {};
+            if (track.constraints) {
+                constraints.video = track.constraints;
+            }
+            constraints.video.width = track.width;
+            constraints.video.height = track.height;
         } else if (track.source === "screen") {
-            constraints.video = {
-                width: track.width,
-                height: track.height
-            };
+            constraints.video = {};
+            if (track.constraints) {
+                constraints.video = track.constraints;
+            }
+            constraints.video.width = track.width;
+            constraints.video.height = track.height;
             screen = true;
         }
     });

package/src/client/main.js

@@ -68,7 +68,13 @@ async function connect() {
         const session = await sfu.createRoom(roomConfig);
         // Now we connected to the server (if no exception was thrown)
         session.on(constants.SFU_EVENT.FAILED, function(e) {
-            displayError("CONNECTION FAILED: "+ e +". Refresh the page to enter the room again");
+            if (e.status && e.statusText) {
+                displayError("CONNECTION FAILED: " + e.status + " " + e.statusText);
+            } else if (e.type && e.info) {
+                displayError("CONNECTION FAILED: " + e.info);
+            } else {
+                displayError("CONNECTION FAILED: " + e);
+            }
         }).on(constants.SFU_EVENT.DISCONNECTED, function(e) {
             displayError("DISCONNECTED. Refresh the page to enter the room again");
         });

package/src/commons/js/config.js

@@ -1,10 +1,16 @@
 const getRoomConfig = function(config) {
     let roomConfig = {
-        url: config.url || "ws://127.0.0.1:8080",
-        roomName: config.name || "ROOM1",
-        pin: config.pin || "1234",
-        nickname: config.nickName || "User1"        
+        url: config.room.url || "ws://127.0.0.1:8080",
+        roomName: config.room.name || "ROOM1",
+        pin: config.room.pin || "1234",
+        nickname: config.room.nickName || "User1"
     };
+    if (config.room.failedProbesThreshold !== undefined) {
+        roomConfig.failedProbesThreshold = config.room.failedProbesThreshold;
+    }
+    if (config.room.pingInterval !== undefined) {
+        roomConfig.pingInterval = config.room.pingInterval;
+    }
     return roomConfig;
 }
 
@@ -50,6 +56,7 @@ const getMedia = async function(track) {
         if (track.constraints) {
             constraints.audio = track.constraints;
         }
+        constraints.audio.stereo = track.channels !== 1
         if (track.channels && track.channels === 2) {
             constraints.audio.echoCancellation = false;
             constraints.audio.googEchoCancellation = false;

package/src/player/player.js

@@ -171,20 +171,28 @@ const connect = async function(state) {
         const session = await sfu.createRoom(roomConfig);
         // Set up session ending events
         session.on(constants.SFU_EVENT.DISCONNECTED, function() {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus(state.statusId(), "DISCONNECTED", "green");
         }).on(constants.SFU_EVENT.FAILED, function(e) {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus(state.statusId(), "FAILED", "red");
-            setStatus(state.errInfoId(), e.status + " " + e.statusText, "red");
+            if (e.status && e.statusText) {
+                setStatus(state.errInfoId(), e.status + " " + e.statusText, "red");
+            } else if (e.type && e.info) {
+                setStatus(state.errInfoId(), e.type + ": " + e.info, "red");
+            }
         });
         // Connected successfully
         state.set(pc, session, session.room());
         onConnected(state);
         setStatus(state.statusId(), "ESTABLISHED", "green");
     } catch(e) {
+        state.clear();
+        onDisconnected(state);
         setStatus(state.statusId(), "FAILED", "red");
         setStatus(state.errInfoId(), e, "red");
     }

package/src/sfu.ts

@@ -1,22 +1,35 @@
-import {Sfu, RoomEvent, SfuEvent, State} from "@flashphoner/sfusdk";
+import {
+    Sfu,
+    RoomEvent,
+    SfuEvent,
+    State
+} from "@flashphoner/sfusdk";
 
 export async function createRoom(options: {
     url: string,
     roomName: string,
     pin: string,
-    nickname: string
+    nickname: string,
+    failedProbesThreshold?: number,
+    pingInterval?: number,
 }) {
-    const sfu = new Sfu();
-    await sfu.connect({
-        url: options.url,
-        nickname: options.nickname,
-        logGroup: options.roomName
-    });
-    sfu.createRoom({
-        name: options.roomName,
-        pin: options.pin
-    });
-    return sfu;
+    try {
+        const sfu = new Sfu();
+        await sfu.connect({
+            url: options.url,
+            nickname: options.nickname,
+            logGroup: options.roomName,
+            failedProbesThreshold: options.failedProbesThreshold,
+            pingInterval: options.pingInterval
+        });
+        sfu.createRoom({
+            name: options.roomName,
+            pin: options.pin
+        });
+        return sfu;
+    } catch (e) {
+        throw new Error("Can't connect to websocket URL " + options.url);
+    }
 }
 
 export const constants = {

package/src/two-way-streaming/config.json

@@ -3,7 +3,9 @@
     "url": "ws://127.0.0.1:8080",
     "name": "ROOM1",
     "pin": "1234",
-    "nickName": "User1"
+    "nickName": "User1",
+    "failedProbesThreshold": 5,
+    "pingInterval": 5000
   },
   "media": {
     "audio": {

package/src/two-way-streaming/two-way-streaming.js

@@ -211,24 +211,31 @@ const connect = async function(state) {
         const session = await sfu.createRoom(roomConfig);
         // Set up session ending events
         session.on(constants.SFU_EVENT.DISCONNECTED, function() {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus(state.statusId(), "DISCONNECTED", "green");
         }).on(constants.SFU_EVENT.FAILED, function(e) {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus(state.statusId(), "FAILED", "red");
-            setStatus(state.errInfoId(), e.status + " " + e.statusText, "red");
+            if (e.status && e.statusText) {
+                setStatus(state.errInfoId(), e.status + " " + e.statusText, "red");
+            } else if (e.type && e.info) {
+                setStatus(state.errInfoId(), e.type + ": " + e.info, "red");
+            }
         });
         // Connected successfully
         state.set(pc, session, session.room());
         onConnected(state);
         setStatus(state.statusId(), "ESTABLISHED", "green");
     } catch(e) {
+        state.clear();
+        onDisconnected(state);
         setStatus(state.statusId(), "FAILED", "red");
         setStatus(state.errInfoId(), e, "red");
-    }
-}
+    }}
 
 const onConnected = function(state) {
     $("#" + state.buttonId()).text("Stop").off('click').click(function () {
@@ -351,7 +358,7 @@ const publishStreams = async function(state) {
                     s.stream.getTracks().forEach((track) => {
                         config[track.id] = contentType;
                         addTrackToPeerConnection(state.pc, s.stream, track, s.encodings);
-                        subscribeTrackToEndedEvent(state, track);
+                        subscribeTrackToEndedEvent(state.room, track, state.pc);
                     });
                 });
                 //start WebRTC negotiation
@@ -396,10 +403,8 @@ const stopStreams = function(state) {
     }
 }
 
-const subscribeTrackToEndedEvent = function(state, track) {
-    let room = state.room;
-    let pc = state.pc;
-    track.addEventListener("ended", async function() {
+const subscribeTrackToEndedEvent = function(room, track, pc) {
+    track.addEventListener("ended", function() {
         //track ended, see if we need to cleanup
         let negotiate = false;
         for (const sender of pc.getSenders()) {
@@ -412,7 +417,7 @@ const subscribeTrackToEndedEvent = function(state, track) {
         }
         if (negotiate) {
             //kickoff renegotiation
-            state.waitFor(room.updateState(), MAX_AWAIT_MS);
+            room.updateState();
         }
     });
 };

package/src/webrtc-abr-player/player.js

@@ -115,7 +115,7 @@ const init = function() {
  */
 const connect = async function(state) {
     // Create peer connection
-    const pc = new RTCPeerConnection();
+    let pc = new RTCPeerConnection();
     // Create a config to connect to SFU room
     const roomConfig = {
         // Server websocket URL
@@ -135,20 +135,28 @@ const connect = async function(state) {
         const session = await sfu.createRoom(roomConfig);
         // Set up session ending events
         session.on(constants.SFU_EVENT.DISCONNECTED, function() {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus("playStatus", "DISCONNECTED", "green");
         }).on(constants.SFU_EVENT.FAILED, function(e) {
+            onStopClick(state);
             state.clear();
             onDisconnected(state);
             setStatus("playStatus", "FAILED", "red");
-            setStatus("playErrorInfo", e.status + " " + e.statusText, "red");
+            if (e.status && e.statusText) {
+                setStatus("playErrorInfo", e.status + " " + e.statusText, "red");
+            } else if (e.type && e.info) {
+                setStatus("playErrorInfo", e.type + ": " + e.info, "red");
+            }
         });
         // Connected successfully
         state.set(pc, session, session.room());
         onConnected(state);
         setStatus("playStatus", "CONNECTING...", "black");
     } catch(e) {
+        state.clear();
+        onDisconnected(state);
         setStatus("playStatus", "FAILED", "red");
         setStatus("playErrorInfo", e, "red");
     }