Add MediaType

JitsiMeetJS.js

 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
 var Logger = require("jitsi-meet-logger");
+var MediaType = require("./service/RTC/MediaType");
 var RTC = require("./modules/RTC/RTC");
 var RTCUIHelper = require("./modules/RTC/RTCUIHelper");
 var Statistics = require("./modules/statistics/statistics");
                     for(var i = 0; i < tracks.length; i++) {
                         var track = tracks[i];
                         var mStream = track.getOriginalStream();
-                        if(track.getType() === "audio"){
+                        if(track.getType() === MediaType.AUDIO){
                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                             track.addEventListener(

modules/RTC/JitsiLocalTrack.js

         resolve();
         return;
     }
-    var isAudio = this.type === JitsiTrack.AUDIO;
+    var isAudio = this.isAudioTrack();
     this.dontFireRemoveEvent = false;
 
     var setStreamToNull = false;
     if (!this.stream)
         return true;
     var tracks = [];
-    var isAudio = this.type === JitsiTrack.AUDIO;
+    var isAudio = this.isAudioTrack();
     if (isAudio) {
         tracks = this.stream.getAudioTracks();
     } else {

modules/RTC/JitsiRemoteTrack.js

     this.videoType = data.videoType;
     this.ssrc = ssrc;
     this.muted = false;
-    if((this.type === JitsiTrack.AUDIO && data.audiomuted)
-      || (this.type === JitsiTrack.VIDEO && data.videomuted)) {
+    if((this.isAudioTrack() && data.audiomuted)
+      || (this.isVideoTrack() && data.videomuted)) {
         this.muted = true;
     }
 }

modules/RTC/JitsiTrack.js

 var RTCUtils = require("./RTCUtils");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
 var EventEmitter = require("events");
+var MediaType = require("../../service/RTC/MediaType");
 
 /**
  * This implements 'onended' callback normally fired by WebRTC after the stream
     this.eventEmitter = new EventEmitter();
     this.audioLevel = -1;
     this.type = jitsiTrackType || ((this.stream.getVideoTracks().length > 0)?
-        JitsiTrack.VIDEO : JitsiTrack.AUDIO);
-    if(this.type == JitsiTrack.AUDIO) {
+        MediaType.VIDEO : MediaType.AUDIO);
+    if(this.isAudioTrack()) {
         this._getTracks = function () {
             return this.stream? this.stream.getAudioTracks() : [];
         }.bind(this);
     }
 }
 
-/**
- * JitsiTrack video type.
- * @type {string}
- */
-JitsiTrack.VIDEO = "video";
-
-/**
- * JitsiTrack audio type.
- * @type {string}
- */
-JitsiTrack.AUDIO = "audio";
-
 /**
  * Returns the type (audio or video) of this track.
  */
  * Check if this is audiotrack.
  */
 JitsiTrack.prototype.isAudioTrack = function () {
-    return this.getType() === JitsiTrack.AUDIO;
+    return this.getType() === MediaType.AUDIO;
 };
 
 /**
  * Check if this is videotrack.
  */
 JitsiTrack.prototype.isVideoTrack = function () {
-    return this.getType() === JitsiTrack.VIDEO;
+    return this.getType() === MediaType.VIDEO;
 };
 
 /**
  * @returns {string}
  */
 JitsiTrack.prototype.getUsageLabel = function () {
-    if (this.type == JitsiTrack.AUDIO) {
+    if (this.isAudioTrack()) {
         return "mic";
     } else {
         return this.videoType ? this.videoType : "default";

modules/RTC/RTC.js

 var JitsiLocalTrack = require("./JitsiLocalTrack.js");
 var DataChannels = require("./DataChannels");
 var JitsiRemoteTrack = require("./JitsiRemoteTrack.js");
-var MediaStreamType = require("../../service/RTC/MediaStreamTypes");
+var MediaType = require("../../service/RTC/MediaType");
 var RTCEvents = require("../../service/RTC/RTCEvents.js");
 
 function createLocalTracks(streams, options) {
     var newStreams = []
     var deviceId = null;
     for (var i = 0; i < streams.length; i++) {
-        if (streams[i].type === 'audio') {
+        if (streams[i].type === MediaType.AUDIO) {
           deviceId = options.micDeviceId;
         } else if (streams[i].videoType === 'camera'){
           deviceId = options.cameraDeviceId;
             // If there is no video track, but we receive it is muted,
             // we need to create a dummy track which we will mute, so we can
             // notify interested about the muting
-            if(!self.remoteStreams[from][JitsiTrack.VIDEO]) {
+            if(!self.remoteStreams[from][MediaType.VIDEO]) {
                 var track = self.createRemoteStream(
                     {peerjid:room.roomjid + "/" + from,
                      videoType:"camera",
-                     jitsiTrackType:JitsiTrack.VIDEO},
+                     jitsiTrackType: MediaType.VIDEO},
                     null, null);
                 self.eventEmitter
                     .emit(RTCEvents.FAKE_VIDEO_TRACK_CREATED, track);
             }
 
-            self.remoteStreams[from][JitsiTrack.VIDEO]
+            self.remoteStreams[from][MediaType.VIDEO]
                 .setMute(values.value == "true");
         }
     });
     room.addPresenceListener("audiomuted", function (values, from) {
         if(self.remoteStreams[from]) {
-            self.remoteStreams[from][JitsiTrack.AUDIO]
+            self.remoteStreams[from][MediaType.AUDIO]
                 .setMute(values.value == "true");
         }
     });
     room.addPresenceListener("videoType", function(data, from) {
         if(!self.remoteStreams[from] ||
-            (!self.remoteStreams[from][JitsiTrack.VIDEO]))
+            (!self.remoteStreams[from][MediaType.VIDEO]))
             return;
-        self.remoteStreams[from][JitsiTrack.VIDEO]._setVideoType(data.value);
+        self.remoteStreams[from][MediaType.VIDEO]._setVideoType(data.value);
     });
 }
 
         {
             var ssrcInfo = null;
             if(this.localStreams[i].isMuted() &&
-                this.localStreams[i].getType() === "video") {
+                this.localStreams[i].getType() === MediaType.VIDEO) {
                 /**
                  * Handles issues when the stream is added before the peerconnection is created.
                  * The peerconnection is created when second participant enters the call. In
     var mutePromises = [];
     for(var i = 0; i < this.localStreams.length; i++) {
         var stream = this.localStreams[i];
-        if(stream.getType() !== "audio") {
+        if(stream.getType() !== MediaType.AUDIO) {
             continue;
         }
         // this is a Promise
     if(!this.remoteStreams[resource]) {
         this.remoteStreams[resource] = {};
     }
-    this.remoteStreams[resource][remoteStream.type]= remoteStream;
+    this.remoteStreams[resource][remoteStream.getType()]= remoteStream;
     return remoteStream;
 };
 
 RTC.prototype.setAudioLevel = function (resource, audioLevel) {
     if(!resource)
         return;
-    if(this.remoteStreams[resource] && this.remoteStreams[resource][JitsiTrack.AUDIO])
-        this.remoteStreams[resource][JitsiTrack.AUDIO].setAudioLevel(audioLevel);
+    if(this.remoteStreams[resource] &&
+        this.remoteStreams[resource][MediaType.AUDIO]) {
+        this.remoteStreams[resource][MediaType.AUDIO].setAudioLevel(audioLevel);
+    }
 };
 
 /**
 
     var resultResource = null;
     $.each(this.remoteStreams, function (resource, remoteTracks) {
-        if((remoteTracks[JitsiTrack.AUDIO]
-                && remoteTracks[JitsiTrack.AUDIO].getSSRC() == ssrc)
-            || (remoteTracks[JitsiTrack.VIDEO]
-                && remoteTracks[JitsiTrack.VIDEO].getSSRC() == ssrc))
+        if((remoteTracks[MediaType.AUDIO]
+                && remoteTracks[MediaType.AUDIO].getSSRC() == ssrc)
+            || (remoteTracks[MediaType.VIDEO]
+                && remoteTracks[MediaType.VIDEO].getSSRC() == ssrc))
             resultResource = resource;
     });
 

modules/RTC/RTCUtils.js

 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var MediaType = require("../../service/RTC/MediaType");
 
 var eventEmitter = new EventEmitter();
 
 
     if (desktopStream)
         res.push({stream: desktopStream,
-            type: "video", videoType: "desktop"});
+            type: MediaType.VIDEO, videoType: "desktop"});
 
     if(audioStream)
-        res.push({stream: audioStream, type: "audio", videoType: null});
+        res.push({stream: audioStream, type: MediaType.AUDIO, videoType: null});
 
     if(videoStream)
-        res.push({stream: videoStream, type: "video", videoType: "camera",
+        res.push({stream: videoStream, type: MediaType.VIDEO, videoType: "camera",
             resolution: resolution});
 
     return res;

service/RTC/MediaStreamTypes.js

-var MediaStreamType = {
-    VIDEO_TYPE: "Video",
-
-    AUDIO_TYPE: "Audio"
-};
-module.exports = MediaStreamType;

service/RTC/MediaType.js

+/**
+ * Enumeration of RTC media stream types
+ * @type {{AUDIO: string, VIDEO: string}}
+ */
+var MediaType = {
+    /**
+     * The audio type.
+     */
+    AUDIO: "audio",
+    /**
+     * The video type.
+     */
+    VIDEO: "video"
+};
+module.exports = MediaType;