@flashphoner/sfusdk 1.0.47 → 2.0.51

package/src/sdk/sfu.js

@@ -1,208 +0,0 @@
-/**
- * @namespace FlashphonerSFU
- */
-
-const ws = require("./ws");
-const roomApi = require("./room");
-const constants = require("./constants");
-const SFU_STATE = constants.SFU_STATE;
-const SFU_EVENT = constants.SFU_EVENT;
-const SFU_INTERNAL = constants.SFU_INTERNAL_API;
-
-/**
- * Connect to server and create local representation of the room.
- * @param {Object} options Room options
- * @param {String} options.url Server url
- * @param {String} options.roomName Room name
- * @param {String} options.pin Room's pin
- * @param {String} options.nickname Participant's nick
- * @param {Object} options.pc Peer connection
- * @returns {FlashphonerSFU.SFUSession} session
- * @throws {TypeError} Error if no options provided
- * @memberof FlashphonerSFU
- */
-function createSession(options) {
-    if (!options) {
-        throw new TypeError("No options provided");
-    }
-    let sfu = {};
-    let room;
-    const callbacks = {};
-    const connection = ws.createConnection();
-    let state = SFU_STATE.NEW;
-
-
-    connection.onMessage = function(name, msg){
-        switch (name) {
-            case SFU_INTERNAL.DEFAULT_METHOD:
-                if (msg[0].roomName && msg[0].roomName.length > 0) {
-                    //room event
-                    if (room) {
-                        room.processEvent(msg[0]);
-                    }
-                } else {
-                    notify(msg[0].type, msg[0]);
-                }
-                break;
-            case "failed":
-                notify(constants.SFU_EVENT.FAILED, msg[0]);
-                break;
-        }
-    };
-
-    connection.onClose = function(e) {
-        state = SFU_STATE.DISCONNECTED;
-        notify(SFU_EVENT.DISCONNECTED, e);
-    };
-
-    connection.onError = function(e) {
-        state = SFU_STATE.FAILED;
-        notify(SFU_STATE.FAILED, e);
-    };
-
-    let connectionConfig = {
-        url: options.url,
-        appName: SFU_INTERNAL.P_APP,
-        custom: {
-            nickname: options.nickname,
-            roomName: options.roomName
-        }
-    };
-
-    connection.connect(connectionConfig).then(function (connectionConfig) {
-        state = SFU_STATE.CONNECTED;
-        //create room
-        const opt = {
-            connection: connection,
-            name: options.roomName,
-            pin: options.pin,
-            pc: options.pc
-        };
-        room = roomApi.room(opt);
-        notify(SFU_EVENT.CONNECTED, room);
-    }, function (e) {
-        state = SFU_STATE.FAILED;
-        notify(SFU_EVENT.FAILED, e);
-    });
-
-    /**
-     * Disconnect from the server
-     * @memberOf FlashphonerSFU.SFUSession
-     */
-    const disconnect = function() {
-        connection.close();
-    }
-
-    /**
-     * Session event callback.
-     *
-     * @callback FlashphonerSFU.SFUSession~eventCallback
-     * @param {FlashphonerSFU.SFUSession} session SFUSession that corresponds to the event
-     */
-
-    /**
-     * Add session event callback.
-     *
-     * @param {String} event One of {@link FlashphonerSFU.SFU_EVENT} events
-     * @param {FlashphonerSFU.SFUSession~eventCallback} callback Callback function
-     * @returns {FlashphonerSFU.SFUSession} Session callback was attached to
-     * @throws {TypeError} Error if event is not specified
-     * @throws {Error} Error if callback is not a valid function
-     * @memberOf FlashphonerSFU.SFUSession
-     * @inner
-     */
-    const on = function (event, callback) {
-        if (!event) {
-            throw new TypeError("Event can't be null");
-        }
-        if (!callback || typeof callback !== "function") {
-            throw new Error("Callback needs to be a valid function");
-        }
-        if (!callbacks[event]) {
-            callbacks[event] = [];
-        }
-        callbacks[event].push(callback);
-        return sfu;
-    };
-
-    /**
-     * Remove session event callback.
-     *
-     * @param {String} event One of {@link FlashphonerSFU.SFU_EVENT} events
-     * @param {FlashphonerSFU.SFUSession~eventCallback} callback Callback function
-     * @returns {FlashphonerSFU.SFUSession} Session callback was removed from
-     * @throws {TypeError} Error if event is not specified
-     * @throws {Error} Error if callback is not a valid function
-     * @memberOf FlashphonerSFU.SFUSession
-     * @inner
-     */
-    const off = function (event, callback) {
-        if (!event) {
-            throw new TypeError("Event can't be null");
-        }
-        if (!callback || typeof callback !== "function") {
-            throw new Error("Callback needs to be a valid function");
-        }
-        if (!callbacks[event]) {
-            callbacks[event] = [];
-        }
-        let index = callbacks[event].findIndex(element => element === callback);
-        if (index !== -1) {
-            callbacks[event] = callbacks[event].slice(index, 1);
-        }
-        return sfu;
-    };
-
-    const notify = function(event, msg) {
-        if (callbacks[event]) {
-            for (const callback of callbacks[event]) {
-                callback(msg);
-            }
-        }
-    };
-
-    /**
-     * Represents connection to server. Once connected will emmit {@link FlashphonerSFU.SFU_EVENT.CONNECTED} with local instance of previously
-     * specified room.
-     *
-     * @see FlashphonerSFU.createSession
-     * @namespace SFUSession
-     * @memberOf FlashphonerSFU
-     */
-    sfu = {
-        /**
-         * Returns room object if available
-         * @returns {FlashphonerSFU.Room}
-         * @memberOf FlashphonerSFU.SFUSession
-         */
-        room: function() {
-            return room;
-        },
-        /**
-         * Returns {@link FlashphonerSFU.SFU_STATE} state of connection
-         * @returns {FlashphonerSFU.SFU_STATE}
-         * @memberOf FlashphonerSFU.SFUSession
-         */
-        state: function() {
-            return state;
-        },
-        /**
-         * Preconfigured nickname
-         * @returns {String}
-         * @memberOf FlashphonerSFU.SFUSession
-         */
-        nickname: function() {
-            return options.nickname;
-        },
-        disconnect: disconnect,
-        on: on,
-        off: off
-    }
-    return sfu;
-}
-
-
-module.exports = {
-    createRoom: createSession,
-    constants: constants
-}

