@flashphoner/sfusdk 1.0.1-36 → 1.0.41

package/Gruntfile.js

@@ -50,6 +50,18 @@ module.exports = function(grunt) {
             release: [
                 'release'
             ]
+        },
+        run: {
+            options: {
+                // ...
+            },
+            test: {
+                cmd: 'npm',
+                args: [
+                    'run',
+                    'test'
+                ]
+            }
         }
     });
 
@@ -57,6 +69,7 @@ module.exports = function(grunt) {
     grunt.loadNpmTasks('grunt-contrib-copy');
     grunt.loadNpmTasks('grunt-contrib-clean');
     grunt.loadNpmTasks('grunt-jsdoc');
+    grunt.loadNpmTasks('grunt-run');
     grunt.registerTask('build', [
         'clean:build',
         'copy',

package/README.md

@@ -87,7 +87,7 @@ cp -r out/* /var/www/html/flashphoner-sfu-test
 
 [SFU functions description](https://docs.flashphoner.com/display/WCS52EN/SFU+functions+with+Simulcast)
 [SFU SDK documentation](https://docs.flashphoner.com/display/SS1E/SFU+SDK+1.0+-+EN)
-[SFU client example description](https://docs.flashphoner.com/display/SS1E/SFU+client)
+[SFU examples description](https://docs.flashphoner.com/display/SS1E/SFU+SDK+Examples)
 [API documentation](http://flashphoner.com/docs/api/WCS5/client/sfu-sdk/latest)
 
 ## Known issues

package/docTemplate/README.md

@@ -1,4 +1,4 @@
-SFU SDK - 1.0.1-36
+SFU SDK - 1.0.41
 
 [Download builds](https://docs.flashphoner.com/display/SS1E/Release+notes)
 

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@flashphoner/sfusdk",
   "description": "Official Flashphoner WebCallServer SFU SDK package",
-  "version": "1.0.1-36",
+  "version": "1.0.41",
+  "scripts": {
+    "test": "jest --runInBand"
+  },
   "dependencies": {
     "bootstrap": "^4.6.0",
     "datatables.net": "^1.10.24",
@@ -10,15 +13,17 @@
     "jquery-ui": "^1.12.1",
     "popper.js": "^1.16.1",
     "sdp-transform": "^2.14.0",
-    "webrtc-adapter": "^7.2.6",
-    "uuid": "^8.3.0"
+    "uuid": "^8.3.0",
+    "webrtc-adapter": "^7.2.6"
   },
   "devDependencies": {
     "grunt": "^1.0.1",
     "grunt-browserify": "^5.0.0",
     "grunt-contrib-clean": "^1.0.0",
     "grunt-contrib-copy": "^1.0.0",
-    "grunt-jsdoc": "^2.4.0"
+    "grunt-jsdoc": "^2.4.0",
+    "grunt-run": "^0.8.1",
+    "jest": "^27.4.7"
   },
   "keywords": [
     "Flashphoner",
@@ -26,5 +31,8 @@
     "SFU SDK"
   ],
   "author": "Flashphoner",
-  "license": "MIT"
+  "license": "MIT",
+  "jest" : {
+    "testEnvironment": "jsdom"
+  }
 }

package/src/examples/player/player.js

@@ -100,6 +100,9 @@ const connect = function(state) {
     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) {

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

@@ -56,16 +56,37 @@ const CurrentState = function(prefix) {
         pc: null,
         session: null,
         room: null,
+        timer: null,
         set: function(pc, session, room) {
             state.pc = pc;
             state.session = session;
             state.room = room;
         },
         clear: function() {
+            state.stopWaiting();
             state.room = null;
             state.session = null;
             state.pc = null;
         },
+        waitFor: function(div, timeout) {
+            state.stopWaiting();
+            state.timer = setTimeout(function () {
+                if (div.innerHTML !== "") {
+                    // Enable stop button
+                    $("#" + state.buttonId()).prop('disabled', false);
+                }
+                else if (state.isConnected()) {
+                    setStatus(state.errInfoId(), "No media capturing started in " + timeout + " ms, stopping", "red");
+                    onStopClick(state);
+                }
+            }, timeout);        
+        },
+        stopWaiting: function() {
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = null;                
+            }
+        },
         buttonId: function() {
             return state.prefix + "Btn";
         },
@@ -86,6 +107,12 @@ const CurrentState = function(prefix) {
         },
         is: function(value) {
             return (prefix === value);
+        },
+        isActive: function() {
+            return (state.room && state.pc);
+        },
+        isConnected: function() {
+            return (state.session && state.session.state() == constants.SFU_STATE.CONNECTED);
         }
     };
     return state;
@@ -165,14 +192,12 @@ const onConnected = function(state) {
     // Add errors displaying
     state.room.on(constants.SFU_ROOM_EVENT.FAILED, function(e) {
         setStatus(state.errInfoId(), e, "red");
+        stopStreaming(state);
     }).on(constants.SFU_ROOM_EVENT.OPERATION_FAILED, function (e) {
         setStatus(state.errInfoId(), e.operation + " failed: " + e.error, "red");
+        stopStreaming(state);
     });
-    if (state.is(PUBLISH)) {
-        publishStreams(state);
-    } else if (state.is(PLAY)) {
-        playStreams(state);
-    }
+    startStreaming(state);
 }
 
 const onDisconnected = function(state) {
@@ -204,65 +229,67 @@ const onStartClick = function(state) {
 
 const onStopClick = function(state) {
     $("#" + state.buttonId()).prop('disabled', true);
+    stopStreaming(state);
+    if (state.isConnected()) {
+        state.session.disconnect();
+    }
+}
+
+const startStreaming = function(state) {
     if (state.is(PUBLISH)) {
-        unPublishStreams(state);
+        publishStreams(state);
     } else if (state.is(PLAY)) {
-        stopStreams(state);
-    }    
-    state.session.disconnect();
+        playStreams(state);
+    }
 }
 
-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);
+const stopStreaming = function(state) {
+    state.stopWaiting();
+    if (state.is(PUBLISH)) {
+        unPublishStreams(state);
+    } else if (state.is(PLAY)) {
+        stopStreams(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);
+const publishStreams = async function(state) {
+    if (state.isConnected()) {
+        //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);
+            if (state.isConnected() && state.isActive()) {
+                //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
+                state.waitFor(document.getElementById("localVideo"), 3000);
+            }
+        } catch(e) {
+            console.error("Failed to capture streams: " + e);
+            setStatus(state.errInfoId(), e.name, "red");
+            state.stopWaiting();
+            if (state.isConnected()) { 
+                onStopClick(state);
+            }
         }
-    }, timeout);
-    return timerId;
+    }
 }
 
 const unPublishStreams = function(state) {
@@ -272,9 +299,11 @@ const unPublishStreams = function(state) {
 }
 
 const playStreams = function(state) {
-    //create remote display item to show remote streams
-    remoteDisplay = initRemoteDisplay(document.getElementById("remoteVideo"), state.room, state.pc);
-    state.room.join();
+    if (state.isConnected() && state.isActive()) {
+        //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);
 }
 

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;

package/src/sdk/sfu-extended.js

@@ -22,7 +22,6 @@ let state = SFU_STATE.NEW;
 let connectionConfig;
 let user;
 let im;
-let pendingUserList = [];
 
 function setupConnection(connection) {
     connection.onMessage = function(name, msg){
@@ -33,15 +32,28 @@ function setupConnection(connection) {
                     notify(SFU_EVENT.MESSAGE, msg[0].message);
                 } else if (msg[0].type === SFU_INTERNAL.MESSAGE_STATE) {
                     im.onMessageState(msg);
+                    notify(SFU_EVENT.MESSAGE_STATE, msg[0].status);
                 } else if (msg[0].type === SFU_INTERNAL.USER_LIST) {
-                    while (pendingUserList.length > 0) {
-                        const promise = pendingUserList.pop();
-                        promise.resolve(msg[0].list);
-                    }
+                    promises.resolve(msg[0].internalMessageId, msg[0].list);
                     notify(SFU_EVENT.USER_LIST, msg[0].list);
                 } else if (msg[0].type === SFU_INTERNAL.USER_CALENDAR) {
                     promises.resolve(msg[0].internalMessageId, msg[0].calendar);
                     notify(SFU_EVENT.USER_CALENDAR, msg[0].calendar);
+                } else if (msg[0].type === SFU_INTERNAL.NEW_CHAT) {
+                    if(!promises.resolve(msg[0].internalMessageId, msg[0].info)) {
+                        notify(SFU_EVENT.NEW_CHAT, msg[0].info);
+                    }
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_DELETED) {
+                    notify(SFU_EVENT.CHAT_DELETED, msg[0].info);
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_UPDATED) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].info);
+                    notify(SFU_EVENT.CHAT_UPDATED, msg[0].info);
+                } else if (msg[0].type === SFU_INTERNAL.USER_CHATS) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].chats);
+                    notify(SFU_EVENT.USER_CHATS, msg[0].chats);
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_LOADED) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].chat);
+                    notify(SFU_EVENT.CHAT_LOADED, msg[0].chat);
                 } else if (msg[0].type === constants.SFU_ROOM_EVENT.OPERATION_FAILED && promises.promised(msg[0].internalMessageId)) {
                     promises.reject(msg[0].internalMessageId, msg[0]);
                 } else if (msg[0].type === constants.SFU_EVENT.ACK && promises.promised(msg[0].internalMessageId)) {
@@ -128,7 +140,8 @@ const connect = function(options) {
 /**
  * Send message
  * @param {Object} msg Message
- * @param {String} msg.to Recipient's id
+ * @param {String} msg.to Recipient's id (deprecated, use chatId instead)
+ * @param {String} msg.chatId Indicates chat this message belongs to
  * @param {String} msg.body Message body
  * @returns {Promise} Promise will resolve upon message delivery and reject if delivery was unsuccessful
  * @throws {Error} error if api isn't connected
@@ -144,26 +157,18 @@ const sendMessage = function(msg) {
 /**
  * Fetch available user list from server
  * @returns {Promise<Array<FlashphonerSFUExtended.UserListEntry>>}
- * @throws {Error} error if api isn't connected
  * @memberOf FlashphonerSFUExtended
 
  */
 const getUserList = function() {
-    if (state !== SFU_STATE.AUTHENTICATED) {
-        throw new Error("Can't get user list while in " + state + " state");
-    }
     return new Promise(function (resolve, reject){
         if (state !== SFU_STATE.AUTHENTICATED) {
             reject(new Error("Can't get user list while in " + state + " state"));
             return;
         }
-        if (pendingUserList.length > 0) {
-            pendingUserList.push({resolve: resolve, reject: reject});
-            return;
-        } else {
-            pendingUserList.push({resolve: resolve, reject: reject});
-        }
-        connection.send(constants.SFU_INTERNAL_API.GET_USER_LIST);
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.GET_USER_LIST, {internalMessageId: id});
     });
 };
 
@@ -229,6 +234,126 @@ const removeCalendarEvent = function(event) {
     });
 };
 
