Modifies the semantics of JitsiTrack#attach method, so that it will return current stream container instance. Also it now takes HTML element instance directly instead of jQuery selector.

modules/RTC/JitsiLocalTrack.js

 
                     for(var i = 0; i < self.containers.length; i++)
                     {
-                        RTCUtils.attachMediaStream(
-                            self.containers[i], self.stream);
+                        self.containers[i]
+                            = RTCUtils.attachMediaStream(
+                                    self.containers[i], self.stream);
                     }
 
                     self.rtc.room.addStream(stream.stream,

modules/RTC/JitsiTrack.js

 }
 
 /**
- * Attaches the MediaStream of this track to an HTML container (?).
+ * Attaches the MediaStream of this track to an HTML container.
  * Adds the container to the list of containers that are displaying the track.
- * @param container the HTML container
+ * Note that Temasys plugin will replace original audio/video element with
+ * 'object' when stream is being attached to the container for the first time.
+ *
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ *
+ * @returns potentially new instance of container if it was replaced by the
+ *          library. That's the case when Temasys plugin is in use.
  */
 JitsiTrack.prototype.attach = function (container) {
     if(this.stream)
-        require("./RTCUtils").attachMediaStream(container, this.stream);
+        container = require("./RTCUtils").attachMediaStream(container, this.stream);
     this.containers.push(container);
+    return container;
 }
 
 /**
  * Removes the track from the passed HTML container.
  * @param container the HTML container. If <tt>null</tt> all containers are removed.
+ *        A container can be 'video', 'audio' or 'object' HTML element instance
+ *        to which this JitsiTrack is currently attached to.
  */
 JitsiTrack.prototype.detach = function (container) {
     for(var i = 0; i < this.containers.length; i++)
     {
-        if(this.containers[i].is(container))
+        if(!container)
         {
-            this.containers.splice(i,1);
+            require("./RTCUtils").setVideoSrc(this.containers[i], null);
         }
-        if(!container)
+        if(!container || $(this.containers[i]).is($(container)))
         {
-            this.containers[i].find(">video").remove();
+            this.containers.splice(i,1);
         }
     }
-    if(container)
-        $(container).find(">video").remove();
 
+    if(container) {
+        require("./RTCUtils").setVideoSrc(container, null);
+    }
 }
 
 /**

modules/RTC/RTC.js

 };
 
 RTC.attachMediaStream =  function (elSelector, stream) {
-    RTCUtils.attachMediaStream(elSelector, stream);
+    return RTCUtils.attachMediaStream(elSelector, stream);
 };
 
 RTC.getStreamID = function (stream) {

modules/RTC/RTCUtils.js

                     //
                     // https://groups.google.com/forum/#!topic/mozilla.dev.media/pKOiioXonJg
                     // https://github.com/webrtc/samples/issues/302
-                    if (!element[0])
+                    if (!element)
                         return;
-                    element[0].mozSrcObject = stream;
-                    element[0].play();
+                    element.mozSrcObject = stream;
+                    element.play();
+
+                    return element;
                 };
                 this.getStreamID = function (stream) {
                     var id = stream.id;
                             = webkitURL.createObjectURL(stream);
                     }
 
-                    element.attr('src', stream.jitsiObjectURL);
+                    element.src = stream.jitsiObjectURL;
+
+                    return element;
                 };
                 this.getStreamID = function (stream) {
                     // streams from FF endpoints have the characters '{' and '}'
                     self.peerconnection = RTCPeerConnection;
                     self.getUserMedia = window.getUserMedia;
                     self.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
-                    self.attachMediaStream = function (elSel, stream) {
+                    self.attachMediaStream = function (element, stream) {
 
                         if (stream.id === "dummyAudio" || stream.id === "dummyVideo") {
                             return;
                         }
 
                         var isVideoStream = !!stream.getVideoTracks().length;
-                        if (isVideoStream && !elSel.is(':visible')) {
+                        if (isVideoStream && !$(element).is(':visible')) {
                             throw new Error('video element must be visible to attach video stream');
                         }
 
-                        attachMediaStream(elSel[0], stream);
+                        return attachMediaStream(element, stream);
                     };
                     self.getStreamID = function (stream) {
                         var id = SDPUtil.filter_special_chars(stream.label);
                     self.setVideoSrc = function (element, src) {
                         //logger.info("Set video src: ", element, src);
                         if (!src) {
-                            logger.warn("Not attaching video stream, 'src' is null");
-                            return;
+                            attachMediaStream(element, null);
+                        } else {
+                            AdapterJS.WebRTCPlugin.WaitForPluginReady();
+                            var stream
+                                = AdapterJS.WebRTCPlugin.plugin
+                                    .getStreamWithId(
+                                        AdapterJS.WebRTCPlugin.pageId, src);
+                            attachMediaStream(element, stream);
                         }
-                        AdapterJS.WebRTCPlugin.WaitForPluginReady();
-                        var stream = AdapterJS.WebRTCPlugin.plugin
-                            .getStreamWithId(AdapterJS.WebRTCPlugin.pageId, src);
-                        attachMediaStream(element, stream);
                     };
 
                     onReady(options, self.getUserMediaWithConstraints);