package/src/sdk/ws.js

@@ -1,113 +0,0 @@
-"use strict";
-
-const logger = require("./logger");
-
-function createConnection() {
-    let wsConnection;
-    let exports = {};
-    exports.onError = function(e){};
-    exports.onClose = function(e){};
-    exports.onMessage = function(name, body){};
-    /**
-     * @param {Object} options Connection options
-     * @param {String=} options.url Server url
-     * @param {String=} options.appName Application name
-     * @param {Number=} options.timeout Connection timeout
-     * @param {Object=} options.custom Custom object
-     * @returns Promise
-     * @throws {TypeError} Error if no options provided
-     * @memberof FSFU
-     * @inner
-     */
-    exports.connect = function(options) {
-        return new Promise(function(resolve, reject) {
-            let connected = false;
-            wsConnection = new WebSocket(options.url);
-            wsConnection.binaryType = 'arraybuffer';
-            let connectionTimeout;
-            if (options.timeout !== undefined && options.timeout > 0) {
-                connectionTimeout = setTimeout(function () {
-                    if (wsConnection.readyState === 0) {
-                        console.log("WS connection timeout");
-                        wsConnection.close();
-                    }
-                }, options.timeout);
-            }
-            wsConnection.onerror = function (e) {
-                if (connected) {
-                    exports.onError(e);
-                } else {
-                    reject(e);
-                }
-            };
-            wsConnection.onclose = function (e) {
-                if (connected) {
-                    exports.onClose(e);
-                } else {
-                    reject(e);
-                }
-            };
-            wsConnection.onopen = function () {
-                clearTimeout(connectionTimeout);
-                let cConfig = {
-                    appKey: options.appName,
-                    mediaProviders: ["WebRTC"],
-                    keepAlive: true,
-                    authToken: null,
-                    clientVersion: "0.5.28",
-                    clientOSVersion: window.navigator.appVersion,
-                    clientBrowserVersion: window.navigator.userAgent,
-                    custom: options.custom
-                };
-                //connect to REST App
-                send("connection", cConfig);
-            };
-            wsConnection.onmessage = function (event) {
-                let name;
-                let msg;
-                if (event.data instanceof Blob) {
-                    name = "binaryData";
-                } else {
-                    let obj = JSON.parse(event.data);
-                    name = obj.message;
-                    msg = obj.data;
-                }
-                switch (name) {
-                    case "ping":
-                        send("pong", null);
-                        break;
-                    case "getUserData":
-                        connected = true;
-                        resolve(msg);
-                        break;
-                    default:
-                        exports.onMessage(name, msg);
-                }
-            };
-        });
-    };
-
-    const send = function(message, data) {
-        logger.log("==>", message, data);
-        if (wsConnection) {
-            wsConnection.send(JSON.stringify({
-                message: message,
-                data: [data]
-            }));
-        }
-    };
-
-    exports.send = send;
-
-    const close = function() {
-        if (wsConnection) {
-            wsConnection.close();
-        }
-    };
-    exports.close = close;
-    return exports;
-}
-
-module.exports = {
-    createConnection: createConnection
-};