+/**
+ * Fetch available chats from server
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const getUserChats = function() {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't get user chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.GET_USER_CHATS, {internalMessageId: id});
+    });
+};
+
+/**
+ * Fetch chat data from server
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const loadChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't load chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.LOAD_CHAT, {id: chat.id, internalMessageId: id});
+    });
+};
+
+/**
+ * Create chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const createChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't create chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.CREATE_CHAT, {id: chat.id, name: chat.name, members: chat.members, internalMessageId: id});
+    });
+};
+
+/**
+ * Delete chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const deleteChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't delete chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.DELETE_CHAT, {id: chat.id, internalMessageId: id});
+    });
+};
+
+/**
+ * Rename chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const renameChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't rename chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.RENAME_CHAT, {id: chat.id, name: chat.name, internalMessageId: id});
+    });
+};
+
+/**
+ * Add member to chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const addMemberToChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't add member to chat while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.ADD_MEMBER_TO_CHAT, {id: chat.id, member: chat.member, internalMessageId: id});
+    });
+};
+
+/**
+ * Remove member from chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const removeMemberFromChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't remove member to chat while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.REMOVE_MEMBER_FROM_CHAT, {id: chat.id, member: chat.member, internalMessageId: id});
+    });
+};
+
+
 /**
  * Create room
  *
@@ -326,8 +451,6 @@ const disconnect = function() {
         value.leaveRoom();
     }
     user = undefined;
-    pendingUserList = [];
-    pendingUserCalendar = [];
     connection.close();
     connection = ws.createConnection();
     state = SFU_STATE.DISCONNECTED;
@@ -341,6 +464,13 @@ sfu.getUserList = getUserList;
 sfu.getUserCalendar = getUserCalendar;
 sfu.addCalendarEvent = addCalendarEvent;
 sfu.removeCalendarEvent = removeCalendarEvent;
+sfu.getUserChats = getUserChats;
+sfu.loadChat = loadChat;
+sfu.createChat = createChat;
+sfu.deleteChat = deleteChat;
+sfu.renameChat = renameChat;
+sfu.addMemberToChat = addMemberToChat;
+sfu.removeMemberFromChat = removeMemberFromChat;
 sfu.room = room;
 
 

package/src/tests/sdk/sfu-extended.test.js

@@ -0,0 +1,151 @@
+const sfu = require("../../sdk/sfu-extended");
+const constants = require("../../sdk/constants");
+
+const SERVER = "ws://127.0.0.1:8080";
+const USER = "bob@flashphoner.com";
+const PASSWD = "123456";
+const CHAT_ID = "test-chat-id";
+const CHAT_NAME = "test-chat";
+const CHAT_NAME2 = "test-chat2";
+const USER2 = "alice@flashphoner.com";
+const MESSAGE_BODY = "This is a test message";
+const MEMBERS = [
+    "bob@flashphoner.com",
+    "alice@flashphoner.com",
+    "kiri@flashphoner.com"
+];
+
+beforeAll( async () => {
+    await sfu.connect({
+        url: SERVER,
+        username: USER,
+        password: PASSWD
+    });
+    const chats = await sfu.getUserChats();
+    if (chats) {
+        Object.entries(chats).map(async ([key, value]) => {
+            await sfu.deleteChat({id: value.id});
+        });
+    }
+});
+
+afterAll(() => {
+    return sfu.disconnect();
+});
+
+
+describe("connection", () => {
+    test("should connect to server", () => {
+        expect(sfu.state()).toBe(constants.SFU_STATE.AUTHENTICATED);
+    });
+});
+
+describe("contacts", () => {
+    test("should load user list", () => {
+        return sfu.getUserList();
+    });
+});
+
+describe("calendar", () => {
+    test("should load calendar", () => {
+        return sfu.getUserCalendar().then((calendar) => {
+            expect(calendar).toHaveProperty("events");
+        })
+    })
+});
+
+describe("chat", () => {
+    test("should create new chat", () => {
+        return sfu.createChat({
+            id: CHAT_ID,
+            name: CHAT_NAME
+        });
+    });
+    test("should load chats", () => {
+        return sfu.getUserChats().then((chats) => {
+            expect(chats).toBeTruthy();
+        });
+    });
+    test("should add new member", () => {
+        return sfu.addMemberToChat({
+            id: CHAT_ID,
+            member: USER2
+        });
+    });
+    test("should send a message", () => {
+        return sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        })
+    });
+    test("should load chat", () => {
+        return sfu.loadChat({
+            id: CHAT_ID
+        }).then((chat) => {
+            expect(chat.id).toBe(CHAT_ID);
+            expect(chat.name).toBe(CHAT_NAME);
+            expect(chat.members).toContain(USER);
+            expect(Array.isArray(chat.messages)).toBe(true);
+            expect(chat.messages.length).toBeGreaterThan(0);
+        });
+    });
+    test("should remove member", () => {
+        return sfu.removeMemberFromChat({
+            id: CHAT_ID,
+            member: USER2
+        });
+    });
+    test("should rename chat", () => {
+        return sfu.renameChat({
+            id: CHAT_ID,
+            name: CHAT_NAME2
+        });
+    });
+    test.skip("should receive message", (done) => {
+        sfu.on(constants.SFU_EVENT.MESSAGE, (msg) => {
+            done();
+        })
+        sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        });
+    });
+    test("should receive ACK message", (done) => {
+        sfu.on(constants.SFU_EVENT.MESSAGE_STATE, (state) => {
+            done();
+        })
+        sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        });
+    });
+    test("should create new chat without id", () => {
+        return sfu.createChat({
+            name: CHAT_NAME
+        });
+    });
+    test("should create new chat with member list", () => {
+        return sfu.createChat({
+            name: CHAT_NAME,
+            members: MEMBERS
+        });
+    });
+    test("should create new chat without name based on members", async () => {
+        const chat = await sfu.createChat({
+            members: MEMBERS
+        });
+        expect(chat.name).toBeTruthy();
+    });
+    test("should delete chat", () => {
+        return sfu.deleteChat({
+            id: CHAT_ID
+        });
+    });
+    test("should change name after member was added", async () => {
+        const chat = await sfu.createChat({});
+        expect(chat.name).toBeTruthy();
+        const name1 = chat.name;
+        const sameChat = await sfu.addMemberToChat({id: chat.id, member: USER2});
+        expect(sameChat.name !== name1).toBeTruthy();
+    });
+});