proctoring 2.0.2

data/app/assets/javascripts/kurento/VideoRecordingUsingSignalingServer.js

@@ -0,0 +1,224 @@
+function videoRecordingUsingSignalingServer(props) {
+  // variables
+  let roomName;
+  let userName;
+  let appName;
+  let participants = {};
+  let currentRtcPeer;
+  let iceServers = [];
+
+  let socket = props.socket;
+
+  let proctoringData = document.getElementById("proctoring-data");
+  appName = proctoringData.dataset.appName;
+  roomName = props.event.toString();
+  userName = props.user.toString();
+
+  if (roomName && userName) {
+    let message = {
+      event: "joinRoom",
+      roomName,
+      userName,
+      appName,
+      extraInfo: {},
+    };
+
+    sendMessage(message);
+  }
+
+  function socketListener(message) {
+    switch (message.event) {
+      case "existingParticipants":
+        onExistingParticipants(message.userId, message.existingUsers);
+        break;
+      case "receiveVideoAnswer":
+        onReceiveVideoAnswer(message.senderId, message.sdpAnswer);
+        break;
+      case "candidate":
+        addIceCandidate(message.userId, message.candidate);
+        break;
+      case "turnServer":
+        setTurnServer(message.turnserver);
+        break;
+    }
+  }
+
+  socket.on("signaling-message", socketListener);
+
+  function sendMessage(message) {
+    socket.emit("signaling-message", message);
+  }
+
+  function setTurnServer(turnServer) {
+    iceServers = turnServer;
+  }
+  
+  function stopRecordingAndRestart() {
+    let message = {
+      event: "stopRecordingAndRestart",
+      appName,
+    };
+    sendMessage(message);
+    currentRtcPeer.dispose();
+    socket.removeListener("signaling-message", socketListener);
+    videoRecordingUsingSignalingServer(props);
+  }
+
+  window.onbeforeunload = function () {
+    currentRtcPeer.dispose();
+    socket.disconnect();
+  };
+
+  function receiveVideo(userIdWs, userNameWs) {
+    let video = document.createElement("video");
+    let div = document.createElement("div");
+    div.className = "videoContainer";
+    div.id = `participant-video-${userIdWs}-${userNameWs}`;
+    let name = document.createElement("div");
+    video.id = userIdWs;
+    video.autoplay = true;
+    name.appendChild(document.createTextNode(userNameWs));
+    div.appendChild(video);
+    div.appendChild(name);
+    // divMeetingRoom.appendChild(div);
+
+    const onOffer = (_err, offer, _wp) => {
+      let message = {
+        event: "receiveVideoFrom",
+        userId: user.id,
+        roomName: roomName,
+        sdpOffer: offer,
+      };
+      sendMessage(message);
+    };
+
+    // send Icecandidate
+    const onIceCandidate = (candidate, wp) => {
+      var message = {
+        event: "candidate",
+        userId: user.id,
+        roomName: roomName,
+        candidate: candidate,
+      };
+      sendMessage(message);
+    };
+
+    let user = {
+      id: userIdWs,
+      userName: userNameWs,
+      video: video,
+      rtcPeer: null,
+    };
+
+    participants[user.id] = user;
+
+    let options = {
+      remoteVideo: video,
+      onicecandidate: onIceCandidate,
+    };
+
+    if (iceServers) {
+      options.configurations = {
+        iceServers: iceServers,
+      }
+    }
+
+    // This is for receving candidates
+    user.rtcPeer = kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(
+      options,
+      function (err) {
+        if (err) {
+          return console.error(err);
+        }
+        this.generateOffer(onOffer);
+      }
+    );
+  }
+
+  function onExistingParticipants(userIdWs, existingUsers) {
+    let video = document.createElement("video");
+    video.id = userIdWs;
+    video.autoplay = true;
+
+    let user = {
+      id: userIdWs,
+      userName: userName,
+      video: video,
+      rtcPeer: null,
+    };
+
+    participants[user.id] = user;
+
+    let constraints = {
+      audio: true,
+      video: {
+        mandatory: {
+          maxWidth: 320,
+          maxFrameRate: 15,
+          minFrameRate: 5,
+        },
+      },
+    };
+
+    const onOffer = (_err, offer, _wp) => {
+      console.log("On Offer");
+      let message = {
+        event: "receiveVideoFrom",
+        userId: user.id,
+        roomName: roomName,
+        sdpOffer: offer,
+      };
+      sendMessage(message);
+    };
+
+    // send Icecandidate
+    const onIceCandidate = (candidate, wp) => {
+      var message = {
+        event: "candidate",
+        userId: user.id,
+        roomName: roomName,
+        candidate: candidate,
+      };
+      sendMessage(message);
+    };
+
+    let options = {
+      localVideo: video,
+      mediaConstraints: constraints,
+      onicecandidate: onIceCandidate,
+    };
+
+    if (iceServers) {
+      options.configurations = {
+        iceServers: iceServers,
+      }
+    }
+
+    // This is for sending candidate
+    user.rtcPeer = kurentoUtils.WebRtcPeer.WebRtcPeerSendonly(
+      options,
+      function (err) {
+        if (err) {
+          return console.error(err);
+        }
+        this.generateOffer(onOffer);
+      }
+    );
+
+    currentRtcPeer = user.rtcPeer;
+
+    setTimeout(() => {
+      stopRecordingAndRestart();
+    }, 5*60*1000);
+  }
+
+  function onReceiveVideoAnswer(senderId, sdpAnswer) {
+    const user = participants[senderId];
+    if (user) user.rtcPeer.processAnswer(sdpAnswer);
+  }
+
+  function addIceCandidate(userId, candidate) {
+    const user = participants[userId];
+    if (user) user.rtcPeer.addIceCandidate(candidate);
+  }
+};

