Source: room-module.js

  1. 'use strict';
  2. var SESSION_STATUS = require('./constants').SESSION_STATUS;
  3. var STREAM_STATUS = require('./constants').STREAM_STATUS;
  4. var Promise = require('promise-polyfill');
  5. const { v1: uuid_v1 } = require('uuid');
  6. var util = require('./util');
  7. var ROOM_REST_APP = "roomApp";
  8. var Flashphoner = require('./flashphoner-core');
  10. /**
  11.  * Room api based on core api
  12.  *
  13.  * @namespace roomApi
  14.  */
  16. /**
  17.  * Initialize connection
  18.  *
  19.  * @param {Object} options session options
  20.  * @param {String} options.urlServer Server address in form of [ws,wss]://host.domain:port
  21.  * @param {String} options.username Username to login with
  22.  * @param {String} options.token JWT Token
  23.  * @param {String} options.appKey Application Key
  24.  * @param {Integer=} options.timeout Connection timeout in milliseconds [0]
  25.  * @param {Integer=} options.pingInterval Server ping interval in milliseconds [0]
  26.  * @param {Integer=} options.receiveProbes A maximum subsequental pings received missing count [0]
  27.  * @param {Integer=} options.probesInterval Interval to check subsequental pings received [0]
  28.  * @returns {roomApi.RoomSession}
  29.  * @memberof roomApi
  30.  * @method connect
  31.  */
  32. var appSession = function (options) {
  33.     /**
  34.      * Represents connection to room api app
  35.      *
  36.      * @namespace roomApi.RoomSession
  37.      */
  38.     var callbacks = {};
  39.     var rooms = {};
  40.     var username_ = options.username;
  41.     var exports;
  42.     var roomHandlers = {};
  43.     var session = Flashphoner.createSession({
  44.         urlServer: options.urlServer,
  45.         mediaOptions: options.mediaOptions,
  46.         appKey: (options.appKey && options.appKey.length != 0) ? options.appKey : ROOM_REST_APP,
  47.         custom: {
  48.             login: options.username,
  49.             token: options.token
  50.         },
  51.         timeout: options.timeout || 0,
  52.         pingInterval: options.pingInterval || 0,
  53.         receiveProbes: options.receiveProbes || 0,
  54.         probesInterval: options.probesInterval || 0
  55.     }).on(SESSION_STATUS.ESTABLISHED, function (session) {
  56.         if (callbacks[session.status()]) {
  57.             callbacks[session.status()](exports);
  58.         }
  59.     }).on(SESSION_STATUS.APP_DATA, function (data) {
  60.         var payload = data.payload;
  61.         if (!payload || !payload.roomName) {
  62.             console.error("Received app data does not contain 'payload' or 'payload.roomName' field. Received data: " + JSON.stringify(data));
  63.             return;
  64.         }
  65.         var roomName = payload.roomName;
  66.         if (roomHandlers[roomName]) {
  67.             roomHandlers[roomName](payload);
  68.         } else {
  69.             console.warn("Failed to find room with name " + roomName);
  70.         }
  71.     }).on(SESSION_STATUS.DISCONNECTED, sessionDied).on(SESSION_STATUS.FAILED, sessionDied);
  73.     //teardown helper
  74.     function sessionDied(session) {
  75.         if (callbacks[session.status()]) {
  76.             callbacks[session.status()](exports);
  77.         }
  78.     }
  80.     /**
  81.      * Disconnect session
  82.      *
  83.      * @memberof roomApi.RoomSession
  84.      * @inner
  85.      */
  86.     var disconnect = function () {
  87.         session.disconnect();
  88.     };
  90.     /**
  91.      * Get session status
  92.      *
  93.      * @returns {string} One of {@link Flashphoner.constants.SESSION_STATUS}
  94.      * @memberof roomApi.RoomSession
  95.      * @inner
  96.      */
  97.     var status = function () {
  98.         return session.status();
  99.     };
  101.     /**
  102.      * Get session id
  103.      *
  104.      * @returns {string} session id
  105.      * @memberof roomApi.RoomSession
  106.      * @inner
  107.      */
  108.     var id = function () {
  109.         return session.id();
  110.     };
  112.     /**
  113.      * Get server address
  114.      *
  115.      * @returns {string} Server url
  116.      * @memberof roomApi.RoomSession
  117.      * @inner
  118.      */
  119.     var getServerUrl = function () {
  120.         return session.getServerUrl();
  121.     };
  123.     /**
  124.      * Get session username
  125.      *
  126.      * @returns {string} username
  127.      * @memberof roomApi.RoomSession
  128.      * @inner
  129.      */
  130.     var username = function () {
  131.         return username_;
  132.     };
  134.     /**
  135.      * Get rooms
  136.      *
  137.      * @returns {roomApi.Room[]}
  138.      * @memberof roomApi.RoomSession
  139.      * @inner
  140.      */
  141.     var getRooms = function () {
  142.         return util.copyObjectToArray(rooms);
  143.     };
  146.     /**
  147.      * Add session event callback.
  148.      *
  149.      * @param {string} event One of {@link Flashphoner.constants.SESSION_STATUS} events
  150.      * @param {RoomSession~eventCallback} callback Callback function
  151.      * @returns {roomApi.RoomSession} Room Session
  152.      * @throws {TypeError} Error if event is not specified
  153.      * @throws {Error} Error if callback is not a valid function
  154.      * @memberof roomApi.RoomSession
  155.      * @inner
  156.      */
  157.     var on = function (event, callback) {
  158.         if (!event) {
  159.             throw new Error("Event can't be null", "TypeError");
  160.         }
  161.         if (!callback || typeof callback !== 'function') {
  162.             throw new Error("Callback needs to be a valid function");
  163.         }
  164.         callbacks[event] = callback;
  165.         return exports;
  166.     };
  168.     /**
  169.      * Join room
  170.      *
  171.      * @param {Object} options Room options
  172.      * @param {String} options.name Room name
  173.      * @param {Boolean} options.record Record
  174.      * @returns {roomApi.Room}
  175.      * @memberof roomApi.RoomSession
  176.      * @inner
  177.      */
  178.     var join = function (options) {
  179.         /**
  180.          * Room
  181.          *
  182.          * @namespace roomApi.Room
  183.          */
  184.         var room = {};
  185.         var name_ = options.name;
  186.         var record_ = options.record;
  187.         var participants = {};
  188.         var callbacks = {};
  189.         var stateStreams = {};
  190.         roomHandlers[name_] = function (data) {
  191.             /**
  192.              * Room participant
  193.              *
  194.              * @namespace roomApi.Room.Participant
  195.              */
  196.             var participant;
  197.             if (data.name == "STATE") {
  198.                 if (data.info) {
  199.                     for (var i = 0; i < data.info.length; i++) {
  200.                         participantFromState(data.info[i]);
  201.                     }
  202.                     stateStreams = {};
  203.                 }
  204.                 if (callbacks["STATE"]) {
  205.                     callbacks["STATE"](room);
  206.                 }
  207.             } else if (data.name == "JOINED") {
  208.                 participants[data.info] = {
  209.                     streams: {},
  210.                     name: function () {
  211.                         return data.info;
  212.                     },
  213.                     sendMessage: attachSendMessage(data.info),
  214.                     getStreams: function () {
  215.                         return util.copyObjectToArray(this.streams);
  216.                     }
  217.                 };
  218.                 if (callbacks["JOINED"]) {
  219.                     callbacks["JOINED"](participants[data.info]);
  220.                 }
  221.             } else if (data.name == "LEFT") {
  222.                 participant = participants[data.info];
  223.                 delete participants[data.info];
  224.                 if (callbacks["LEFT"]) {
  225.                     callbacks["LEFT"](participant);
  226.                 }
  227.             } else if (data.name == "PUBLISHED") {
  228.                 participant = participants[data.info.login];
  229.                 participant.streams[data.info.name] = {
  230.                     play: play(data.info.name),
  231.                     stop: stop(data.info.name),
  232.                     id: id(data.info.name),
  233.                     streamName: function () {
  234.                         return data.info.name
  235.                     }
  236.                 };
  237.                 if (callbacks["PUBLISHED"]) {
  238.                     callbacks["PUBLISHED"](participant);
  239.                 }
  240.             } else if (data.name == "FAILED" || data.name == "UNPUBLISHED") {
  241.                 participant = participants[data.info.login];
  242.                 if (participant != null)
  243.                     delete participant.streams[data.info.name];
  244.             } else if (data.name == "MESSAGE") {
  245.                 if (callbacks["MESSAGE"]) {
  246.                     callbacks["MESSAGE"]({
  247.                         from: participants[data.info.from],
  248.                         text: data.info.text
  249.                     });
  250.                 }
  251.             }
  252.         };
  254.         //participant creation helper
  255.         function participantFromState(state) {
  256.             var participant = {};
  258.             if (state.hasOwnProperty("login")) {
  259.                 var login = state.login;
  260.                 var streamName = state.name;
  261.                 stateStreams[streamName] = {
  262.                     /**
  263.                      * Play participant stream
  264.                      *
  265.                      * @param {HTMLElement} display Div element stream should be displayed in
  266.                      * @returns {Stream} Local stream object
  267.                      * @memberof roomApi.Room.Participant.Stream
  268.                      * @inner
  269.                      */
  270.                     play: play(streamName),
  271.                     /**
  272.                      * Stop participant stream
  273.                      *
  274.                      * @memberof roomApi.Room.Participant.Stream
  275.                      * @inner
  276.                      */
  277.                     stop: stop(streamName),
  278.                     /**
  279.                      * Get participant stream id
  280.                      *
  281.                      * @returns {String} Stream id
  282.                      * @memberof roomApi.Room.Participant.Stream
  283.                      * @inner
  284.                      */
  285.                     id: id(streamName),
  286.                     /**
  287.                      * Get participant stream name
  288.                      *
  289.                      * @returns {String} Stream name
  290.                      * @memberof roomApi.Room.Participant.Stream
  291.                      * @inner
  292.                      */
  293.                     streamName: function () {
  294.                         return streamName
  295.                     }
  296.                 };
  298.                 if (participants[login] != null) {
  299.                     participant = participants[login];
  300.                 } else {
  301.                     participant = {
  302.                         streams: {},
  303.                         /**
  304.                          * Get participant name
  305.                          *
  306.                          * @returns {String} Participant name
  307.                          * @memberof roomApi.Room.Participant
  308.                          * @inner
  309.                          */
  310.                         name: function () {
  311.                             return login;
  312.                         },
  313.                         /**
  314.                          * Send message to participant
  315.                          *
  316.                          * @param {String} message Message to send
  317.                          * @param {Function} error Error callback
  318.                          * @memberof roomApi.Room.Participant
  319.                          * @inner
  320.                          */
  321.                         sendMessage: attachSendMessage(login),
  322.                         /**
  323.                          * Get participant streams
  324.                          *
  325.                          * @returns {Array<roomApi.Room.Participant.Stream>} Streams
  326.                          * @memberof roomApi.Room.Participant
  327.                          * @inner
  328.                          */
  329.                         getStreams: function () {
  330.                             return util.copyObjectToArray(this.streams);
  331.                         }
  332.                     };
  333.                     participants[participant.name()] = participant;
  334.                 }
  335.                 /**
  336.                  * Room participant
  337.                  *
  338.                  * @namespace roomApi.Room.Participant.Stream
  339.                  */
  340.             } else {
  341.                 participant = {
  342.                     streams: {},
  343.                     name: function () {
  344.                         return state;
  345.                     },
  346.                     sendMessage: attachSendMessage(state),
  347.                     getStreams: function () {
  348.                         return util.copyObjectToArray(this.streams);
  349.                     }
  350.                 }
  351.             }
  352.             if (Object.keys(stateStreams).length != 0) {
  353.                 for (var k in stateStreams) {
  354.                     if (stateStreams.hasOwnProperty(k)) {
  355.                         participant.streams[k] = stateStreams[k];
  356.                         delete stateStreams[k];
  357.                     }
  358.                 }
  359.             }
  360.             participants[participant.name()] = participant;
  361.             return participant;
  362.         }
  364.         /**
  365.          * Get room name
  366.          *
  367.          * @returns {String} Room name
  368.          * @memberof roomApi.Room
  369.          * @inner
  370.          */
  371.         var name = function () {
  372.             return name_;
  373.         };
  375.         /**
  376.          * Leave room
  377.          *
  378.          * @returns {Promise<room>}
  379.          * @memberof roomApi.Room
  380.          * @inner
  381.          */
  382.         var leave = function () {
  383.             return new Promise(function (resolve, reject) {
  384.                 sendAppCommand("leave", {name: name_}).then(function () {
  385.                     cleanUp();
  386.                     resolve(room);
  387.                 }, function () {
  388.                     cleanUp();
  389.                     reject(room);
  390.                 });
  392.                 function cleanUp() {
  393.                     //clear streams
  394.                     var streams = session.getStreams();
  395.                     for (var i = 0; i < streams.length; i++) {
  396.                         if (streams[i].name().indexOf(name_ + "-" + username_) !== -1 && streams[i].status() != STREAM_STATUS.UNPUBLISHED) {
  397.                             streams[i].stop();
  398.                         } else if (streams[i].name().indexOf(name_) !== -1 && streams[i].status() != STREAM_STATUS.STOPPED) {
  399.                             streams[i].stop();
  400.                         }
  401.                     }
  402.                     delete roomHandlers[name_];
  403.                     delete rooms[name_];
  404.                 }
  405.             });
  406.         };
  408.         /**
  409.          * Publish stream inside room
  410.          *
  411.          * @param {Object} options Stream options
  412.          * @param {string=} options.name Stream name
  413.          * @param {Object=} options.constraints Stream constraints
  414.          * @param {Boolean=} options.record Enable stream recording
  415.          * @param {Boolean=} options.cacheLocalResources Display will contain local video after stream release
  416.          * @param {HTMLElement} options.display Div element stream should be displayed in
  417.          * @returns {Stream}
  418.          * @memberof roomApi.Room
  419.          * @inner
  420.          */
  421.         var publish = function (options) {
  422.             options.name = (options.name) ? (name_ + "-" + username_ + "-" + uuid_v1().substr(0, 4) + "-" + options.name) : (name_ + "-" + username_ + "-" + uuid_v1().substr(0, 4));
  423.             options.cacheLocalResources = (typeof options.cacheLocalResources === "boolean") ? options.cacheLocalResources : true;
  424.             options.custom = {name: name_};
  425.             var stream = session.createStream(options);
  426.             stream.publish();
  427.             return stream;
  428.         };
  430.         /**
  431.          * Add room event callback.
  432.          *
  433.          * @param {string} event One of {@link roomApi.events} events
  434.          * @param {roomApi.Room~eventCallback} callback Callback function
  435.          * @returns {roomApi.Room} room
  436.          * @throws {TypeError} Error if event is not specified
  437.          * @throws {Error} Error if callback is not a valid function
  438.          * @memberof roomApi.Room
  439.          * @inner
  440.          */
  441.         var on = function (event, callback) {
  442.             if (!event) {
  443.                 throw new Error("Event can't be null", "TypeError");
  444.             }
  445.             if (!callback || typeof callback !== 'function') {
  446.                 throw new Error("Callback needs to be a valid function");
  447.             }
  448.             callbacks[event] = callback;
  449.             return room;
  450.         };
  452.         /**
  453.          * Get participants
  454.          *
  455.          * @returns {roomApi.Room.Participant}
  456.          * @memberof roomApi.Room
  457.          * @inner
  458.          */
  459.         var getParticipants = function () {
  460.             return util.copyObjectToArray(participants);
  461.         };
  463.         //participant helpers
  464.         function play(streamName) {
  465.             // Pass stream options to play #WCS-3445
  466.             return function (display, options = {}) {
  467.                 var streamOptions = {
  468.                     ...options,
  469.                     name: streamName,
  470.                     display: display,
  471.                     custom: {name: name_}
  472.                 };
  473.                 var stream = session.createStream(streamOptions);
  474.                 stream.play();
  475.                 return stream;
  476.             }
  477.         }
  479.         function stop(streamName) {
  480.             return function () {
  481.                 var streams = session.getStreams();
  482.                 for (var i = 0; i < streams.length; i++) {
  483.                     if (streams[i].name() == streamName && streams[i].status() != STREAM_STATUS.UNPUBLISHED) {
  484.                         streams[i].stop();
  485.                     }
  486.                 }
  487.             }
  488.         }
  490.         function id(streamName) {
  491.             return function () {
  492.                 var streams = session.getStreams();
  493.                 for (var i = 0; i < streams.length; i++) {
  494.                     if (streams[i].name() == streamName)
  495.                         return streams[i].id();
  496.                 }
  497.             }
  498.         }
  500.         function attachSendMessage(recipientName) {
  501.             return function (text, error) {
  502.                 var message = {
  503.                     roomConfig: {
  504.                         name: name_
  505.                     },
  506.                     to: recipientName,
  507.                     text: text
  508.                 };
  509.                 sendAppCommand("sendMessage", message).then(function () {
  510.                 }, function () {
  511.                     if (error) {
  512.                         error();
  513.                     }
  514.                 });
  515.             }
  516.         }
  518.         //sendData helper
  519.         function sendAppCommand(commandName, data) {
  520.             var command = {
  521.                 command: commandName,
  522.                 options: data
  523.             };
  524.             return session.sendData(command);
  525.         }
  527.         sendAppCommand("join", {name: name_, record: record_}).then(function () {
  528.         }, function (info) {
  529.             if (callbacks["FAILED"]) {
  530.                 callbacks["FAILED"](room, info.info);
  531.             }
  532.         });
  533.         room.name = name;
  534.         room.leave = leave;
  535.         room.publish = publish;
  536.         room.getParticipants = getParticipants;
  537.         room.on = on;
  538.         rooms[name_] = room;
  539.         return room;
  540.     };
  543.     exports = {
  544.         disconnect: disconnect,
  545.         id: id,
  546.         getServerUrl: getServerUrl,
  547.         username: username,
  548.         status: status,
  549.         getRooms: getRooms,
  550.         join: join,
  551.         on: on
  552.     };
  553.     return exports;
  554. };
  556. var events = {
  557.     STATE: "STATE",
  558.     JOINED: "JOINED",
  559.     LEFT: "LEFT",
  560.     PUBLISHED: "PUBLISHED",
  561.     MESSAGE: "MESSAGE",
  562.     FAILED: "FAILED"
  563. };
  565. module.exports = {
  566.     connect: appSession,
  567.     events: events,
  568.     sdk: Flashphoner    
  569. };