kurento_rails 0.1.0

data/lib/generators/kurento_rails/templates/javascript/kurento-rails-js/kurento-rails.js

@@ -0,0 +1,635 @@
+(function() {
+  var StreamingHelper, kurentoRailsHelpers,
+    hasProp = {}.hasOwnProperty;
+
+  kurentoRailsHelpers = {};
+
+  kurentoRailsHelpers.getRailsUrlFromBrowser = (function(_this) {
+    return function() {
+      return location.hostname + "/websocket";
+    };
+  })(this);
+
+  kurentoRailsHelpers.generateKurentoVideoUrl = (function(_this) {
+    return function(baseFileLocation, videoName) {
+      var date, dateString;
+      date = new Date();
+      dateString = (date.getMonth() + 1) + "-" + (date.getDate()) + "-" + (date.getFullYear()) + "_" + (date.getHours()) + ":" + (date.getMinutes()) + ":" + (date.getSeconds());
+      return baseFileLocation + "/" + (encodeURIComponent(videoName.toLowerCase().replace(/\s/g, '-'))) + "-" + dateString + ".webm";
+    };
+  })(this);
+
+  kurentoRailsHelpers.onIceCandidate = (function(_this) {
+    return function(webRtcEndpoint, webRtcPeer, onError) {
+      webRtcPeer.on('icecandidate', function(candidate) {
+        candidate = kurentoClient.register.complexTypes.IceCandidate(candidate);
+        return webRtcEndpoint.addIceCandidate(candidate, onError);
+      });
+      return webRtcEndpoint.on('OnIceCandidate', function(event) {
+        return webRtcPeer.addIceCandidate(event.candidate, onError);
+      });
+    };
+  })(this);
+
+  StreamingHelper = (function() {
+    function StreamingHelper(kurentoUrl, railsUrl) {
+      var onBroadcastingError, onBroadcastingOffer, onLiveViewError, onLiveViewOffer, onRecordedError, onRecordedOffer, timeoutFunction;
+      this.kurentoUrl = kurentoUrl;
+      this.railsUrl = railsUrl != null ? railsUrl : kurentoRailsHelpers.getRailsUrlFromBrowser();
+      this.kurento = kurentoClient(this.kurentoUrl);
+      this.rails_websocket_dispatcher = new WebSocketRails(this.railsUrl);
+      this.broadcast = {};
+      this.view = {};
+
+      /* BROADCASTING FUNCTIONS AND MEMBERS */
+      this.broadcast.kurentoObjects = {};
+      this.broadcast.kurentoObjects.pipeline = null;
+      this.broadcast.kurentoObjects.webRtcPeer = null;
+      this.broadcast.kurentoObjects.recorder = null;
+      this.broadcast.kurentoObjects.webRtcEndpoint = null;
+      this.broadcast.kurentoObjects.videoStreamId = null;
+      this.broadcast.kurentoObjects.currentCallback = null;
+      onBroadcastingError = (function(_this) {
+        return function(error) {
+          if (error) {
+            console.log("Broadcasting error:", error);
+            _this.broadcast.stopBroadcasting();
+            if (_this.broadcast.kurentoObjects.currentCallback) {
+              return _this.broadcast.kurentoObjects.currentCallback(error);
+            }
+          }
+        };
+      })(this);
+      onBroadcastingOffer = (function(_this) {
+        return function(error, offer) {
+          if (error) {
+            return onBroadcastingError(error);
+          }
+          return _this.kurento.create('MediaPipeline', function(error, pipeline) {
+            var file_url, mediaElements;
+            if (error || !_this.broadcast.kurentoObjects.webRtcPeer) {
+              return onBroadcastingError(error);
+            }
+            _this.broadcast.kurentoObjects.pipeline = pipeline;
+            file_url = kurentoRailsHelpers.generateKurentoVideoUrl(_this.broadcast.kurentoObjects.baseFileLocation, _this.broadcast.kurentoObjects.videoName);
+            mediaElements = [
+              {
+                type: 'WebRtcEndpoint',
+                params: {}
+              }, {
+                type: 'RecorderEndpoint',
+                params: {
+                  uri: file_url
+                }
+              }
+            ];
+            return pipeline.create(mediaElements, function(error, elements) {
+              if (error || !_this.broadcast.kurentoObjects.pipeline) {
+                return onBroadcastingError(error);
+              }
+              _this.broadcast.kurentoObjects.webRtcEndpoint = elements[0], _this.broadcast.kurentoObjects.recorder = elements[1];
+              kurentoRailsHelpers.onIceCandidate(_this.broadcast.kurentoObjects.webRtcEndpoint, _this.broadcast.kurentoObjects.webRtcPeer, onBroadcastingError);
+              return _this.broadcast.kurentoObjects.webRtcEndpoint.processOffer(offer, function(error, answer) {
+                if (error || !_this.broadcast.kurentoObjects.pipeline) {
+                  return onBroadcastingError(error);
+                }
+                _this.broadcast.kurentoObjects.webRtcEndpoint.gatherCandidates(onBroadcastingError);
+                _this.broadcast.kurentoObjects.webRtcPeer.processAnswer(answer, onBroadcastingError);
+                return _this.broadcast.kurentoObjects.webRtcEndpoint.connect(_this.broadcast.kurentoObjects.recorder, function(error) {
+                  if (error || !_this.broadcast.kurentoObjects.pipeline) {
+                    return onBroadcastingError(error);
+                  }
+                  return _this.broadcast.kurentoObjects.recorder.record(function(error) {
+                    var save_to_rails_failure, save_to_rails_success, streamToBroadcast;
+                    if (error || !_this.broadcast.kurentoObjects.pipeline) {
+                      return onBroadcastingError(error);
+                    }
+                    save_to_rails_success = function(stream) {
+                      _this.broadcast.kurentoObjects.videoStreamId = stream.id;
+                      if (_this.broadcast.kurentoObjects.currentCallback) {
+                        return _this.broadcast.kurentoObjects.currentCallback(null, stream);
+                      }
+                    };
+                    save_to_rails_failure = function(stream) {
+                      if (_this.broadcast.kurentoObjects.currentCallback) {
+                        return _this.broadcast.kurentoObjects.currentCallback("Failed to save the data to rails", stream);
+                      }
+                    };
+                    streamToBroadcast = {
+                      name: _this.broadcast.kurentoObjects.videoName,
+                      pipeline: _this.broadcast.kurentoObjects.pipeline.id,
+                      file_url: file_url,
+                      sender_rtc: _this.broadcast.kurentoObjects.webRtcEndpoint.id,
+                      streaming: true
+                    };
+                    return _this.rails_websocket_dispatcher.trigger('streams.broadcast', streamToBroadcast, save_to_rails_success, save_to_rails_failure);
+                  });
+                });
+              });
+            });
+          });
+        };
+      })(this);
+      this.broadcast.broadcast = (function(_this) {
+        return function(videoName, videoElement, baseFileLocation, callback) {
+          var options;
+          if (baseFileLocation == null) {
+            baseFileLocation = "file:///kurento";
+          }
+          if (callback == null) {
+            callback = null;
+          }
+          _this.broadcast.kurentoObjects.currentCallback = callback;
+          _this.broadcast.kurentoObjects.baseFileLocation = baseFileLocation;
+          _this.broadcast.kurentoObjects.videoName = videoName;
+          if (videoElement === null || $(videoElement).prop("tagName").toLowerCase().trim() === !"video") {
+            return onBroadcastingError("You must pass in a valid video tag");
+          }
+          videoElement = $(videoElement)[0];
+          options = {
+            localVideo: videoElement
+          };
+          return _this.broadcast.kurentoObjects.webRtcPeer = kurentoUtils.WebRtcPeer.WebRtcPeerSendonly(options, function(error) {
+            if (error) {
+              return onBroadcastingError(error);
+            }
+            return this.generateOffer(onBroadcastingOffer);
+          });
+        };
+      })(this);
+      this.broadcast.stopBroadcasting = (function(_this) {
+        return function(callback) {
+          var failed_to_notify_rails, successfully_notified_rails;
+          if (callback == null) {
+            callback = null;
+          }
+          successfully_notified_rails = function(stream) {
+            _this.broadcast.kurentoObjects.videoStreamId = null;
+            if (callback) {
+              return callback();
+            }
+          };
+          failed_to_notify_rails = function(stream) {
+            console.log("Unable to update video stream status in rails");
+            if (callback) {
+              return callback("Unable to update video stream status in rails");
+            }
+          };
+          if (_this.broadcast.kurentoObjects.recorder) {
+            _this.broadcast.kurentoObjects.recorder.stop();
+            _this.broadcast.kurentoObjects.recorder = null;
+          }
+          if (_this.broadcast.kurentoObjects.webRtcEndpoint) {
+            _this.broadcast.kurentoObjects.webRtcEndpoint.release();
+            _this.broadcast.kurentoObjects.webRtcEndpoint = null;
+          }
+          if (_this.broadcast.kurentoObjects.currentCallback) {
+            _this.broadcast.kurentoObjects.currentCallback = null;
+          }
+          if (_this.broadcast.kurentoObjects.webRtcPeer) {
+            _this.broadcast.kurentoObjects.webRtcPeer.dispose();
+            _this.broadcast.kurentoObjects.webRtcPeer = null;
+          }
+          if (_this.broadcast.kurentoObjects.pipeline) {
+            _this.broadcast.kurentoObjects.pipeline.release();
+            _this.broadcast.kurentoObjects.pipeline = null;
+          }
+          if (_this.broadcast.kurentoObjects.videoStreamId) {
+            return _this.rails_websocket_dispatcher.trigger('streams.stop_broadcasting', '', successfully_notified_rails, failed_to_notify_rails);
+          } else {
+            if (callback) {
+              return callback();
+            }
+          }
+        };
+      })(this);
+
+      /* END BROADCASTING FUNCTIONS AND MEMBERS */
+
+      /* VIEWING FUNCTIONS AND MEMBERS */
+      this.view.live = {};
+      this.view.recorded = {};
+      this.view.live.kurentoObjects = {};
+      this.view.recorded.kurentoObjects = {};
+      this.view.live.activeStreams = (function(_this) {
+        return function(callback, searchParams) {
+          var error, success;
+          if (callback == null) {
+            callback = null;
+          }
+          if (searchParams == null) {
+            searchParams = {};
+          }
+          success = function(streams) {
+            if (callback) {
+              return callback(null, streams);
+            }
+          };
+          error = function(streams) {
+            if (callback) {
+              return callback("There was an error getting the streams", streams);
+            }
+          };
+          return _this.rails_websocket_dispatcher.trigger('streams.active_streams', searchParams, success, error);
+        };
+      })(this);
+      this.view.live.subscribeToStreams = (function(_this) {
+        return function(newStreamHandler, streamDeactivatedHandler) {
+          return _this.view.live.createChannel('video_streams', {
+            'new': newStreamHandler,
+            'remove': streamDeactivatedHandler
+          });
+        };
+      })(this);
+      this.view.live.createChannel = (function(_this) {
+        return function(channelName, events) {
+          var channel, eventHandler, eventName, results;
+          channel = _this.rails_websocket_dispatcher.subscribe(channelName);
+          results = [];
+          for (eventName in events) {
+            if (!hasProp.call(events, eventName)) continue;
+            eventHandler = events[eventName];
+            results.push(channel.bind(eventName, eventHandler));
+          }
+          return results;
+        };
+      })(this);
+      this.view.live.triggerChannelEvent = (function(_this) {
+        return function(channelName, eventName, objectToSend) {
+          var channel;
+          channel = _this.rails_websocket_dispatcher.subscribe(channelName);
+          return channel.trigger(eventName, objectToSend);
+        };
+      })(this);
+      this.view.live.onEndOfStream = (function(_this) {
+        return function(stream, endOfStreamHandler) {
+          var channel;
+          channel = _this.rails_websocket_dispatcher.subscribe("stream-" + stream.id);
+          return channel.bind('end-of-stream', function(updated_stream) {
+            _this.view.live.stopViewing();
+            return endOfStreamHandler(updated_stream);
+          });
+        };
+      })(this);
+      onLiveViewError = (function(_this) {
+        return function(error) {
+          if (error) {
+            console.log("Error!", error);
+          }
+          _this.view.live.stopViewing();
+          if (_this.view.live.kurentoObjects.callback) {
+            return _this.view.live.kurentoObjects.callback(error);
+          }
+        };
+      })(this);
+      onLiveViewOffer = (function(_this) {
+        return function(error, offer) {
+          var pipeline, presenterEndpoint, ref;
+          if (error) {
+            return onLiveViewError(error);
+          }
+          if (_this.view.live.kurentoObjects.pipeline && _this.view.live.kurentoObjects.presenterWebRtcEndpoint) {
+            ref = [_this.view.live.kurentoObjects.pipeline, _this.view.live.kurentoObjects.presenterWebRtcEndpoint], pipeline = ref[0], presenterEndpoint = ref[1];
+            return pipeline.create('WebRtcEndpoint', function(error, endpoint) {
+              if (error || !_this.view.live.kurentoObjects.pipeline) {
+                return onLiveViewError(error);
+              }
+              _this.view.live.kurentoObjects.viewerWebRtcEndpoint = endpoint;
+              kurentoRailsHelpers.onIceCandidate(endpoint, _this.view.live.kurentoObjects.webRtcPeer, function() {});
+              endpoint.on('OnIceCandidate', function(event) {
+                var candidate;
+                return candidate = kurentoClient.register.complexTypes.IceCandidate(event.candidate);
+              });
+              return endpoint.processOffer(offer, function(error, answer) {
+                if (error || !_this.view.live.kurentoObjects.pipeline) {
+                  return onLiveViewError(error);
+                }
+                _this.view.live.kurentoObjects.webRtcPeer.processAnswer(answer, function(error) {
+                  if (error) {
+                    return onLiveViewError(error);
+                  }
+                });
+                endpoint.gatherCandidates(function(error) {
+                  if (error) {
+                    return onLiveViewError(error);
+                  }
+                });
+                return _this.view.live.kurentoObjects.presenterWebRtcEndpoint.connect(endpoint, function(error) {
+                  if (error || !_this.view.live.kurentoObjects.pipeline) {
+                    return onLiveViewError(error);
+                  }
+                  if (_this.view.live.kurentoObjects.callback) {
+                    return _this.view.live.kurentoObjects.callback(null, "Successfully started stream!");
+                  }
+                });
+              });
+            });
+          }
+        };
+      })(this);
+      this.view.live.startViewing = (function(_this) {
+        return function(stream, videoElement, callback) {
+          if (callback == null) {
+            callback = null;
+          }
+          _this.view.live.kurentoObjects.callback = callback;
+          if (videoElement === null || $(videoElement).prop("tagName").toLowerCase().trim() === !"video") {
+            return onLiveViewError("You must pass in a valid video tag");
+          }
+          videoElement = $(videoElement)[0];
+          return _this.kurento.getMediaobjectById(stream.sender_rtc, function(error, webRtcEndpoint) {
+            if (error) {
+              return onLiveViewError(error);
+            }
+            _this.view.live.kurentoObjects.presenterWebRtcEndpoint = webRtcEndpoint;
+            return _this.kurento.getMediaobjectById(stream.pipeline, function(error, pipeline) {
+              var options;
+              if (error || !_this.view.live.kurentoObjects.presenterWebRtcEndpoint) {
+                return onLiveViewError(error);
+              }
+              _this.view.live.kurentoObjects.pipeline = pipeline;
+              options = {
+                remoteVideo: videoElement
+              };
+              return _this.view.live.kurentoObjects.webRtcPeer = kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(options, function(error) {
+                if (error) {
+                  return onLiveViewError(error);
+                }
+                return this.generateOffer(onLiveViewOffer);
+              });
+            });
+          });
+        };
+      })(this);
+      this.view.live.stopViewing = (function(_this) {
+        return function(callback) {
+          if (callback == null) {
+            callback = null;
+          }
+          if (_this.view.live.kurentoObjects.callback) {
+            _this.view.live.kurentoObjects.callback = null;
+          }
+          if (_this.view.live.kurentoObjects.viewerWebRtcEndpoint) {
+            _this.view.live.kurentoObjects.viewerWebRtcEndpoint.release();
+            _this.view.live.kurentoObjects.viewerWebRtcEndpoint = null;
+          }
+          if (_this.view.live.kurentoObjects.webRtcPeer) {
+            _this.view.live.kurentoObjects.webRtcPeer.dispose();
+            _this.view.live.kurentoObjects.webRtcPeer = null;
+          }
+          if (_this.view.live.kurentoObjects.pipeline) {
+            _this.view.live.kurentoObjects.pipeline = null;
+          }
+          if (_this.view.live.kurentoObjects.presenterWebRtcEndpoint) {
+            _this.view.live.kurentoObjects.presenterWebRtcEndpoint = null;
+          }
+          if (callback) {
+            return callback();
+          }
+        };
+      })(this);
+      this.view.recorded.availableStreams = (function(_this) {
+        return function(callback, searchParams) {
+          var error, success;
+          if (callback == null) {
+            callback = null;
+          }
+          if (searchParams == null) {
+            searchParams = {};
+          }
+          success = function(streams) {
+            if (callback) {
+              return callback(null, streams);
+            }
+          };
+          error = function(streams) {
+            if (callback) {
+              return callback("There was an error getting the streams", streams);
+            }
+          };
+          return _this.rails_websocket_dispatcher.trigger('streams.recorded_streams', searchParams, success, error);
+        };
+      })(this);
+      onRecordedError = (function(_this) {
+        return function(error) {
+          if (error) {
+            console.log("Error: ", error);
+          }
+          _this.view.recorded.stopViewing();
+          if (_this.view.recorded.kurentoObjects.callback) {
+            return _this.view.recorded.kurentoObjects.callback(error);
+          }
+        };
+      })(this);
+      onRecordedOffer = (function(_this) {
+        return function(error, offer) {
+          console.log("In the offer function");
+          if (error) {
+            onRecordedError(error);
+          }
+          return _this.kurento.create('MediaPipeline', function(error, pipeline) {
+            if (error) {
+              return onRecordedError(error);
+            }
+            _this.view.recorded.kurentoObjects.pipeline = pipeline;
+            return pipeline.create('WebRtcEndpoint', function(error, endpoint) {
+              var options;
+              if (error || !_this.view.recorded.kurentoObjects.pipeline) {
+                return onRecordedError(error);
+              }
+              _this.view.recorded.kurentoObjects.webRtcEndpoint = endpoint;
+              kurentoRailsHelpers.onIceCandidate(endpoint, _this.view.recorded.kurentoObjects.webRtcPeer, function() {});
+              endpoint.processOffer(offer, function(error, answer) {
+                if (error || !_this.view.recorded.kurentoObjects.pipeline) {
+                  return onRecordedError(error);
+                }
+                endpoint.gatherCandidates(function() {});
+                return _this.view.recorded.kurentoObjects.webRtcPeer.processAnswer(answer);
+              });
+              options = {
+                uri: _this.view.recorded.kurentoObjects.fileUrl
+              };
+              return pipeline.create('PlayerEndpoint', options, function(error, player) {
+                if (error || !_this.view.recorded.kurentoObjects.pipeline) {
+                  return onRecordedError(error);
+                }
+                player.on('EndOfStream', function(event) {
+                  var channel;
+                  channel = _this.rails_websocket_dispatcher.subscribe("recorded-stream-" + _this.view.recorded.kurentoObjects.streamId);
+                  channel.trigger('end-of-stream', _this.view.recorded.kurentoObjects.streamId);
+                  return _this.view.recorded.stopViewing();
+                });
+                return player.connect(endpoint, function(error) {
+                  if (error || !_this.view.recorded.kurentoObjects.pipeline) {
+                    return onRecordedError(error);
+                  }
+                  return player.play(function(error) {
+                    if (error || !_this.view.recorded.kurentoObjects.pipeline) {
+                      return onRecordedError(error);
+                    }
+                    if (_this.view.recorded.kurentoObjects.callback) {
+                      return _this.view.recorded.kurentoObjects.callback();
+                    }
+                  });
+                });
+              });
+            });
+          });
+        };
+      })(this);
+      this.view.recorded.startViewing = (function(_this) {
+        return function(stream, videoElement, callback) {
+          var options;
+          if (callback == null) {
+            callback = null;
+          }
+          console.log("Stream", stream);
+          _this.view.recorded.kurentoObjects.fileUrl = stream.file_url;
+          _this.view.recorded.kurentoObjects.streamId = stream.id;
+          _this.view.recorded.kurentoObjects.videoElement = videoElement;
+          _this.view.recorded.kurentoObjects.callback = callback;
+          if (videoElement === null || $(videoElement).prop("tagName").toLowerCase().trim() === !"video") {
+            return onRecordedError("You must pass in a valid video tag");
+          }
+          videoElement = $(videoElement)[0];
+          options = {
+            remoteVideo: videoElement
+          };
+          return _this.view.recorded.kurentoObjects.webRtcPeer = kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(options, function(error) {
+            if (error) {
+              return onRecordedError(error);
+            }
+            console.log("About to generate an offer.");
+            return this.generateOffer(onRecordedOffer);
+          });
+        };
+      })(this);
+      this.view.recorded.stopViewing = (function(_this) {
+        return function(callback) {
+          if (callback == null) {
+            callback = null;
+          }
+          if (_this.view.recorded.kurentoObjects.fileUrl) {
+            _this.view.recorded.kurentoObjects.fileUrl = null;
+          }
+          if (_this.view.recorded.kurentoObjects.streamId) {
+            _this.view.recorded.kurentoObjects.streamId = null;
+          }
+          if (_this.view.recorded.kurentoObjects.callback) {
+            _this.view.recorded.kurentoObjects.callback = null;
+          }
+          if (_this.view.recorded.kurentoObjects.player) {
+            _this.view.recorded.kurentoObjects.player = null;
+          }
+          if (_this.view.recorded.kurentoObjects.videoElement) {
+            $(_this.view.recorded.kurentoObjects.videoElement).attr('src', '');
+            _this.view.recorded.kurentoObjects.videoElement = null;
+          }
+          if (_this.view.recorded.kurentoObjects.webRtcEndpoint) {
+            _this.view.recorded.kurentoObjects.webRtcEndpoint.release();
+            _this.view.recorded.kurentoObjects.webRtcEndpoint = null;
+          }
+          if (_this.view.recorded.kurentoObjects.pipeline) {
+            _this.view.recorded.kurentoObjects.pipeline.release();
+            _this.view.recorded.kurentoObjects.pipeline = null;
+          }
+          if (callback) {
+            return callback();
+          }
+        };
+      })(this);
+      this.view.recorded.onEndOfStream = (function(_this) {
+        return function(stream, endOfStreamHandler) {
+          var channel;
+          channel = _this.rails_websocket_dispatcher.subscribe("recorded-stream-" + stream.id);
+          return channel.bind('end-of-stream', function(streamId) {
+            return endOfStreamHandler(streamId);
+          });
+        };
+      })(this);
+      this.view.startViewing = (function(_this) {
+        return function(stream, videoElement, callback) {
+          var live, recorded;
+          if (callback == null) {
+            callback = null;
+          }
+          live = function() {
+            return _this.view.live.startViewing(stream, videoElement, callback);
+          };
+          recorded = function() {
+            return _this.view.recorded.startViewing(stream, videoElement, callback);
+          };
+          return _this.rails_websocket_dispatcher.trigger('streams.view', '', live, recorded);
+        };
+      })(this);
+      this.view.stopViewing = (function(_this) {
+        return function(callback) {
+          if (callback == null) {
+            callback = null;
+          }
+          _this.view.live.stopViewing(callback);
+          return _this.view.recorded.stopViewing(callback);
+        };
+      })(this);
+      this.view.onEndOfStream = (function(_this) {
+        return function(stream, endOfStreamHandler) {
+          var live, recorded;
+          live = function() {
+            return _this.view.live.onEndOfStream(stream, endOfStreamHandler);
+          };
+          recorded = function() {
+            return _this.view.recorded.onEndOfStream(stream, endOfStreamHandler);
+          };
+          return _this.rails_websocket_dispatcher.trigger('streams.view', '', live, recorded);
+        };
+      })(this);
+      this.view.currentlyViewing = (function(_this) {
+        return function(stream) {
+          if (stream == null) {
+            stream = null;
+          }
+          if (stream) {
+            if (_this.view.live.kurentoObjects.pipeline && _this.view.live.kurentoObjects.presenterWebRtcEndpoint) {
+              return _this.view.live.kurentoObjects.pipeline.id === stream.pipeline && _this.view.live.kurentoObjects.presenterWebRtcEndpoint.id === stream.sender_rtc;
+            } else if (_this.view.recorded.kurentoObjects.pipeline) {
+              return _this.view.recorded.kurentoObjects.pipeline.id === stream.pipeline;
+            } else {
+              return false;
+            }
+          }
+          return _this.view.live.kurentoObjects.pipeline || _this.view.recorded.kurentoObjects.pipeline;
+        };
+      })(this);
+
+      /* END VIEWING FUNCTIONS AND MEMBERS */
+
+      /* AND FINALLY, A UNIVERSAL PAGE UNLOAD HANDLER */
+      timeoutFunction = (function(_this) {
+        return function() {
+          return window.addEventListener('unload', function() {
+            _this.broadcast.stopBroadcasting();
+            _this.view.stopViewing();
+            if (_this.kurento) {
+              _this.kurento.close();
+            }
+            if (_this.rails_websocket_dispatcher) {
+              return _this.rails_websocket_dispatcher.disconnect();
+            }
+          });
+        };
+      })(this);
+      setTimeout(timeoutFunction, 2000);
+      return this;
+    }
+
+    return StreamingHelper;
+
+  })();
+
+  window.createStreamingHelper = (function(_this) {
+    return function(kurento_url, rails_url) {
+      return new StreamingHelper(kurento_url, rails_url);
+    };
+  })(this);
+
+}).call(this);