data/app/assets/javascripts/kurento/co.js

@@ -0,0 +1,299 @@
+(function(exports){
+
+  /**
+   * toString() reference.
+   */
+  var toString = Object.prototype.toString;
+
+  /**
+   * slice() reference.
+   */
+  var slice = Array.prototype.slice;
+
+  /**
+   * setImmediate() in node.js environment
+   */
+  if (typeof window === 'undefined') {
+    setImmediate = global.setImmediate || process.nextTick
+  }
+
+  /**
+   * Wrap the given generator `fn` and
+   * return a thunk.
+   *
+   * @param {Function} fn
+   * @return {Function}
+   * @api public
+   */
+
+  var co = function co(fn) {
+    var isGenFun = isGeneratorFunction(fn);
+
+    return function (done) {
+      var ctx = this;
+
+      // in toThunk() below we invoke co()
+      // with a generator, so optimize for
+      // this case
+      var gen = fn;
+
+      // we only need to parse the arguments
+      // if gen is a generator function.
+      if (isGenFun) {
+        var args = slice.call(arguments), len = args.length;
+        var hasCallback = len && 'function' == typeof args[len - 1];
+        done = hasCallback ? args.pop() : error;
+        gen = fn.apply(this, args);
+      } else {
+        done = done || error;
+      }
+
+      next();
+
+      // #92
+      // wrap the callback in a setImmediate
+      // so that any of its errors aren't caught by `co`
+      function exit(err, res) {
+        setImmediate(done.bind(ctx, err, res));
+      }
+
+      function next(err, res) {
+        var ret;
+
+        // multiple args
+        if (arguments.length > 2) res = slice.call(arguments, 1);
+
+        // error
+        if (err) {
+          try {
+            ret = gen.throw(err);
+          } catch (e) {
+            return exit(e);
+          }
+        }
+
+        // ok
+        if (!err) {
+          try {
+            ret = gen.next(res);
+          } catch (e) {
+            return exit(e);
+          }
+        }
+
+        // done
+        if (ret.done) return exit(null, ret.value);
+
+        // normalize
+        ret.value = toThunk(ret.value, ctx);
+
+        // run
+        if ('function' == typeof ret.value) {
+          var called = false;
+          try {
+            ret.value.call(ctx, function(){
+              if (called) return;
+              called = true;
+              next.apply(ctx, arguments);
+            });
+          } catch (e) {
+            setImmediate(function(){
+              if (called) return;
+              called = true;
+              next(e);
+            });
+          }
+          return;
+        }
+
+        // invalid
+        next(new Error('yield a function, promise, generator, array, or object'));
+      }
+    }
+  }
+
+  /**
+   * Convert `obj` into a normalized thunk.
+   *
+   * @param {Mixed} obj
+   * @param {Mixed} ctx
+   * @return {Function}
+   * @api private
+   */
+
+  function toThunk(obj, ctx) {
+
+    if (isGeneratorFunction(obj)) {
+      return co(obj.call(ctx));
+    }
+
+    if (isGenerator(obj)) {
+      return co(obj);
+    }
+
+    if (isPromise(obj)) {
+      return promiseToThunk(obj);
+    }
+
+    if ('function' == typeof obj) {
+      return obj;
+    }
+
+    if (isObject(obj) || Array.isArray(obj)) {
+      return objectToThunk.call(ctx, obj);
+    }
+
+    return obj;
+  }
+
+  /**
+   * Convert an object of yieldables to a thunk.
+   *
+   * @param {Object} obj
+   * @return {Function}
+   * @api private
+   */
+
+  function objectToThunk(obj){
+    var ctx = this;
+
+    return function(done){
+      var keys = Object.keys(obj);
+      var pending = keys.length;
+      var results = new obj.constructor();
+      var finished;
+
+      if (!pending) {
+        setImmediate(function(){
+          done(null, results)
+        });
+        return;
+      }
+
+      for (var i = 0; i < keys.length; i++) {
+        run(obj[keys[i]], keys[i]);
+      }
+
+      function run(fn, key) {
+        if (finished) return;
+        try {
+          fn = toThunk(fn, ctx);
+
+          if ('function' != typeof fn) {
+            results[key] = fn;
+            return --pending || done(null, results);
+          }
+
+          fn.call(ctx, function(err, res){
+            if (finished) return;
+
+            if (err) {
+              finished = true;
+              return done(err);
+            }
+
+            results[key] = res;
+            --pending || done(null, results);
+          });
+        } catch (err) {
+          finished = true;
+          done(err);
+        }
+      }
+    }
+  }
+
+  /**
+   * Convert `promise` to a thunk.
+   *
+   * @param {Object} promise
+   * @return {Function}
+   * @api private
+   */
+
+  function promiseToThunk(promise) {
+    return function(fn){
+      promise.then(function(res) {
+        fn(null, res);
+      }, fn);
+    }
+  }
+
+  /**
+   * Check if `obj` is a promise.
+   *
+   * @param {Object} obj
+   * @return {Boolean}
+   * @api private
+   */
+
+  function isPromise(obj) {
+    return obj && 'function' == typeof obj.then;
+  }
+
+  /**
+   * Check if `obj` is a generator.
+   *
+   * @param {Mixed} obj
+   * @return {Boolean}
+   * @api private
+   */
+
+  function isGenerator(obj) {
+    return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw;
+  }
+
+  /**
+   * Check if `obj` is a generator function.
+   *
+   * @param {Mixed} obj
+   * @return {Boolean}
+   * @api private
+   */
+
+  function isGeneratorFunction(obj) {
+    return obj && obj.constructor && 'GeneratorFunction' == obj.constructor.name;
+  }
+
+  /**
+   * Check for plain object.
+   *
+   * @param {Mixed} val
+   * @return {Boolean}
+   * @api private
+   */
+
+  function isObject(val) {
+    return val && Object == val.constructor;
+  }
+
+  /**
+   * Throw `err` in a new stack.
+   *
+   * This is used when co() is invoked
+   * without supplying a callback, which
+   * should only be for demonstrational
+   * purposes.
+   *
+   * @param {Error} err
+   * @api private
+   */
+
+  function error(err) {
+    if (!err) return;
+    setImmediate(function(){
+      throw err;
+    });
+  }
+
+  /**
+   * Set module reference
+   */
+  if(typeof window === 'undefined') {
+    module.exports = co;
+  } else {
+    exports['co'] = co;
+  }
+
+})(typeof module === 'undefined' ? this : module);
+