@flashphoner/sfusdk 1.0.1-35 → 1.0.40

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

@@ -0,0 +1,346 @@
+const constants = SFU.constants;
+const sfu = SFU;
+let mainConfig;
+let localDisplay;
+let remoteDisplay;
+let publishState;
+let playState;
+const PUBLISH = "publish";
+const PLAY = "play";
+const STOP = "stop";
+const PRELOADER_URL="../commons/media/silence.mp3"
+
+
+/**
+ * Default publishing config
+ */
+const defaultConfig = {
+    room: {
+        url: "wss://127.0.0.1:8888",
+        name: "ROOM1",
+        pin: "1234",
+        nickName: "User1"
+    },
+    media: {
+        audio: {
+            tracks: [
+                {
+                    source: "mic",
+                    channels: 1
+                }
+            ]
+        },
+        video: {
+            tracks: [
+                {
+                    source: "camera",
+                    width: 640,
+                    height: 360,
+                    codec: "H264",
+                    encodings: [
+                        { rid: "360p", active: true, maxBitrate: 500000 },
+                        { rid: "180p", active: true, maxBitrate: 200000, scaleResolutionDownBy: 2 }
+                    ]
+                }
+            ]
+        }
+    }
+};
+
+/**
+ * Current state object
+ */
+const CurrentState = function(prefix) {
+    let state = {
+        prefix: prefix,
+        pc: null,
+        session: null,
+        room: null,
+        set: function(pc, session, room) {
+            state.pc = pc;
+            state.session = session;
+            state.room = room;
+        },
+        clear: function() {
+            state.room = null;
+            state.session = null;
+            state.pc = null;
+        },
+        buttonId: function() {
+            return state.prefix + "Btn";
+        },
+        buttonText: function() {
+            return (state.prefix.charAt(0).toUpperCase() + state.prefix.slice(1));
+        },
+        inputId: function() {
+            return state.prefix + "Name";
+        },
+        statusId: function() {
+            return state.prefix + "Status";
+        },
+        formId: function() {
+            return state.prefix + "Form";
+        },
+        errInfoId: function() {
+            return state.prefix + "ErrorInfo";
+        },
+        is: function(value) {
+            return (prefix === value);
+        }
+    };
+    return state;
+}
+
+/**
+ * load config and set default values
+ */
+const init = function() {
+    let configName = getUrlParam("config") || "./config.json";
+    $("#publishBtn").prop('disabled', true);
+    $("#playBtn").prop('disabled', true);
+    $("#url").prop('disabled', true);
+    $("#roomName").prop('disabled', true);
+    $("#publishName").prop('disabled', true);
+    $("#playName").prop('disabled', true);
+    publishState = CurrentState(PUBLISH);
+    playState = CurrentState(PLAY);
+    $.getJSON(configName, function(cfg){
+        mainConfig = cfg;
+        onDisconnected(publishState);
+        onDisconnected(playState);
+    }).fail(function(e){
+        //use default config
+        console.error("Error reading configuration file " + configName + ": " + e.status + " " + e.statusText)
+        console.log("Default config will be used");
+        mainConfig = defaultConfig;
+        onDisconnected(publishState);
+        onDisconnected(playState);
+    });
+    $("#url").val(setURL());
+    $("#roomName").val("ROOM1-"+createUUID(4));
+    $("#publishName").val("Publisher1-"+createUUID(4));
+    $("#playName").val("Player1-"+createUUID(4));
+}
+
+/**
+ * connect to server
+ */
+const connect = function(state) {
+    //create peer connection
+    pc = new RTCPeerConnection();
+    //get config object for room creation
+    const roomConfig = getRoomConfig(mainConfig);
+    roomConfig.pc = pc;
+    roomConfig.url = $("#url").val();
+    roomConfig.roomName = $("#roomName").val();
+    roomConfig.nickname = $("#" + state.inputId()).val();
+    // clean state display items
+    setStatus(state.statusId(), "");
+    setStatus(state.errInfoId(), "");
+    // connect to server and create a room if not
+    const session = sfu.createRoom(roomConfig);
+    session.on(constants.SFU_EVENT.CONNECTED, function(room) {
+        state.set(pc, session, room);
+        onConnected(state);
+        setStatus(state.statusId(), "ESTABLISHED", "green");
+    }).on(constants.SFU_EVENT.DISCONNECTED, function() {
+        state.clear();
+        onDisconnected(state);
+        setStatus(state.statusId(), "DISCONNECTED", "green");
+    }).on(constants.SFU_EVENT.FAILED, function(e) {
+        state.clear();
+        onDisconnected(state);
+        setStatus(state.statusId(), "FAILED", "red");
+        setStatus(state.errInfoId(), e.status + " " + e.statusText, "red");
+    });
+}
+
+const onConnected = function(state) {
+    $("#" + state.buttonId()).text("Stop").off('click').click(function () {
+        onStopClick(state);
+    });
+    $('#url').prop('disabled', true);
+    $("#roomName").prop('disabled', true);
+    $("#" + state.inputId()).prop('disabled', true);
+    // Add errors displaying
+    state.room.on(constants.SFU_ROOM_EVENT.FAILED, function(e) {
+        setStatus(state.errInfoId(), e, "red");
+    }).on(constants.SFU_ROOM_EVENT.OPERATION_FAILED, function (e) {
+        setStatus(state.errInfoId(), e.operation + " failed: " + e.error, "red");
+    });
+    if (state.is(PUBLISH)) {
+        publishStreams(state);
+    } else if (state.is(PLAY)) {
+        playStreams(state);
+    }
+}
+
+const onDisconnected = function(state) {
+    $("#" + state.buttonId()).text(state.buttonText()).off('click').click(function () {
+        onStartClick(state);
+    }).prop('disabled', false);
+    $("#" + state.inputId()).prop('disabled', false);
+    // Check if other session is active
+    if ((state.is(PUBLISH) && playState.session)
+       || (state.is(PLAY) && publishState.session)) {
+        return;
+    }
+    $('#url').prop('disabled', false);
+    $("#roomName").prop('disabled', false);
+}
+
+const onStartClick = function(state) {
+    if (validateForm("connectionForm") && validateForm(state.formId())) {
+        $("#" + state.buttonId()).prop('disabled', true);
+        if (state.is(PLAY) && Browser().isSafariWebRTC()) {
+            playFirstSound(document.getElementById("main"), PRELOADER_URL).then(function () {
+                connect(state);
+            });
+        } else {
+            connect(state);
+        }
+    }
+}
+
+const onStopClick = function(state) {
+    $("#" + state.buttonId()).prop('disabled', true);
+    if (state.is(PUBLISH)) {
+        unPublishStreams(state);
+    } else if (state.is(PLAY)) {
+        stopStreams(state);
+    }    
+    state.session.disconnect();
+}
+
+const publishStreams = async function(state) {
+    let timerId;
+    //create local display item to show local streams
+    localDisplay = initLocalDisplay(document.getElementById("localVideo"));
+    try {
+        //get configured local video streams
+        let streams = await getVideoStreams(mainConfig);
+        let audioStreams = await getAudioStreams(mainConfig);
+        //combine local video streams with audio streams
+        streams.push.apply(streams, audioStreams);
+        let config = {};
+        //add our local streams to the room (to PeerConnection)
+        streams.forEach(function (s) {
+            //add local stream to local display
+            localDisplay.add(s.stream.id, $("#" + state.inputId()).val(), s.stream);
+            //add each track to PeerConnection
+            s.stream.getTracks().forEach((track) => {
+                if (s.source === "screen") {
+                    config[track.id] = s.source;
+                }
+                addTrackToPeerConnection(state.pc, s.stream, track, s.encodings);
+                subscribeTrackToEndedEvent(state.room, track, state.pc);
+            });
+        });
+        state.room.join(config);
+        // TODO: Use room state or promises to detect if publishing started to enable stop button
+        timerId = waitFor(document.getElementById("localVideo"), 3000, state);
+    } catch(e) {
+        console.error("Failed to capture streams: " + e);
+        setStatus(state.errInfoId(), e.name, "red");
+        if (timerId) {
+            clearTimeout(timerId);
+            timerId = null;
+        }    
+        onStopClick(state);
+    }
+}
+
+// A workaround to check if publishing or playback is started
+const waitFor = function (div, timeout, state) {
+    let timerId = setTimeout(function () {
+        if (div.innerHTML !== "") {
+            // Enable stop button
+            $("#" + state.buttonId()).prop('disabled', false);
+        }
+        else {
+            setStatus(state.errInfoId(), "Something went wrong, stopping", "red");
+            onStopClick(state);
+        }
+    }, timeout);
+    return timerId;
+}
+
+const unPublishStreams = function(state) {
+    if (localDisplay) {
+        localDisplay.stop();
+    }
+}
+
+const playStreams = function(state) {
+    //create remote display item to show remote streams
+    remoteDisplay = initRemoteDisplay(document.getElementById("remoteVideo"), state.room, state.pc);
+    state.room.join();
+    $("#" + state.buttonId()).prop('disabled', false);
+}
+
+const stopStreams = function(state) {
+    if (remoteDisplay) {
+        remoteDisplay.stop();
+    }
+}
+
+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()) {
+            if (sender.track === track) {
+                pc.removeTrack(sender);
+                //track found, set renegotiation flag
+                negotiate = true;
+                break;
+            }
+        }
+        if (negotiate) {
+            //kickoff renegotiation
+            room.updateState();
+        }
+    });
+};
+
+const addTrackToPeerConnection = function(pc, stream, track, encodings) {
+    pc.addTransceiver(track, {
+        direction: "sendonly",
+        streams: [stream],
+        sendEncodings: encodings ? encodings : [] //passing encoding types for video simulcast tracks
+    });
+}
+
+const setStatus = function (status, text, color) {
+    const field = document.getElementById(status);
+    if (color) {
+        field.style.color = color;
+    }
+    field.innerText = text;
+}
+
+const validateForm = function (formId) {
+    var valid = true;
+    $('#' + formId + ' :text').each(function () {
+        if (!$(this).val()) {
+            highlightInput($(this));
+            valid = false;
+        } else {
+            removeHighlight($(this));
+        }
+    });
+    return valid;
+
+    function highlightInput(input) {
+        input.closest('.input-group').addClass("has-error");
+    }
+
+    function removeHighlight(input) {
+        input.closest('.input-group').removeClass("has-error");
+    }
+}
+
+const buttonText = function (string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+

package/src/sdk/constants.js

@@ -56,6 +56,14 @@ const constants = Object.freeze({
          */
         USER_LIST: "USER_LIST",
 
+        //TODO(naz): documentation
+        USER_CHATS: "USER_CHATS",
+        CHAT_LOADED: "CHAT_LOADED",
+        NEW_CHAT: "NEW_CHAT",
+        CHAT_DELETED: "CHAT_DELETED",
+        CHAT_UPDATED: "CHAT_UPDATED",
+        MESSAGE_STATE: "MESSAGE_STATE",
+
         /**
          * @typedef {Object} UserCalendar
          * @property events {UserCalendarEvents} object with events
@@ -400,6 +408,11 @@ const constants = Object.freeze({
         MESSAGE_STATE: "SFU_MESSAGE_STATE",
         USER_LIST: "SFU_USER_LIST",
         USER_CALENDAR: "SFU_USER_CALENDAR",
+        USER_CHATS: "SFU_USER_CHATS",
+        CHAT_LOADED: "SFU_CHAT_LOADED",
+        NEW_CHAT: "SFU_NEW_CHAT",
+        CHAT_DELETED: "SFU_CHAT_DELETED",
+        CHAT_UPDATED: "SFU_UPDATE_CHAT",
         GET_USER_LIST: "getUserList",
         GET_USER_CALENDAR: "getUserCalendar",
         ADD_CALENDAR_EVENT: "addCalendarEvent",
@@ -411,7 +424,14 @@ const constants = Object.freeze({
         UNSUBSCRIBE_FROM_WAITING_PARTICIPANT: "unsubscribeFromWaitingParticipant",
         MOVE_TO_WAITING_ROOM: "moveToWaitingRoom",
         CONFIGURE_WAITING_ROOM: "configureWaitingRoom",
-        TRACK_CONTENT_HEADER: "a=content:"
+        TRACK_CONTENT_HEADER: "a=content:",
+        GET_USER_CHATS: "getUserChats",
+        LOAD_CHAT: "loadChat",
+        CREATE_CHAT: "createChat",
+        DELETE_CHAT: "deleteChat",
+        RENAME_CHAT: "renameChat",
+        ADD_MEMBER_TO_CHAT: "addMemberToChat",
+        REMOVE_MEMBER_FROM_CHAT: "removeMemberFromChat"
     }),
     /**
      * @namespace FlashphonerSFUExtended.SFU_OPERATIONS
@@ -430,7 +450,15 @@ const constants = Object.freeze({
         ASSIGN_ROLE: "ASSIGN_ROLE",
         SUBSCRIBE_TO_WAITING_PARTICIPANT: "SUBSCRIBE_TO_WAITING_PARTICIPANT",
         UNSUBSCRIBE_FROM_WAITING_PARTICIPANT: "UNSUBSCRIBE_FROM_WAITING_PARTICIPANT",
-        MOVE_TO_WAITING_ROOM: "MOVE_TO_WAITING_ROOM"
+        MOVE_TO_WAITING_ROOM: "MOVE_TO_WAITING_ROOM",
+        CREATE_CHAT: "CREATE_CHAT",
+        DELETE_CHAT: "DELETE_CHAT",
+        RENAME_CHAT: "RENAME_CHAT",
+        LOAD_CHAT: "LOAD_CHAT",
+        ADD_MEMBER_TO_CHAT: "ADD_MEMBER_TO_CHAT",
+        REMOVE_MEMBER_FROM_CHAT: "REMOVE_MEMBER_FROM_CHAT",
+        UPDATE_CHAT_PREFERENCES: "UPDATE_CHAT_PREFERENCES",
+        GET_USER_CHATS: "GET_USER_CHATS"
     }),
     /**
      * @namespace FlashphonerSFU.SFU_PARTICIPANT_ROLE

package/src/sdk/messaging.js

@@ -6,20 +6,31 @@ const create = function(options) {
 
     /*
      * @param {String} msg.to Recipient's id
+     * @param {String} msg.chatId Indicates chat this message belongs to
      * @param {String} msg.body Message body
      */
     const sendMessage = function(msg) {
         return new Promise(function(resolve, reject) {
-            const message = {
-                id: uuidv4(),
-                to: msg.to,
-                body: msg.body
-            };
-            connection.send("sendMessage", message);
-            pendingMessages[message.id] = {
-                resolve: resolve,
-                reject: reject
-            };
+            //validate
+            if (!msg) {
+                reject(new Error("Can't send null message"));
+            } else if (!msg.body || msg.body === "") {
+                reject(new Error("Can't send message without a body"));
+            } else if (!msg.chatId || msg.chatId === "") {
+                reject(new Error("Can't send message without a chatId"));
+            } else {
+                const message = {
+                    id: uuidv4(),
+                    to: msg.to,
+                    body: msg.body,
+                    chatId: msg.chatId
+                };
+                connection.send("sendMessage", message);
+                pendingMessages[message.id] = {
+                    resolve: resolve,
+                    reject: reject
+                };
+            }
         });
     };
 
@@ -28,7 +39,7 @@ const create = function(options) {
         if (promise) {
             delete pendingMessages[msg[0].status.id];
             if (msg[0].status.delivered) {
-                promise.resolve();
+                promise.resolve(msg[0].status);
             } else {
                 promise.reject();
             }

package/src/sdk/promise.js

@@ -8,11 +8,21 @@ function add(id, resolve, reject) {
 }
 
 function resolve(id, args) {
-    getAndRemovePromise(id).resolve(args);
+    const promise = getAndRemovePromise(id);
+    if (!promise) {
+        return false;
+    }
+    promise.resolve(args);
+    return true;
 }
 
 function reject(id, args) {
-    getAndRemovePromise(id).reject(args);
+    const promise = getAndRemovePromise(id);
+    if (!promise) {
+        return false;
+    }
+    promise.reject(args);
+    return true;
 }
 
 function promised(id) {
@@ -22,7 +32,7 @@ function promised(id) {
 function getAndRemovePromise(id) {
     const promise = promises[id];
     if (!promise) {
-        throw new Error("Don't have promise with id " + id)
+        return;
     }
     delete promises[id];
     return promise;