package/src/tests/lib/rtcaudiosourcesinewave.js

@@ -1,109 +0,0 @@
-/**
- * File from node-webrtc-examples project
- * https://github.com/node-webrtc/node-webrtc-examples/blob/master/lib/server/webrtc/rtcaudiosourcesinewave.js
- */
-
-'use strict';
-
-const { RTCAudioSource } = require('wrtc').nonstandard;
-
-const twoPi = 2 * Math.PI;
-
-class RTCAudioSourceSineWave {
-    constructor(options = {}) {
-        options = {
-            frequency: 440,
-            channelCount: 1,
-            panning: null,
-            sampleRate: 48000,
-            schedule: setTimeout,
-            unschedule: clearTimeout,
-            ...options
-        };
-
-        const {
-            channelCount,
-            sampleRate
-        } = options;
-
-        if (channelCount !== 1 && channelCount !== 2) {
-            throw new Error('channelCount must be 1 or 2');
-        }
-
-        const bitsPerSample = 16;
-        const maxValue = Math.pow(2, bitsPerSample) / 2 - 1;
-        const numberOfFrames = sampleRate / 100;
-        const secondsPerSample = 1 / sampleRate;
-        const source = new RTCAudioSource();
-        const samples = new Int16Array(channelCount * numberOfFrames);
-
-        const data = {
-            samples,
-            sampleRate,
-            bitsPerSample,
-            channelCount,
-            numberOfFrames
-        };
-
-        const a = [1, 1];
-
-        let {
-            frequency,
-            panning
-        } = options;
-
-        let time = 0;
-
-        function next() {
-            for (let i = 0; i < numberOfFrames; i++, time += secondsPerSample) {
-                for (let j = 0; j < channelCount; j++) {
-                    samples[i * channelCount + j] = a[j] * Math.sin(twoPi * frequency * time) * maxValue;
-                }
-            }
-            source.onData(data);
-            // eslint-disable-next-line
-            scheduled = options.schedule(next);
-        }
-
-        let scheduled = options.schedule(next);
-
-        this.close = () => {
-            options.unschedule(scheduled);
-            scheduled = null;
-        };
-
-        this.createTrack = () => {
-            return source.createTrack();
-        };
-
-        this.setFrequency = newFrequency => {
-            frequency = newFrequency;
-        };
-
-        this.setPanning = newPanning => {
-            if (channelCount === 1) {
-                return;
-            }
-            panning = newPanning;
-            a[0] = 1 - (panning / 100);
-            a[1] = 1 - ((100 - panning) / 100);
-        };
-
-        this.setPanning(panning);
-
-        Object.defineProperties(this, {
-            frequency: {
-                get() {
-                    return frequency;
-                }
-            },
-            panning: {
-                get() {
-                    return panning;
-                }
-            }
-        });
-    }
-}
-
-module.exports = RTCAudioSourceSineWave;

package/src/tests/lib/rtcvideosourcewrapper.js

@@ -1,28 +0,0 @@
-/**
- * https://github.com/node-webrtc/node-webrtc/blob/develop/docs/nonstandard-apis.md#programmatic-video
- */
-
-'use strict';
-
-const { RTCVideoSource } = require('wrtc').nonstandard;
-
-class RTCVideoSourceWrapper {
-    constructor() {
-        const source = new RTCVideoSource();
-        const width = 320;
-        const height = 240;
-        const data = new Uint8ClampedArray(width * height * 1.5);
-        const frame = { width, height, data };
-
-        const interval = setInterval(() => {
-            // Update the frame in some way before sending.
-            source.onFrame(frame);
-        });
-
-        this.createTrack = () => {
-            return source.createTrack();
-        };
-    }
-}
-
-module.exports = RTCVideoSourceWrapper;

