Changes redirect on unsupported browser to console.error.

lib-jitsi-meet.js

  */
 
 function JitsiConference(options) {
+    if(!options.name || options.name.toLowerCase() === options.name) {
+        console.error("Invalid conference name (no conference name passed or it"
+            + "contains invalid characters like capital letters)!");
+         return;
+    }
     this.options = options;
     this.connection = this.options.connection;
     this.xmpp = this.connection.xmpp;
  * @param password {string} the password
  */
 JitsiConference.prototype.join = function (password) {
-    this.room.join(password);
+    if(this.room)
+        this.room.join(password);
 }
 
 /**
  * Leaves the conference.
  */
 JitsiConference.prototype.leave = function () {
-    this.xmpp.leaveRoom(this.room.roomjid);
+    if(this.xmpp)
+        this.xmpp.leaveRoom(this.room.roomjid);
     this.room = null;
 }
 
  *     or a JitsiConferenceError if rejected.
  */
 JitsiConference.prototype.createLocalTracks = function (options) {
-    return this.rtc.obtainAudioAndVideoPermissions(options || {});
+    if(this.rtc)
+        return this.rtc.obtainAudioAndVideoPermissions(options || {});
 }
 
 /**
  * Returns the local tracks.
  */
 JitsiConference.prototype.getLocalTracks = function () {
-    return this.rtc.localStreams;
+    if(this.rtc)
+        return this.rtc.localStreams;
 };
 
 
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.on = function (eventId, handler) {
-    this.eventEmitter.on(eventId, handler);
+    if(this.eventEmitter)
+        this.eventEmitter.on(eventId, handler);
 }
 
 /**
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.off = function (eventId, handler) {
-    this.eventEmitter.removeListener(eventId, listener);
+    if(this.eventEmitter)
+        this.eventEmitter.removeListener(eventId, listener);
 }
 
 // Common aliases for event emitter
  * @param handler {Function} handler for the command
  */
  JitsiConference.prototype.addCommandListener = function (command, handler) {
-     this.room.addPresenceListener(command, handler);
+    if(this.room)
+        this.room.addPresenceListener(command, handler);
  }
 
 /**
   * @param command {String}  the name of the command
   */
  JitsiConference.prototype.removeCommandListener = function (command) {
-    this.room.removePresenceListener(command);
+    if(this.room)
+        this.room.removePresenceListener(command);
  }
 
 /**
  * @param message the text message.
  */
 JitsiConference.prototype.sendTextMessage = function (message) {
-    this.room.sendMessage(message);
+    if(this.room)
+        this.room.sendMessage(message);
 }
 
 /**
  * @param values Object with keys and values that will be send.
  **/
 JitsiConference.prototype.sendCommand = function (name, values) {
-    this.room.addToPresence(name, values);
-    this.room.sendPresence();
+    if(this.room) {
+        this.room.addToPresence(name, values);
+        this.room.sendPresence();
+    }
 }
 
 /**
  * @param persistent if false the command will be sent only one time
  **/
 JitsiConference.prototype.removeCommand = function (name) {
-    this.room.removeFromPresence(name);
+    if(this.room)
+        this.room.removeFromPresence(name);
 }
 
 /**
  * @param name the display name to set
  */
 JitsiConference.prototype.setDisplayName = function(name) {
-    this.room.addToPresence("nick", {attributes: {xmlns: 'http://jabber.org/protocol/nick'}, value: name});
-    this.room.sendPresence();
+    if(this.room){
+        this.room.addToPresence("nick", {attributes: {xmlns: 'http://jabber.org/protocol/nick'}, value: name});
+        this.room.sendPresence();
+    }
 }
 
 /**
  * @param id the identifier of the participant
  */
 JitsiConference.prototype.selectParticipant = function(participantId) {
-    this.rtc.selectedEndpoint(participantId);
+    if (this.rtc) {
+        this.rtc.selectedEndpoint(participantId);
+    }
 }
 
 /**
  * @param id the identifier of the participant
  */
 JitsiConference.prototype.pinParticipant = function(participantId) {
-    this.rtc.pinEndpoint(participantId);
+    if(this.rtc)
+        this.rtc.pinEndpoint(participantId);
 }
 
 /**
  * @param id the id of the participant.
  */
 JitsiConference.prototype.getParticipantById = function(id) {
-    return this.participants[id];
+    if(this.participants)
+        return this.participants[id];
+    return null;
 }
 
 JitsiConference.prototype.onMemberJoined = function (jid, email, nick) {
-    this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, Strophe.getResourceFromJid(jid));
+    if(this.eventEmitter)
+        this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, Strophe.getResourceFromJid(jid));
 //    this.participants[jid] = new JitsiParticipant();
 }
 
             });
         } else {
             try {
-                console.log('Browser does not appear to be WebRTC-capable');
+                console.error('Browser does not appear to be WebRTC-capable');
             } catch (e) {
             }
-            window.location.href = 'unsupported_browser.html';
+            return;
         }
 
     },

modules/RTC/RTCUtils.js

             });
         } else {
             try {
-                console.log('Browser does not appear to be WebRTC-capable');
+                console.error('Browser does not appear to be WebRTC-capable');
             } catch (e) {
             }
-            window.location.href = 'unsupported_browser.html';
+            return;
         }
 
     },