package/src/tests/sdk/room.test.js

@@ -1,229 +0,0 @@
-const wrtc = require("wrtc");
-const RTCAudioSourceSineWave = require("../lib/rtcaudiosourcesinewave");
-const RTCVideoSourceWrapper = require("../lib/rtcvideosourcewrapper");
-const sfu = require("../../sdk/sfu-extended");
-const constants = require("../../sdk/constants");
-const {waitForTracks, waitForPeerConnectionStableState, waitForPeerConnectionState} = require("../util");
-
-// Jest default timeout
-const JEST_TIMEOUT = 20000;
-
-const SERVER = "ws://127.0.0.1:8080";
-const USER_BOB = "bob@flashphoner.com";
-const BOB_NICKNAME = "bob";
-const USER_ALICE = "alice@flashphoner.com";
-const ALICE_NICKNAME = "alice";
-const PASSWD = "123456";
-
-const ROOM_NAME = "TEST_ROOM";
-const PIN = "1234";
-const USE_WAITING_ROOM = true;
-
-let sfu2;
-
-jest.setTimeout(JEST_TIMEOUT);
-jest.isolateModules(() => {
-    sfu2 = require("../../sdk/sfu-extended");
-});
-
-function stopAfterTimeout(done) {
-    console.log("Test ended");
-    setTimeout(done, 5000);
-}
-
-beforeAll(async () => {
-    await sfu.connect({
-        url: SERVER,
-        username: USER_BOB,
-        password: PASSWD
-    });
-    await sfu2.connect({
-        url: SERVER,
-        username: USER_ALICE,
-        password: PASSWD
-    });
-});
-
-afterAll(async () => {
-    await sfu2.disconnect();
-    await sfu.disconnect();
-});
-
-describe("room", () => {
-    it("should create new room", async () => {
-        const room = sfu.room({
-            name: ROOM_NAME,
-            pin: PIN,
-            pc: new wrtc.RTCPeerConnection()
-        });
-        const ret = await room.createRoom();
-        expect(ret).toBeTruthy();
-    });
-
-    it("should join the room", async () => {
-        const room = sfu.getRoom({name: ROOM_NAME});
-        const ret = await room.join();
-        expect(ret).toBeTruthy();
-        await waitForPeerConnectionStableState(room.pc());
-    });
-
-    it("should configure waiting room", async () => {
-        const room = sfu.getRoom({name: ROOM_NAME});
-        await room.configureWaitingRoom(USE_WAITING_ROOM);
-    })
-
-    describe("second participant", () => {
-        it("should be successfully authorized and joined to the room", async (done) => {
-            console.log("should be successfully authorized and joined to the room");
-            const room = sfu.getRoom({name: ROOM_NAME});
-            const waitingListHandler = async (event) => {
-                if (event.users && event.users.length !== 0) {
-                    const users = event.users;
-                    for (const waitingUser of users) {
-                        const info = await room.subscribeToWaitingParticipant(waitingUser.nickname);
-                        expect(info).toBeTruthy();
-                        expect(Array.isArray(info.info)).toBeTruthy();
-                        expect(info.info.length).toEqual(1);
-                        await waitForTracks(room.pc(), info.info);
-                        await room.unsubscribeFromWaitingParticipant(waitingUser.nickname);
-                        await room.authorizeWaitingList(waitingUser.id, true);
-                        await waitForPeerConnectionStableState(room.pc());
-                    }
-                    room.off(sfu.constants.SFU_ROOM_EVENT.WAITING_LIST, waitingListHandler);
-                    done();
-                }
-            };
-            room.on(sfu.constants.SFU_ROOM_EVENT.WAITING_LIST, waitingListHandler);
-            const room2 = sfu2.room({
-                name: ROOM_NAME,
-                pin: PIN,
-                pc: new wrtc.RTCPeerConnection()
-            });
-            // Audio track
-            const aSource = new RTCAudioSourceSineWave();
-            const aTrack = aSource.createTrack();
-            const aSender = room2.pc().addTrack(aTrack);
-
-            const ret = await room2.join({});
-            expect(ret).toBeTruthy();
-        });
-
-        it("should set new role for the second participant", async () => {
-            const room = sfu.getRoom({name: ROOM_NAME});
-            await room.assignRole(ALICE_NICKNAME, sfu.constants.SFU_PARTICIPANT_ROLE.ADMIN);
-        });
-
-        it("should be able to send message", async () => {
-            const room = sfu.getRoom({name: ROOM_NAME});
-            await room.sendMessage("should be able to send message");
-        });
-
-        it("should be able to send message more then 16384 characters long", async () => {
-            const messageLength = 20000;
-            const letter = "a";
-            let msg = "";
-            for (let i = 0; i < messageLength; i++) {
-                msg += letter;
-            }
-            const room = sfu.getRoom({name: ROOM_NAME});
-            await room.sendMessage(msg);
-        });
-
-        it("should receive message", async (done) => {
-            const msg = "should receive message";
-            const room = sfu.getRoom({name: ROOM_NAME});
-            const room2 = sfu2.getRoom({name: ROOM_NAME});
-            const messageHandler = (message) => {
-                expect(message).toBeTruthy();
-                expect(message.message).toEqual(msg);
-                room2.off(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
-                done();
-            }
-            room2.on(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
-            room.sendMessage(msg);
-        });
-
-        it("should receive message more then 16384 characters long", async (done) => {
-            const messageLength = 20000;
-            const letter = "a";
-            let msg = "";
-            for (let i = 0; i < messageLength; i++) {
-                msg += letter;
-            }
-            const room = sfu.getRoom({name: ROOM_NAME});
-            const room2 = sfu2.getRoom({name: ROOM_NAME});
-            const messageHandler = (message) => {
-                expect(message).toBeTruthy();
-                expect(message.message).toEqual(msg);
-                room.off(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
-                done();
-            }
-            room.on(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
-            room2.sendMessage(msg);
-        });
-
-        it("should leave the room", async () => {
-            const room2 = sfu2.getRoom({name: ROOM_NAME});
-            await room2.leaveRoom();
-            await waitForPeerConnectionState(room2.pc(), "closed");
-        });
-
-        it("the owner should be able to move it to the waiting room", async (done) => {
-            const room = sfu.getRoom({name: ROOM_NAME});
-            room.on(sfu.constants.SFU_ROOM_EVENT.JOINED, async (participant) => {
-                await room.moveToWaitingRoom(participant.name);
-                done();
-            });
-            await room.configureWaitingRoom(false);
-            const room2 = sfu2.room({
-                name: ROOM_NAME,
-                pin: PIN,
-                pc: new wrtc.RTCPeerConnection()
-            });
-            await room2.join({});
-        });
-    });
-
-    it("should update room state", async () => {
-        const room = sfu.getRoom({name: ROOM_NAME});
-        // Audio track
-        const aSource = new RTCAudioSourceSineWave();
-        const aTrack = aSource.createTrack();
-        const aSender = room.pc().addTrack(aTrack);
-        // Video track
-        const vSource = new RTCVideoSourceWrapper();
-        const vTrack = vSource.createTrack();
-        const vSender = room.pc().addTrack(vTrack);
-
-        await room.updateState({});
-        await waitForPeerConnectionStableState(room.pc());
-        aTrack.stop();
-        aSource.close();
-        vTrack.stop();
-        room.pc().removeTrack(aSender);
-        room.pc().removeTrack(vSender);
-        await room.updateState();
-        await waitForPeerConnectionStableState(room.pc());
-    });
-
-    it("should leave room", async () => {
-        const room = sfu.getRoom({name: ROOM_NAME});
-        const ret = await room.leaveRoom();
-        expect(ret).toBeTruthy();
-    });
-
-    it("should destroy room", async (done) => {
-        const room = sfu.room({
-            name: ROOM_NAME,
-            pin: PIN,
-            pc: new wrtc.RTCPeerConnection()
-        });
-        room.on(constants.SFU_ROOM_EVENT.EVICTED, () => {
-            expect(sfu.getRoom({name: ROOM_NAME})).toBeFalsy();
-            done();
-        });
-        await room.createRoom();
-        await room.join();
-        await room.destroyRoom();
-    });
-});