social_stream-presence 0.7.5 → 0.8.0

data/lib/opentok.rb

@@ -0,0 +1,29 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+=begin
+ OpenTok Ruby Library
+ http://www.tokbox.com/
+
+ Copyright 2010, TokBox, Inc.
+
+ Last modified: 2011-02-17
+=end
+
+
+require 'rubygems'
+require 'net/http'
+require 'uri'
+require 'digest/md5'
+require 'cgi'
+#require 'pp' # just for debugging purposes
+
+Net::HTTP.version_1_2 # to make sure version 1.2 is used
+
+module OpenTok
+  VERSION = "tbrb-v0.91.2011-02-17"
+  API_URL = "https://api.opentok.com/hl";
+end
+
+require 'OpenTok/Exceptions'
+require 'OpenTok/OpenTokSDK'

data/lib/social_stream-presence.rb

@@ -33,12 +33,16 @@ module SocialStream
     
     mattr_accessor :social_stream_presence_username
     mattr_accessor :password
+    
+    mattr_accessor :opentok_api_key
+    mattr_accessor :opentok_api_secret
 
     @@auth_method = "cookie"
     @@remote_xmpp_server = false
     @@secure_rest_api = false
     @@enable = false
     @@social_stream_presence_username = "social_stream_presence"
+    @@opentok_api_key = "default"
     
     class << self
       def setup

data/lib/social_stream/presence/version.rb

@@ -1,5 +1,5 @@
 module SocialStream
   module Presence
-    VERSION = "0.7.5"
+    VERSION = "0.8.0"
   end
 end

data/vendor/assets/javascripts/TB.min.js

@@ -0,0 +1,4329 @@
+/*!
+ * OpenTok JavaScript Library v0.91.46
+ * http://www.tokbox.com/
+ *
+ * Copyright (c) 2011 TokBox, Inc.
+ *
+ * Date: February 16 18:15:10 2012
+ */
+
+function getHostname() {
+	return window.location.hostname;
+}
+
+// Instrumentation
+
+TB = function() {
+
+	//--------------------------------------
+	// EVENT CLASSES
+	//--------------------------------------
+
+	function EventDispatcher() {
+		this._listeners = {};
+
+		this.addEventListener = function(type, listener) {
+			if (!type) {
+				throw new Error("EventDispatcher.addEventListener :: No type specified");
+			}
+			if (!listener) {
+				throw new Error("EventDispatcher.addEventListener :: No listener function specified");
+			}
+
+
+			if (!this._listeners.hasOwnProperty(type)) {
+				this._listeners[type] = new Array();
+			}
+			this.removeEventListener(type, listener); // You cannot have the same listener for the same type multiple times
+			debug("TB.addEventListener(" + type + ")");
+			this._listeners[type].push(listener);
+		};
+
+		this.removeEventListener = function(type, listener) {
+			if (!type) {
+				throw new Error("EventDispatcher.removeEventListener :: No type specified");
+			}
+			if (!listener) {
+				throw new Error("EventDispatcher.removeEventListener :: No listener function specified");
+			}
+
+			debug("TB.removeEventListener(" + type + ")");
+			if (this._listeners.hasOwnProperty(type)) {
+				for (var i=0; i < this._listeners[type].length; i++) {
+					if (this._listeners[type][i] == listener) {
+						this._listeners[type].splice(i, 1);
+						break;
+					}
+				};
+			}
+		};
+
+		this.dispatchEvent = function(event) {
+			if (!event) {
+				throw new Error("EventDispatcher.dispatchEvent :: No event specified");
+			}
+			if (!event.type) {
+				throw new Error("EventDispatcher.dispatchEvent :: Event has no type");
+			}
+			if (!event.target) {
+				event.target = this;
+			}
+
+			if (this._listeners.hasOwnProperty(event.type)) {
+				var listeners = this._listeners[event.type];
+
+				if (listeners instanceof Array) {
+					for (var i=0; i < listeners.length; i++) {
+						var handler = createHandler(listeners[i], event);
+						// We run this asynchronously so that it doesn't interfere with execution if an error happens
+						// eg. multiple event handlers are added one has an error so the subsequent ones fail
+						setTimeout(handler, 1);
+					};
+				} else {
+					throw new Error("EventDispatcher.dispatchEvent :: Invalid object type in listeners");
+				}
+			}
+		};
+	}
+
+	function Event (type, cancelable) {
+		this.type = type;
+		this.cancelable = cancelable ? cancelable : false;
+		this.target;
+
+		var defaultPrevented = false;
+
+		this.preventDefault = function() {
+			if (this.cancelable) {
+				defaultPrevented = true;
+			} else {
+				warn("Event.preventDefault :: Trying to preventDefault on an Event that isn't cancelable");
+			}
+		};
+
+		this.isDefaultPrevented = function() {
+			return defaultPrevented;
+		};
+	}
+
+	function ExceptionEvent (type, message, title, code) {
+		this.superClass = Event;
+		this.superClass(type);
+
+		this.message = message;
+		this.title = title;
+		this.code = code;
+	}
+
+	function ConnectionEvent (type, connections, reason) {
+		this.superClass = Event;
+		this.superClass(type);
+
+		this.connections = connections;
+		this.reason = reason;
+	}
+
+	function StreamEvent (type, streams, reason, cancelable) {
+		this.superClass = Event;
+		this.superClass(type, cancelable);
+
+		this.streams = streams;
+		this.reason = reason;
+	}
+
+	function SessionConnectEvent (type, connections, streams, groups, archives) {
+		this.superClass = Event;
+		this.superClass(type);
+
+		this.connections = connections;
+		this.streams = streams;
+		this.groups = groups;
+		this.archives = archives;
+	}
+
+	function SessionDisconnectEvent (type, reason, cancelable) {
+		this.superClass = Event;
+		this.superClass(type, cancelable);
+
+		this.reason = reason;
+	}
+
+	function SignalEvent (type, fromConnection) {
+		this.superClass = Event;
+		this.superClass(type);
+
+		this.fromConnection = fromConnection;
+	}
+
+	function VolumeEvent(type, streamId, volume) {
+	               this.superClass = Event;
+	               this.superClass(type);
+	
+	               this.streamId = streamId;
+				   this.volume = volume;
+	}
+
+
+	function DeviceEvent (type, camera, microphone) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.camera = camera;
+			this.microphone = microphone;
+		}
+
+		function GroupEvent (type, group, reason) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.group = group;
+			this.reason = reason;
+		}
+
+		function DeviceStatusEvent (type, cameras, microphones, selectedCamera, selectedMicrophone) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.cameras = cameras;
+			this.microphones = microphones;
+			this.selectedCamera = selectedCamera;
+			this.selectedMicrophone = selectedMicrophone;
+		}
+
+		function ResizeEvent (type, widthFrom, widthTo, heightFrom, heightTo) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.widthFrom = widthFrom;
+			this.widthTo = widthTo;
+			this.heightFrom = heightFrom;
+			this.heightTo = heightTo;
+		}
+
+	    function StreamPropertyChangedEvent(type, stream, changedProperty, oldValue, newValue) {
+		this.superClass = Event;
+		this.superClass(type);
+
+		this.type = type;
+		this.stream = stream;
+		this.changedProperty = changedProperty;
+		this.oldValue = oldValue;
+		this.newValue = newValue;
+	    }
+
+		function ArchiveEvent (type, archives) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.archives = archives;
+		}
+
+		function ArchiveStreamEvent (type, archive, streams) {
+			this.superClass = Event;
+			this.superClass(type);
+
+			this.archive = archive;
+			this.streams = streams;
+		}
+		
+		function StateChangedEvent(type, changedValues) {
+			this.superClass = Event;
+			this.superClass(type);
+			this.changedValues = changedValues;
+		}
+		
+	    function ChangeFailedEvent(type, reasonCode, reason, failedValues) {
+		this.superClass = Event;
+		this.superClass(type);
+		
+		this.reasonCode = reasonCode;
+		this.reason = reason;
+		this.failedValues = failedValues;
+	    }
+
+		//--------------------------------------
+		// CLASSES
+		//--------------------------------------
+
+		function Connection (connectionId, creationTime, data) {
+			this.connectionId = connectionId;
+			this.creationTime = Number(creationTime);
+			this.data = data;
+
+			this.quality;
+		}
+
+
+	function Stream (streamId, connection, name, data, type, creationTime, hasAudio, hasVideo, orientation, sessionId, peerId, quality) {
+        //INSTANCE VARIABLES
+	    this.streamId = streamId;
+	    this.connection = connection;
+	    this.name = name;
+	    this.data = data;
+	    this.type = type;
+	    this.creationTime = creationTime;
+	    this.hasAudio = hasAudio;
+	    this.hasVideo = hasVideo;
+	    this.orientation = orientation;
+	    this.peerId = peerId;
+	    this.quality = quality;
+
+			this.startRecording = function(archive) {
+				debug("Stream.startRecording()");
+				var controllerId = "controller_" + sessionId;
+				archive = createdArchives[sessionId][archive.archiveId];
+				if (!archive) {
+						var errorMsg = "Stream.startRecording :: Archive not created.";
+						error(errorMsg);
+						throw new Error(errorMsg);
+				}
+				if (archive.type != TB.PER_STREAM) {
+					errorMsg = "Stream.startRecording :: Trying to record per stream on a " + archive.type + " archive";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.startRecordingStream(this.streamId, archive.archiveId);
+						archive.recording = true;
+					} catch(err) {
+						errorMsg = "Stream.startRecording :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Stream.startRecording :: Connection required to record an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.stopRecording = function(archive) {
+				debug("Stream.stopRecording()");
+				archive = createdArchives[sessionId][archive.archiveId];
+				if (!archive) {
+						var errorMsg = "Stream.stopRecording :: Archive not created.";
+						error(errorMsg);
+						throw new Error(errorMsg);
+				}
+				if (archive.type != TB.PER_STREAM) {
+					errorMsg = "Stream.stopRecording :: Trying to stop recording per stream on a " + archive.type + " archive";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				var controllerId = "controller_" + sessionId;
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.stopRecordingStream(this.streamId, archive.archiveId);
+					} catch(err) {
+						errorMsg = "Stream.stopRecording :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Stream.stopRecording :: Connection required to record an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+		}
+
+		function UIComponent (id, replacedDivId) {
+			this.id = id;
+			this.replacedDivId = replacedDivId;
+			this.parentClass = EventDispatcher;
+			this.parentClass();
+		}
+		
+		function StylableComponent(id, replacedDivId) {
+			this.uberClass = UIComponent;
+			this.uberClass(id, replacedDivId);
+			
+			var componentStyles = ["showMicButton", "showSpeakerButton", "showSettingsButton", "showCameraToggleButton", "nameDisplayMode", "buttonDisplayMode", "showSaveButton", "showRecordButton", "showRecordStopButton", "showReRecordButton", "showPauseButton", "showPlayButton", "showPlayStopButton", "showStopButton", "backgroundImageURI", "showControlPanel", "showRecordCounter", "showPlayCounter", "showControlBar"];
+			this.getStyle = function(key) {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					if (key) {
+						return this._style[key];
+					} else {
+						return this._style;
+					}
+				} else if (component) {
+					try {
+						var style = component.getStyle(key);
+						if (typeof(style) == "string")
+							return style;
+						for (var i in style) {
+							if (style[i] == "false")
+								style[i] = false;
+							if (style[i] == "true")
+								style[i] = true;
+							if (componentStyles.indexOf(i) < 0) {
+								// Strip unnecessary properties out
+								delete style[i];
+							}
+						};
+						return style;
+					} catch (err) {
+						var errorMsg = "Publisher.getStyle:: Failed to call getStyle. " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Publisher.getStyle:: Publisher " + this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+			
+			this._style = {};
+			var validStyleValues = {
+				buttonDisplayMode: ["auto", "off", "on"],
+				nameDisplayMode: ["auto", "off", "on"],
+				showSettingsButton: [true, false],
+				showMicButton: [true, false],
+				showCameraToggleButton: [true, false],
+				showSaveButton: [true, false],
+				backgroundImageURI: null,
+				showControlBar: [true, false],
+				showPlayCounter: [true, false],
+				showRecordCounter: [true, false]
+			};
+			this.setStyle = function(key, value) {
+				debug("Publisher.setStyle: " + key.toString());
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					if ((typeof(key) == "string") && value != null) {
+						if (this._style.hasOwnProperty(key) && (key == "backgroundImageURI" || (validStyleValues[key].indexOf(value) > -1)) ) {
+							debug("setStyle::Setting " + key + " to " + value);
+							this._style[key] = value;
+						} else {
+							warn("setStyle::Invalid style property passed " + key + " : " + value);
+						}
+					} else {
+						for (var i in key) {
+							this.setStyle(i, key[i]);
+						};
+					}
+					this.modified = true;
+				} else if (component) {
+					try {
+						component.setStyle(key, value);
+					} catch (err) {
+						var errorMsg = "Publisher.setStyle:: Failed to call setStyle. " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Publisher.setStyle:: Publisher " + this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				
+				return this;
+			};
+		}
+		
+		function VideoComponent(id, replacedDivId) {
+			this.supClass = StylableComponent;
+			this.supClass(id, replacedDivId);
+			
+			this.getImgData = function() {
+				debug("VideoComponent.getImgData");
+
+				var component = document.getElementById(this.id);
+				if (component) {
+					try {
+						return component.getImgData();
+					} catch(err) {
+						var errorMsg = "VideoComponent.getImgData:: Failed to call getImgData. " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "VideoComponent.getImgData:: Component " + this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+		}
+		
+
+		function Publisher (id, replacedDivId, properties) {
+			this.superClass = VideoComponent;
+			this.superClass(id, replacedDivId);
+			this._style = {
+				showMicButton: true,
+				showSettingsButton: true,
+				showCameraToggleButton: true,
+				nameDisplayMode: "auto",
+				buttonDisplayMode: "auto",
+				backgroundImageURI: null
+			};
+			
+			this.modified = false;
+
+			if (properties && properties.hasOwnProperty("style")) {
+				this.setStyle(properties['style']);
+				this.modified = true;
+			}
+
+			this.properties = properties;
+			this.loaded = false;
+			this.panelId = null;
+			this.gain = 50;
+
+		if(properties && properties.hasOwnProperty("microphoneGain")) {
+		    this.gain = parseInt(properties["microphoneGain"], 10);
+		}
+			
+			this.enableMicrophone = function() {
+				this.publishAudio(true);
+			};
+			this.disableMicrophone = function() {
+				this.publishAudio(false);
+			};
+			this.setMicrophoneGain = function(value) {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					this.gain = value;
+					this.modified = true;
+				} else if (component) {
+					try {
+						component.setMicGain(value);
+					} catch (err) {
+						var errorMsg = "Microphone gain adjustment on publisher "+this.id+" failed";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Publisher "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				return this;
+			};
+			this.getMicrophoneGain = function() {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					return this.gain;
+				} else if (component) {
+					try {
+						return component.getMicGain();
+					} catch (err) {
+						var errorMsg = "Microphone gain adjustment on publisher "+this.id+" failed";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Publisher "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+			this.getEchoCancellationMode = function() {
+				debug("Publisher.getEchoCancellationMode()");
+
+				var mode = "";
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					return "unknown";
+				} else if (component) {
+					try {
+						mode = component.getEchoCancellationMode();
+					} catch (err) {
+						var errorMsg = "Getting echo cancellation mode for publisher " + this.id + " failed. " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Publisher "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				return mode;
+			};
+			this.publishAudio = function(publishAudioBool) {
+				debug("Publisher.publishAudio()");
+				if (!this.loaded) {
+					this.audioPublished = publishAudioBool;
+					this.modified = true;
+				} else {
+					setStreamProperty(this.id, "publishAudio", publishAudioBool);
+				}
+			};
+			this.publishVideo = function(publishVideoBool) {
+				debug("Publisher.publishVideo()");
+				if (!this.loaded) {
+					this.videoPublished = publishVideoBool;
+					this.modified = true;
+				} else {
+					setStreamProperty(this.id, "publishVideo", publishVideoBool);
+				}
+			};
+			this.setCamera = function(camera) {
+				// Private function
+				debug("Publisher.setCamera(" + camera + ")");
+				setDevice(this.id, camera, true);
+			};
+			this.setMicrophone = function(microphone) {
+				// Private function
+				debug("Publisher.setMicrophone(" + microphone + ")");
+				setDevice(this.id, microphone, false);
+			};
+		
+		} 
+
+
+		function Subscriber (stream, id, replacedDivId, properties) {
+			this.superClass = VideoComponent;
+			this.superClass(id, replacedDivId);
+			this._style = {
+				nameDisplayMode: "auto",
+				buttonDisplayMode: "auto",
+				backgroundImageURI: null
+			};
+			
+			this.modified = false;
+
+			if (properties && properties.hasOwnProperty("style")) {
+				this.setStyle(properties['style']);
+				this.modified = true;
+			}
+
+			this.stream = stream;
+			this.properties = properties;
+			this.loaded = false;
+			this.audioVolume = 50;
+
+		var _isAudioSubscribed = true;
+		var _isVideoSubscribed = true;
+
+		if(properties) {
+		    if(properties.hasOwnProperty("subscribeToAudio") && (properties["subscribeToAudio"] == "false" || properties["subscribeToAudio"] == false)) {
+			_isAudioSubscribed = false;
+		    }
+
+		    if(properties.hasOwnProperty("subscribeToVideo") && (properties["subscribeToVideo"] == "false" || properties["subscribeToVideo"] == false)) {
+			_isVideoSubscribed = false;
+		    }
+
+		    if(properties.hasOwnProperty("audioVolume")) {
+			this.audioVolume = parseInt(properties["audioVolume"], 10);
+		    }
+		}
+
+			this.enableAudio = function() {
+				this.subscribeToAudio(true);
+			};
+			this.disableAudio = function() {
+				this.subscribeToAudio(false);
+			};
+			this.setAudioVolume = function(value) {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					this.audioVolume = value;
+				} else if (component) {
+					try {
+						component.setAudioVolume(value);
+					} catch (err) {
+						var errorMsg = "Volume adjustment on subscriber "+this.id+" failed";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Subscriber "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				return this;
+			};
+			this.getAudioVolume = function() {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					return this.audioVolume;
+				}
+				if (component) {
+					try {
+						return component.getAudioVolume();
+					} catch (err) {
+						var errorMsg = "Volume adjustment on subscriber "+this.id+" failed";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Subscriber "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				return this;
+			};
+
+	/**
+		 * Internal function to toggle the subscribeToAudio that respects
+		 * the developer's state of subscribing
+		 */
+		this._subscribeToAudio = function(subscribeAudioBool, isTokBox) {
+		    debug("Subscriber.subscribeToAudio()");
+		    if(!isTokBox || _isAudioSubscribed) {
+			if(!this.loaded) {
+			    this.audioSubscribed = subscribeAudioBool;
+			    this.modified = true;
+			} else {
+			    setStreamProperty(this.id, "subscribeToAudio", subscribeAudioBool);
+			}
+		    }
+		};
+		this.subscribeToAudio = function(subscribeAudioBool) {
+		    _isAudioSubscribed = subscribeAudioBool;
+		    this._subscribeToAudio(_isAudioSubscribed, false);
+		};
+
+		/**
+		 * Internal function to toggle the subscribeToVideo that respects
+		 * the developer's state of subscribing
+		 */
+		this._subscribeToVideo = function(subscribeVideoBool, isTokBox) {
+		    debug("Subscriber.subscribeToVideo()");
+		    if(!isTokBox || _isVideoSubscribed) {
+			if(!this.loaded) {
+			    this.videoSubscribed = subscribeVideoBool;
+			    this.modified = true;
+			} else {
+			    setStreamProperty(this.id, "subscribeToVideo", subscribeVideoBool);
+			}
+		    }
+		};
+		this.subscribeToVideo = function(subscribeVideoBool) {
+		    _isVideoSubscribed = subscribeVideoBool;
+		    this._subscribeToVideo(_isVideoSubscribed, false);
+		};
+
+			this.changeOrientation = function(orientation) {
+				// private function
+				debug("Subscriber.changeOrientation()");
+				setStreamProperty(this.id, "changeOrientation", orientation);
+			};
+		}
+
+		function DevicePanel (id, replacedDivId, component, properties) {
+			this.superClass = UIComponent;
+			this.superClass(id, replacedDivId);
+
+			if (component) {
+				this.publisher = component;	//publisher is deprecated
+				this.component = component;
+			} else {
+				this.publisher = null;
+				this.component = component;
+			}
+			this.parentCreated = false;
+			this.properties = properties;
+		}
+
+		function Camera (name, status) {
+			this.name = name;
+			this.status = status;
+		}
+
+		function Microphone (name, status) {
+			this.name = name;
+			this.status = status;
+		}
+
+		function Group (sessionId,groupId) {
+			this.superClass = EventDispatcher;
+			this.superClass();
+
+			this.groupId = groupId;
+			this.sessionId = sessionId;
+			this.enableEchoSuppression = function() {
+				debug("Group.enableEchoSuppresion()");
+				setEchoSuppressionEnabled(this.sessionId, this.groupId, true);
+			};
+			this.disableEchoSuppression = function() {
+				debug("Group.disableEchoSuppression()");
+				setEchoSuppressionEnabled(this.sessionId, this.groupId, false);
+			};
+
+			this.getGroupProperties = function() {
+				debug("Group.getGroupProperties()");
+				return getGroupProperties(this.sessionId, this.groupId);
+			};
+
+		}
+
+		function EchoSuppression(isEnabled){
+		    this.isEnabled = isEnabled;
+		}
+
+		function Multiplexer(outputStreams,switchType,switchTimeout)
+		{
+		    this.numOutputStreams = outputStreams;
+		    this.switchType = switchType;
+		    this.switchTimeout = switchTimeout;
+		}
+
+		function GroupProperties(group) {
+			this.echoSuppression = new EchoSuppression(group.echoSuppressionEnabled);
+			this.multiplexer = new Multiplexer(group.multiplexerNumOutputStreams,group.multiplexerSwitchType,group.multiplexerSwitchTimeout);
+		}
+
+		function Archive (archiveId, type, title, sessionId, status) {
+			this.archiveId = archiveId;
+			this.type = type;
+			this.title = title;
+			this.sessionId = sessionId;
+			var stateManager; 
+			if (status == "sessionRecordingInProgress") {
+				this.recording = true;
+				this.status = "open";
+			}
+			else {
+				this.recording = false;
+				this.status = status;
+			}
+
+			this.startPlayback = function(loop) {
+		        if (!loop) {
+		            loop = false;
+		        }
+				debug("Archive.startPlayback() : " + loop);
+				var controllerId = "controller_" + sessionId;
+				var connection = TB.sessions[sessionId].connection;
+				if (!loadedArchives[sessionId][this.archiveId]) {
+						var errorMsg = "Archive.startPlayback :: Archive not loaded.";
+						error(errorMsg);
+						throw new Error(errorMsg);
+				}
+				if (controllerId && connection && connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.startPlayback(this.archiveId, loop);
+					} catch(err) {
+						errorMsg = "Archive.startPlayback :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Archive.startPlayback :: Connection required to play back an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.stopPlayback = function() {
+				debug("Archive.stopPlayback()");
+				var controllerId = "controller_" + sessionId;
+				var connection = TB.sessions[sessionId].connection;
+				if (controllerId && connection && connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.stopPlayback(this.archiveId);
+					} catch(err) {
+						var errorMsg = "Archive.stopPlayback :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Archive.stopPlayback :: Connection required to stop playing back an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.getStateManager = function() {
+				debug("Archive.getStateManager() " + archiveId);
+				
+				if (stateManager) return stateManager;
+
+				else {
+					var controllerId = "controller_" + sessionId;
+					var connection = TB.sessions[sessionId].connection;
+					if (controllerId && connection && connection.connectionId) {
+					stateManager = new StateManager(controllerId, archiveId);
+						return stateManager;
+					}
+				}
+				
+				var errorMsg = "Archive.getStateManager :: Connection required to getStateManager. "
+								+ "Make sure that this archive was loaded in a Session.";
+				error(errorMsg);
+				throw new Error(errorMsg);
+			};
+		}
+		
+		function Recorder(id, replacedDivId, properties) {
+			this.superClass = VideoComponent;
+			this.superClass(id, replacedDivId);
+			
+			this._style = {
+				buttonDisplayMode: "auto",
+                showCameraToggleButton: true,
+                showControlBar: true,
+                showMicButton: true,
+                showPlayCounter: true,
+                showRecordCounter: true,
+                showSaveButton: true,
+                showSettingsButton: true
+			};
+			
+			this.id = id;
+			this.properties = properties;
+			
+			this.saveArchive = function() {
+				var recorderElement = document.getElementById(this.id);
+				recorderElement.save();
+			};
+			
+			this.setCamera = function(camera) {
+				debug("Recorder.setCamera(" + camera + ")");
+				setDevice(this.id, camera, true);
+			};
+			this.setMicrophone = function(microphone) {
+				debug("Recorder.setMicrophone(" + microphone + ")");
+				setDevice(this.id, microphone, false);
+			};
+
+			this.stopRecording = function() {
+				recorderElement = document.getElementById(this.id);
+				recorderElement.stopRecording();
+			};
+
+			this.startRecording = function(title) {
+				recorderElement = document.getElementById(this.id);
+				recorderElement.startRecording(title);
+			};
+
+			this.startPlaying = function() {
+				debug("Recorder.startPlaying()");
+				try {
+					var recorderElement = document.getElementById(this.id);
+					recorderElement.startPlaying();
+				} catch(err) {
+					var errorMsg = "Recorder.startPlaying :: " + err;
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.stopPlaying = function() {
+				debug("Recorder.stopPlaying()");
+				try {
+					var recorderElement = document.getElementById(this.id);
+					recorderElement.stopPlaying();
+				} catch(err) {
+					var errorMsg = "Recorder.stopPlaying :: " + err;
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.setTitle = function (title) {
+				var component = document.getElementById(this.id);
+				if (!this.loaded) {
+					this._title = title;
+					this.modified = true;
+				} else if (component) {
+					try {
+						component.setTitle(title);
+					} catch (err) {
+						var errorMsg = "Setting archive title on Recorder "+this.id+" failed.";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Recorder "+ this.id + " does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+		}
+		
+
+		function Player(id, replacedDivId, properties) {
+			this.superClass = VideoComponent;
+			this.superClass(id, replacedDivId);
+			
+			this._style = {
+				showPlayButton: true,
+				showStopButton: true,
+				showSpeakerButton: true
+			};
+
+			this.id = id;
+			this.properties = properties;
+			this.archiveId;
+
+			this.loadArchive = function(archiveId) {
+				if (archiveId) {
+					if (this.loaded) {
+						try {
+							var player = document.getElementById(this.id);
+							player.loadArchive(archiveId);
+							this.archiveId = archiveId;
+						} catch(err) {
+							var errorMsg = "Player.loadArchive :: " + err;
+							error(errorMsg);
+							throw new Error(errorMsg);
+						}
+					} else {
+						this._archiveId = archiveId;
+					}
+				} else {
+					errorMsg = "Player.loadArchive :: Archive id required to load an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+			};
+
+			this.play = function() {
+				if (this.loaded) {
+					try {
+						var player = document.getElementById(this.id);
+						player.startPlayback();
+					} catch(err) {
+						var errorMsg = "Player.play :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					this._play = true;
+				}
+			};
+
+			this.stop = function() {
+				if (this.loaded) {
+					try {
+						var player = document.getElementById(this.id);
+						player.stopPlayback();
+					} catch(err) {
+						var errorMsg = "Player.stop :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					this._play = false;
+				}
+			};
+
+			this.pause = function() {
+				if (this.loaded) {
+					try {
+						var player = document.getElementById(this.id);
+						player.pausePlayback();
+					} catch(err) {
+						var errorMsg = "Player.pause :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					this._play = false;
+				}
+			};
+
+		}
+
+		function DeviceManager (apiKey) {
+			this.superClass = EventDispatcher;
+			this.superClass();
+
+			this.apiKey = apiKey;
+
+			this.panels = {};
+
+			this.showMicSettings = true;
+		this.showCamSettings = true;
+
+			var DEVICE_PANEL_WIDTH = 360;
+			var DEVICE_PANEL_HEIGHT = 270;
+			var DEVICE_PANEL_WIDTH_NO_CHROME = 340;
+			var DEVICE_PANEL_HEIGHT_NO_CHROME = 230;
+
+			this.detectDevices = function() {
+				debug("DeviceManager.detectDevices()");
+				if (!deviceDetectorId) {
+					var params = {};
+					params.allowscriptaccess = "always";
+
+					deviceDetectorId = "opentok_deviceDetector";
+					var attributes = {};
+					attributes.id = deviceDetectorId;
+
+					var properties = {};
+
+					swfobject.addDomLoadEvent(function() {
+						var div = document.createElement('div');
+						div.setAttribute('id', deviceDetectorId);
+						div.style.display = "none";
+						document.body.appendChild(div);
+
+						swfobject.embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_devicedetectorwidget.swf?partnerId="+apiKey, deviceDetectorId, 1, 1, "10.0.0", false, properties, params, attributes);
+					});
+				} else {
+					try {
+						var deviceDetector = document.getElementById(deviceDetectorId);
+						deviceDetector.detectDevices();
+					} catch(err) {
+						error(err);
+						throw new Error("DeviceManager.detectDevices() :: Failed to locate existing device detector " + err);
+					}
+				}
+			};
+
+			this.displayPanel = function(replaceElementId, component, properties) {
+				debug("DeviceManager.displayPanel(" + replaceElementId + ")");
+
+				var panelId;
+				if (component) panelId = "displayPanel_" + component.id;
+				else panelId = "displayPanel_global";
+
+				// If this is a publisher update the panelId in the publisher object
+				if (component && TB.sessions) {
+					for (var i in TB.sessions) {
+						if (TB.sessions[i].hasOwnProperty("publishers") && TB.sessions[i].publishers[component.id]) {
+							TB.sessions[i].publishers[component.id].panelId = panelId;
+						}
+					}
+				}
+
+				var existingElement = document.getElementById(panelId);
+
+				if (existingElement) {
+					warn("DeviceManager.displayPanel :: there is already a device panel" + (component ? " for this component" : ""));
+					return this.panels[panelId];
+				}
+
+				var parentCreated = false;
+				var propertiesCopy = (properties) ? copyObject(properties) : {};
+				var params = {};
+				params.allowscriptaccess = "always";
+
+				var width = DEVICE_PANEL_WIDTH;
+				var height = DEVICE_PANEL_HEIGHT;
+				if ("showCloseButton" in propertiesCopy) {
+					if (propertiesCopy["showCloseButton"] == false) {
+						width = DEVICE_PANEL_WIDTH_NO_CHROME;
+						height = DEVICE_PANEL_HEIGHT_NO_CHROME;
+					}
+				} else {
+					propertiesCopy["showCloseButton"] = true;
+				}
+
+		    if(!("showMicSettings" in propertiesCopy)) {
+			propertiesCopy["showMicSettings"] = this.showMicSettings;
+		    }
+
+		    if(!("showCamSettings" in propertiesCopy)) {
+			propertiesCopy["showCamSettings"] = this.showCamSettings;
+		    }
+
+				if(!replaceElementId) {
+					// If they didn't specify a replaceElementId then we will create a new element
+					replaceElementId = 'devicePanel_replace_div';
+					var replaceDiv = document.createElement('div');
+					replaceDiv.setAttribute('id', replaceElementId);
+
+					var parentDiv = document.createElement('div');
+					parentDiv.setAttribute('id', 'devicePanel_parent_' + (component ? component.id : 'global'));
+					parentDiv.style.position = "absolute";
+
+					var yOffset =  ("pageYOffset" in window && typeof( window.pageYOffset ) == 'number') ? window["pageYOffset"] : 
+									(document.body && document.body.scrollTop) ? document.body.scrollTop :
+									(document.documentElement && document.documentElement.scrollTop) ? document.documentElement.scrollTop :
+									0;
+					var winHeight = ("innerHeight" in window) ? window.innerHeight : 
+									(document.documentElement && document.documentElement.offsetHeight) ? document.documentElement.offsetHeight :
+									DEVICE_PANEL_HEIGHT;
+					yOffset += (winHeight * 0.20); // 20% down the current screen
+
+					parentDiv.style.top = yOffset + "px";
+					parentDiv.style.left = "50%";
+					parentDiv.style.width = width + "px";
+					parentDiv.style.height = height + "px";
+					parentDiv.style.marginLeft = (0 - width/2) + "px";
+					parentDiv.style.marginTop = (0 - height/4) + "px";
+					if ("zIndex" in propertiesCopy) {
+						parentDiv.style.zIndex = propertiesCopy["zIndex"];
+						delete propertiesCopy["zIndex"];
+					} else {
+						parentDiv.style.zIndex = highZ()+1;
+					}
+					document.body.appendChild(parentDiv);
+					parentCreated = true;
+					parentDiv.appendChild(replaceDiv);
+		    }
+
+				var replaceElement = document.getElementById(replaceElementId);
+				if(!replaceElement) {
+					var errorMsg = "DeviceManager.displayPanel :: replaceElementId does not exist in DOM.";
+			error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				var devicePanel;
+				if (this.panels[panelId]) this.removePanel(this.panels[panelId]);
+				if (component) devicePanel = new DevicePanel(panelId, replaceElementId, component, propertiesCopy);
+				else devicePanel = new DevicePanel(panelId, replaceElementId, null, propertiesCopy);
+
+				devicePanel.parentCreated = parentCreated;
+				this.panels[panelId] = devicePanel;
+
+				var attributes = {};
+				attributes.id = devicePanel.id;
+				attributes.style = "outline:none;";
+
+				propertiesCopy["devicePanelId"] = panelId;
+
+				if (propertiesCopy.wmode) {
+					params.wmode = propertiesCopy.wmode;
+					delete propertiesCopy["wmode"];
+				} else {
+					params.wmode = "transparent";
+				}
+
+				embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_devicewidget.swf?partnerId="+this.apiKey, replaceElementId, width, height, MIN_FLASH_VERSION, false, propertiesCopy, params, attributes);
+
+				return devicePanel;
+			};
+
+			this.removePanel = function(devicePanel) {
+				if (!devicePanel.hasOwnProperty("id")) {
+					var errorMsg = "DeviceManager.removePanel :: invalid DevicePanel object";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				debug("DeviceManager.removePanel(" + devicePanel.id + ")");
+
+				var devicePanelElement = document.getElementById(devicePanel.id);
+				if (!devicePanelElement) {
+					errorMsg = "DeviceManager.removePanel :: DevicePanel does not exist in DOM";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				var parentElement = devicePanelElement.parentNode;
+				var parentCreated = devicePanel.parentCreated;
+
+				for (var dp in this.panels) {
+					if (this.panels[dp].hasOwnProperty("id") && dp == devicePanel.id) {
+						var panel = this.panels[dp];
+						unloadComponent(this.panels[dp]);
+						delete this.panels[dp];
+
+						var action = function() {
+							if (panel.publisher && TB.sessions) {
+								for (var i in TB.sessions) {
+									if (TB.sessions[i].hasOwnProperty("disconnect") && TB.sessions[i].publishers[panel.publisher.id]) {
+										TB.sessions[i].publishers[panel.publisher.id].panelId = null;
+									}
+								}
+							}
+						};
+
+						// The event handler is called asynchronously after 2 milliseconds.
+						setTimeout(action, 2);
+					}
+				}
+
+				if (parentCreated) {
+					// Remove the parent because we created it
+					try {
+						var parentNode = parentElement.parentNode;
+						parentNode.removeChild(parentElement);
+					} catch (err) {
+						errorMsg = "Failed to clean up the parent of the device panel " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				}
+			};
+
+		}
+		
+		function RecorderManager (apiKey) {
+			
+			var recorderCount = 1;
+			var playerCount = 1;
+
+			this.recorders = {};
+			this.players = {};
+			this.apiKey = apiKey;
+			
+			var DEFAULT_WIDTH = 320;
+			var DEFAULT_HEIGHT = 271;
+			var CONTROL_BAR_HEIGHT = 31;
+			
+			this.displayRecorder = function(token, replaceElementId, properties) {
+				
+				if (!token) {
+					errorMsg = "RecorderManager.displayRecorder :: Token required to displayRecorder";
+				    error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				
+				var recorderId = "recorder_" + apiKey + "_" + recorderCount++;
+				
+				var propertiesCopy = (properties) ? copyObject(properties) : {};
+				propertiesCopy["token"] = token;
+				propertiesCopy["partnerId"] = apiKey;
+				propertiesCopy["recorderId"] = recorderId;
+				
+				if (propertiesCopy.hasOwnProperty("style")) {
+					var showControlBar = propertiesCopy.style.showControlBar;
+					propertiesCopy.style = encodeURIComponent(JSONify(propertiesCopy.style));
+				}
+				
+				var params = {};
+				params.allowscriptaccess = "always";
+				if (propertiesCopy.wmode){
+					params.wmode = propertiesCopy.wmode;
+					delete propertiesCopy["wmode"];
+				} else {
+					params.wmode = "transparent";
+				}
+				
+				var attributes = {};
+				attributes.id = recorderId;
+				attributes.style = "outline:none;";
+				
+				if (!propertiesCopy.width || isNaN(propertiesCopy.width)) {
+					propertiesCopy.width = DEFAULT_WIDTH;
+				}
+				if (!propertiesCopy.height || isNaN(propertiesCopy.height)) {
+					propertiesCopy.height = DEFAULT_HEIGHT;
+					if (showControlBar == false) {
+						propertiesCopy.height -= CONTROL_BAR_HEIGHT;
+					}
+				}
+					
+				var createReplaceElement = false;
+				if (!replaceElementId) {
+					// Create a new element for the publisher and append it to the body
+					replaceElementId = "recorder_replace_" + recorderCount;
+					createReplaceElement = true;
+				}
+				
+				swfobject.addDomLoadEvent(function() {
+					if (createReplaceElement) {
+						var div = document.createElement('div');
+						div.setAttribute('id', replaceElementId);
+						document.body.appendChild(div);
+					}
+					
+					embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_recordwidget.swf?partnerId="+apiKey, replaceElementId, propertiesCopy.width, propertiesCopy.height, MIN_FLASH_VERSION, false, propertiesCopy, params, attributes);
+				});
+				
+				this.recorders[recorderId] = new Recorder(recorderId, replaceElementId, propertiesCopy);
+				
+				return this.recorders[recorderId];
+			};
+
+			this.removeRecorder = function(recorder) {
+				if (!recorder) {
+					var errorMsg = "Session.removeRecorder :: recorder cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				debug("Session.removeRecorder(" + recorder.id + ")");
+
+				unloadComponent(recorder);
+				delete this.recorders[recorder.id];
+			};
+
+			this.displayPlayer = function(archiveId, token, replaceElementId, properties) {
+				
+				if (!archiveId) {
+					errorMsg = "RecorderManager.displayPlayer :: Valid ArchiveId required";
+				    error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				
+				var playerId = "player_" + apiKey + "_" + playerCount++;
+				
+				var propertiesCopy = (properties) ? copyObject(properties) : {};
+				propertiesCopy["token"] = token;
+				propertiesCopy["archiveId"] = archiveId;
+				propertiesCopy["partnerId"] = apiKey;
+				propertiesCopy["playerId"] = playerId;
+
+				if (propertiesCopy.hasOwnProperty("style")) {
+					var showControlBar = propertiesCopy.style.showControlBar;
+					propertiesCopy.style = encodeURIComponent(JSONify(propertiesCopy.style));
+				}
+
+				var params = {};
+				params.allowscriptaccess = "always";
+				if (propertiesCopy.wmode){
+					params.wmode = propertiesCopy.wmode;
+					delete propertiesCopy["wmode"];
+				} else {
+					params.wmode = "transparent";
+				}
+				
+				var attributes = {};
+				attributes.id = playerId;
+				attributes.style = "outline:none;";
+				
+				if (!propertiesCopy.width || isNaN(propertiesCopy.width)) {
+					propertiesCopy.width = DEFAULT_WIDTH;
+				}
+				if (!propertiesCopy.height || isNaN(propertiesCopy.height)) {
+					propertiesCopy.height = DEFAULT_HEIGHT;
+					if (showControlBar == false) {
+						propertiesCopy.height -= CONTROL_BAR_HEIGHT;
+					}
+				}
+				if (!propertiesCopy.autoPlay) {
+					propertiesCopy.autoPlay = false;
+				}
+				var createReplaceElement = false;
+				if (!replaceElementId) {
+					// Create a new element for the player and append it to the body
+					replaceElementId = "player_replace_" + playerCount;
+					createReplaceElement = true;
+				}
+				
+				swfobject.addDomLoadEvent(function() {
+					if (createReplaceElement) {
+						var div = document.createElement('div');
+						div.setAttribute('id', replaceElementId);
+						document.body.appendChild(div);
+					}
+					
+					embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_playerwidget.swf?partnerId="+apiKey, replaceElementId, propertiesCopy.width, propertiesCopy.height, MIN_FLASH_VERSION, false, propertiesCopy, params, attributes);
+				});
+				
+				this.players[playerId] = new Player(playerId, replaceElementId, propertiesCopy);
+				
+				return this.players[playerId];
+			};
+			
+			this.removePlayer = function(player) {
+				if (!player) {
+					var errorMsg = "Session.removePlayer :: player cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+		}
+				debug("Session.removePlayer(" + player.id + ")");
+
+				unloadComponent(player);
+				delete this.players[player.id];
+			};
+			
+		}
+
+		function Session (sessionId) {
+			this.superClass = EventDispatcher;
+			this.superClass();
+
+			this.sessionId = sessionId;
+			this.connection;
+			this.subscribers = {};
+			this.publishers = {};
+			this.apiKey;
+			this.capabilities;
+			this.connected = false;
+			this.connecting = false;
+
+			var publisherCount = 1;
+			var subscriberCount = 1;
+			var DEFAULT_WIDTH = 264;
+			var DEFAULT_HEIGHT = 198;
+			var controllerId;
+			var stateManager;
+
+			this.connect = function(apiKey, token, properties) {
+				if (this.connecting) {
+					warn("Session.connect :: Patience, please.");
+					return;
+				}
+
+				debug("Session.connect(" + apiKey + ")");
+				
+				if (!TB.checkSystemRequirements()) {
+					var errorMsg = "Session.connect :: Flash Player Version 10+ required";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (!apiKey) {
+					errorMsg = "Session.connect :: API key required to connect";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (!token) {
+					errorMsg = "Session.connect :: Token required to connect";
+				    error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (this.connected) {
+					warn("Session.connect :: Session already connected");
+					return;
+				}
+
+				this.connecting = true;
+
+				var propertiesCopy = (properties) ? copyObject(properties) : {};
+
+				this.apiKey = apiKey;
+				this.token = token;
+				this.properties = properties;
+				var params = {};
+				params.allowscriptaccess = "always";
+				if (propertiesCopy.wmode) {
+				    params.wmode = propertiesCopy.wmode;
+				    delete propertiesCopy["wmode"];
+				}
+
+				if (propertiesCopy.connectionData) {
+					propertiesCopy.connectionData = encodeURIComponent(propertiesCopy.connectionData);
+				}
+
+				controllerId = "controller_" + this.sessionId;
+				var attributes = {};
+				attributes.id = controllerId;
+
+				propertiesCopy["sessionId"] = this.sessionId;
+				propertiesCopy["token"] = this.token;
+
+				var replaceId = "replace_" + this.sessionId;
+				swfobject.addDomLoadEvent(function() {
+					var div = document.createElement('div');
+					div.setAttribute('id', replaceId);
+					div.style.display = "none";
+					document.body.appendChild(div);
+                    var nowDate = new Date();
+			        propertiesCopy["startTime"] = nowDate.getTime();
+					swfobject.embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_controllerwidget.swf?partnerId="+apiKey, replaceId, 1, 1, MIN_FLASH_VERSION, false, propertiesCopy, params, attributes);
+				});
+				if (window.location.protocol == "file:") {
+					setTimeout("TB.controllerLoadCheck()", 8000);
+				}
+			};
+
+			this.disconnect = function() {
+				debug("Session.disconnect()");
+
+				if (!controllerId || this.connecting) {
+					warn("Session.disconnect :: No connection to disconnect");
+					return;
+				}
+
+				// Disconnect controller
+				var controller = document.getElementById(controllerId);
+				if (controller) {
+					if (!isUnloading) {
+						try {
+							controller.cleanupView();
+
+						} catch(e) {
+								var errorMsg = "Session.disconnect :: Failed to disconnect - " + e;
+								error(errorMsg);
+								throw new Error(errorMsg);
+						}
+					}
+				} else {
+					warn("Session.disconnect :: No connection to disconnect");
+				}
+			};
+
+			this.disconnectComponents = function() {
+				debug("Session.disconnectComponents() - disconnecting publishers and subscribers");
+				// As part of cleaning up connections, disconnect any publishers and subscribers
+
+				for (var publisher in this.publishers) {
+					if (this.publishers[publisher].hasOwnProperty("id"))
+						disconnectComponent(this.publishers[publisher]);
+				}
+
+				for (var subscriber in this.subscribers) {
+					if (this.subscribers[subscriber].hasOwnProperty("id"))
+						disconnectComponent(this.subscribers[subscriber]);
+				}
+			};
+
+			this.cleanup = function() {
+				debug("Session.cleanup()");
+				for (var publisher in this.publishers) {
+					if (this.publishers[publisher].hasOwnProperty("id"))
+						this.unpublish(this.publishers[publisher]);
+				}
+				for (var subscriber in this.subscribers) {
+					if (this.subscribers[subscriber].hasOwnProperty("id"))
+						this.unsubscribe(this.subscribers[subscriber]);
+				}
+			};
+
+			this.cleanupConnection = function() {
+				// private function
+				debug("Session.cleanupConnection() - removing controller");
+				this.connection = null;
+
+				if (!controllerId) {
+					warn("Session.cleanup :: No connection to clean up");
+					return;
+				}
+
+				if (document.getElementById(controllerId)) {
+					setTimeout(function() { removeSWF(controllerId, "TB.sessionDisconnected :: "); controllerId = null; }, 0); // must be asynchronous
+				} else {
+					warn("Session.cleanup :: No connection to clean up");
+				}
+			};
+
+
+		this.publish = function(replaceElementId, properties) {
+			debug("Session.publish(" + replaceElementId + "):" + properties);
+
+
+			if (!this.connection || !this.connection.connectionId) {
+				var errorMsg = "Session.publish :: Connection required to publish";
+				error(errorMsg);
+				throw new Error(errorMsg);
+			}
+			if (!replaceElementId) {
+				// Create a new element for the publisher and append it to the body
+				var div = document.createElement('div');
+				replaceElementId = "publisher_replace_" + this.sessionId + "_" + publisherCount;
+				div.setAttribute('id', replaceElementId);
+				document.body.appendChild(div);
+			}
+
+			// Check the name & data properties for length
+			var propertiesCopy = (properties) ? copyObject(properties) : {};
+
+            if (propertiesCopy["name"] != undefined && propertiesCopy["name"].length > 1000) {
+				errorMsg = "Session.publish :: name property longer than 1000 chars.";
+	            error(errorMsg);
+				throw new Error(errorMsg);
+            }
+
+            if (propertiesCopy["data"] != undefined && propertiesCopy["data"].length > 1000) {
+				errorMsg = "Session.publish :: data property longer than 1000 chars.";
+	            error(errorMsg);
+				throw new Error(errorMsg);
+            }
+
+			var publisherId = "publisher_" + this.sessionId + "_" + publisherCount++;
+			var publisher = new Publisher(publisherId, replaceElementId, propertiesCopy);
+				return this._embedPublisher(publisher);
+			};
+			
+			// This function is not intended for publish use, it is so that we can republish when someone clicks
+			// the deny button
+			this._embedPublisher = function (publisher) {			
+				var replaceElement = document.getElementById(publisher.replacedDivId);
+				if(!replaceElement) {
+					errorMsg = "Session.publish :: replaceElementId does not exist in DOM.";
+			    error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				var params = {};
+				params.allowscriptaccess = "always";
+				params.cameraSelected = cameraSelected;
+			      
+				if (publisher.properties.wmode){
+					params.wmode = publisher.properties.wmode;
+					delete publisher.properties["wmode"];
+				} else {
+					params.wmode = "transparent";
+				}
+
+				if (publisher.properties.hasOwnProperty("style")) {
+					publisher.properties.style = encodeURIComponent(JSONify(publisher.properties.style));
+				}
+
+				var attributes = {};
+				attributes.id = publisher.id;
+				attributes.style = "outline:none;";
+
+				publisher.properties["publisherId"] = publisher.id;
+				publisher.properties["connectionId"] = this.connection.connectionId;
+				publisher.properties["sessionId"] = this.sessionId;
+				publisher.properties["token"] = this.token;
+				publisher.properties["cameraSelected"] = cameraSelected;
+				publisher.properties["simulateMobile"] = TB.simulateMobile;
+				publisher.properties["publishCapability"] = this.capabilities.publish;
+				
+				if (!publisher.properties.width || isNaN(publisher.properties.width))
+					publisher.properties.width = DEFAULT_WIDTH;
+				if (!publisher.properties.height || isNaN(publisher.properties.height))
+					publisher.properties.height = DEFAULT_HEIGHT;
+				/**	if (!publisher.properties.encodedWidth || isNaN(publisher.properties.encodedWidth))
+					publisher.properties.encodedWidth = DEFAULT_WIDTH;
+				if (!publisher.properties.encodedHeight || isNaN(publisher.properties.encodedHeight))
+					publisher.properties.encodedHeight = DEFAULT_HEIGHT;
+				*/
+				this.publishers[publisher.id] = publisher;
+				var nowDate = new Date();
+				publisher.properties["startTime"] = nowDate.getTime();
+				embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_publishwidget.swf?partnerId="+this.apiKey, publisher.replacedDivId, publisher.properties.width, publisher.properties.height, MIN_FLASH_VERSION, false, publisher.properties, params, attributes);
+
+				return publisher;
+			};
+			
+
+			this.unpublish = function(publisher) {
+				if (!publisher) {
+					var errorMsg = "Session.unpublish :: publisher cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				debug("Session.unpublish(" + publisher.id + ")");
+
+				if (publisher.panelId && deviceManager && deviceManager.panels[publisher.panelId]) {
+					deviceManager.removePanel(deviceManager.panels[publisher.panelId]);
+				}
+
+				unloadComponent(publisher);
+				delete this.publishers[publisher.id];
+			};
+
+		this.forceUnpublish = function(stream) {
+				var streamId;
+				if (stream && typeof(stream) == "string") {
+					streamId = stream;
+		    } else if (stream && typeof(stream) == "object" && stream.hasOwnProperty("streamId")) {
+					streamId = stream.streamId;
+		    } else {
+					var errorMsg = "Session.forceUnpublish :: Invalid stream type";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				debug("Session.forceUnpublish(" + streamId + ")");
+
+				if (streamId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.forceUnpublish(streamId);
+					} catch(err) {
+						errorMsg = "Session.forceUnpublish :: "+ err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.forceUnpublish :: Stream does not exist.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+		};
+
+			this.subscribe = function(stream, replaceElementId, properties) {
+				if (!this.connection || !this.connection.connectionId) {
+					var errorMsg = "Session.subscribe :: Connection required to subscribe";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				if (!stream) {
+					errorMsg = "Session.subscribe :: stream cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (!stream.hasOwnProperty("streamId")) {
+					errorMsg = "Session.subscribe :: invalid stream object";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				debug("Session.subscribe(" + stream.streamId + ")");
+
+				if (!replaceElementId) {
+					// Create a new element for the subscriber and append it to the body
+					var div = document.createElement('div');
+					replaceElementId = "subscriber_replace_" + this.sessionId + "_" + subscriberCount;
+					div.setAttribute('id', replaceElementId);
+					document.body.appendChild(div);
+				}
+
+				var replaceElement = document.getElementById(replaceElementId);
+				if(!replaceElement) {
+					errorMsg = "Session.subscribe :: replaceElementId does not exist in DOM.";
+			error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				var propertiesCopy = (properties) ? copyObject(properties) : {};
+
+				if( stream && stream.hasOwnProperty("type") && stream.type == "multiplexed") {
+					propertiesCopy.mixedStreamURI = "live-lowlatency";
+				}
+
+				var subscriberId = "subscriber_" + stream.streamId + "_" + subscriberCount++;
+				var subscriber = new Subscriber(stream, subscriberId, replaceElementId, propertiesCopy);
+
+				var params = {};
+				params.allowscriptaccess = "always";
+				if (propertiesCopy.wmode){
+					params.wmode = propertiesCopy.wmode;
+					delete propertiesCopy["wmode"];
+				} else {
+					params.wmode = "transparent";
+				}
+				
+				if (propertiesCopy.hasOwnProperty("style")) {
+					propertiesCopy.style = encodeURIComponent(JSONify(propertiesCopy.style));
+				}
+
+				var attributes = {};
+				attributes.id = subscriber.id;
+				attributes.style = "outline:none;";
+
+				propertiesCopy["subscriberId"] = subscriberId;
+				propertiesCopy["connectionId"] = this.connection.connectionId;
+				propertiesCopy["sessionId"] = this.sessionId;
+				propertiesCopy["streamId"] = stream.streamId;
+				propertiesCopy["streamType"] = stream.type;
+				propertiesCopy["name"] = stream.name;
+				propertiesCopy["token"] = this.token;
+				propertiesCopy["simulateMobile"] = TB.simulateMobile;
+				propertiesCopy["isPublishing"] = (Object.keys(this.publishers).length > 0);
+
+		    if(!stream.hasAudio) {
+			propertiesCopy["subscribeToAudio"] = "false";
+		    }
+		    if(!stream.hasVideo) {
+			propertiesCopy["subscribeToVideo"] = "false";
+		    }
+				propertiesCopy["orientation"] = stream.orientation;
+				propertiesCopy["peerId"] = stream.peerId;
+				
+				if (!propertiesCopy.width || isNaN(propertiesCopy.width))
+					propertiesCopy.width = DEFAULT_WIDTH;
+				if (!propertiesCopy.height || isNaN(propertiesCopy.height))
+					propertiesCopy.height = DEFAULT_HEIGHT;
+
+				this.subscribers[subscriber.id] = subscriber;
+
+                var nowDate = new Date();
+				propertiesCopy["startTime"] = nowDate.getTime();
+				embedSWF(WIDGET_URL + "/v0.91.46.b5f48f1/flash/f_subscribewidget.swf?partnerId="+this.apiKey, replaceElementId, propertiesCopy.width, propertiesCopy.height, MIN_FLASH_VERSION, false, propertiesCopy, params, attributes);
+
+				return subscriber;
+			};
+
+			this.unsubscribe = function(subscriber) {
+				if (!subscriber) {
+					var errorMsg = "Subscribe.unsubscribe :: subscriber cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				debug("Session.unsubscribe(" + subscriber.id + ")");
+
+				unloadComponent(subscriber);
+				delete this.subscribers[subscriber.id];
+			};
+
+			this.signal = function() {
+				debug("Session.signal()");
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.sendSignal();
+					} catch(err) {
+						var errorMsg = "Session.signal :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.signal :: Connection required to signal.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+
+			this.forceDisconnect = function(connection) {
+				if (connection) debug("Session.forceDisconnect(" + connection.connectionId + ")");
+				var connectionId;
+				if (connection && typeof(connection) == "string")
+					connectionId = connection;
+				else if (connection && typeof(connection) == "object" && connection.hasOwnProperty("connectionId"))
+					connectionId = connection.connectionId;
+				else {
+					var errorMsg = "Session.forceDisconnect :: Invalid connection type";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.forceDisconnect(connectionId);
+					} catch(err) {
+						errorMsg = "Session.forceDisconnect :: "+ err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.forceDisconnect :: Connection required to forceDisconnect.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.getSubscribersForStream = function(stream) {
+				var res = null;
+				if (!stream) {
+					var errorMsg = "Session.getSubscribersForStream :: stream cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				} else {
+				    var streamId;
+				if (typeof(stream) == "string") {
+					streamId = stream;
+				} else if (typeof(stream) == "object" && stream.hasOwnProperty("streamId")) {
+					streamId = stream.streamId;
+				} else {
+						errorMsg = "Session.getSubscribersForStream :: Invalid stream type";
+					error(errorMsg);
+						throw new Error(errorMsg);
+				    }
+
+				res = [];
+				for (var sr in this.subscribers) {
+				    if (this.subscribers[sr].hasOwnProperty("stream") && this.subscribers[sr].stream.streamId == streamId)
+						res.push(this.subscribers[sr]);
+				    }
+				}
+
+				return res;
+			};
+
+			this.getPublisherForStream = function(stream) {
+				if (!stream) {
+					var errorMsg = "Session.getPublisherForStream :: stream cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				} else {
+				    var streamId;
+				if (typeof(stream) == "string") {
+					streamId = stream;
+				} else if (typeof(stream) == "object" && stream.hasOwnProperty("streamId")) {
+					streamId = stream.streamId;
+				} else {
+						errorMsg = "Session.getPublisherForStream :: Invalid stream type";
+					error(errorMsg);
+						throw new Error(errorMsg);
+				    }
+
+				for (var pub in this.publishers) {
+						var publisher = document.getElementById(this.publishers[pub].id);
+						if (publisher) {
+							try {
+								if (publisher.getStreamId() == streamId) return this.publishers[pub];
+							} catch (err) {
+								warn("Failed to get streamId for publisher: " + this.publishers[pub].id);
+							}
+						}
+				    }
+				}
+
+				return null;
+			};
+
+			this.createArchive = function(apiKey, type, title) {
+				debug("Session.createArchive()");
+				if (controllerId && this.connection && this.connection.connectionId) {
+					if (type == TB.PER_SESSION || type == TB.PER_STREAM) {
+						try {
+							var controller = document.getElementById(controllerId);
+							controller.createArchive(apiKey, type, title);
+						} catch(err) {
+							errorMsg = "Session.createArchive :: " + err;
+							error(errorMsg);
+							throw new Error(errorMsg);
+						}
+					} else {
+						errorMsg = "Session.createArchive :: Invalid type specfied.";
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.createArchive :: Connection required to create an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.loadArchive = function(archiveId) {
+				debug("Session.loadArchive()");
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.loadArchive(archiveId);
+					} catch(err) {
+						var errorMsg = "Session.loadArchive :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.loadArchive :: Connection required to load an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.startRecording = function(archive) {
+				debug("Session.startRecording()");
+				archive = createdArchives[this.sessionId][archive.archiveId];
+				if (!archive) {
+					var errorMsg = "Session.startRecording :: Archive not created.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (archive.type != TB.PER_SESSION) {
+					errorMsg = "Session.startRecording :: Trying to record per session on a " + archive.type + " archive";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (archive.recording) {
+					warn("Session.startRecording :: Trying to start recording when the archive is already recording");
+					return;
+				}
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.startRecordingSession(archive.archiveId);
+						archive.recording = true;
+					} catch(err) {
+						errorMsg = "Session.startRecording :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.startRecording :: Connection required to record an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.stopRecording = function(archive) {
+				debug("Session.stopRecording()");
+				archive = createdArchives[this.sessionId][archive.archiveId];
+				if (!archive) {
+					var errorMsg = "Session.stopRecording :: Archive not created.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (archive.type != TB.PER_SESSION) {
+					errorMsg = "Session.stopRecording :: Trying to stop recording per session on a " + archive.type + " archive";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.stopRecordingSession(archive.archiveId);
+						archive.recording = false;
+					} catch(err) {
+						errorMsg = "Session.stopRecording :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.stopRecording :: Connection required to record an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+
+			this.closeArchive = function(archive) {
+				debug("Session.closeArchive()");
+				if (controllerId && this.connection && this.connection.connectionId) {
+					try {
+						var controller = document.getElementById(controllerId);
+						controller.closeArchive(archive.archiveId);
+					} catch(err) {
+						var errorMsg = "Session.closeArchive :: " + err;
+						error(errorMsg);
+						throw new Error(errorMsg);
+					}
+				} else {
+					errorMsg = "Session.closeArchive :: Connection required to close an archive.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			};
+			
+			this.getStateManager = function() {
+				debug("Session.getStateManager()");
+				
+				if (stateManager) return stateManager;
+				else if (controllerId && this.connection && this.connection.connectionId) {
+				    stateManager = new StateManager(controllerId);
+					return stateManager;
+				}
+				
+				var errorMsg = "Session.getStateManager :: Connection required to getState. Wait for sessionConnected before you getStateManager.";
+				error(errorMsg);
+				throw new Error(errorMsg);
+			};
+		}
+		
+		function StateManager(controllerId, archiveId) {
+		    this.superClass = EventDispatcher;
+		    this.superClass();
+		    
+		    var MAX_KEYS = 20;
+			
+			this.archiveId = archiveId;
+
+			this.set = function(key, value) {
+			    var values = key;
+				if (archiveId) {
+				  var errorMsg = "StateManager.set :: not allowed on StateManager objects for archives.";
+				  error(errorMsg);
+				  throw new Error(errorMsg);
+				}
+			    if (typeof(key) == "string" && (typeof(value) == "string" || value == null)) {
+					values = {};
+					values[key] = value;
+			    } else if (typeof(key) == "object" && value == null) {
+					if (Object.keys(values).length > MAX_KEYS) {
+					    error("StateManager.set :: Maximum number of keys exceeded");
+						this.dispatchEvent(new ChangeFailedEvent("changeFailed", 405, "Maximum number of keys exceeded", values));
+						return;
+					}
+			    } else {
+					errorMsg = "StateManager.set :: Invalid parameters passed. set() takes either two string parameters or one object of key value pairs.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+			    }
+			    
+			    for (var k in values) {
+					if (typeof(values[k]) != "string" && values[k] != null) {
+					    error("StateManager.set :: Invalid value " + values[k].toString() + " is not a string");
+					    this.dispatchEvent(new ChangeFailedEvent("changeFailed", 403, " Invalid value, value must be a string", values));
+					    return;
+					}
+			    };
+			    
+			    if (controllerId) {
+					try {
+					  var controller = document.getElementById(controllerId);
+					  controller.setState(values);
+					} catch (err) {
+					  errorMsg = "StateManager.set :: " + err;
+					  error(errorMsg);
+					  throw new Error(errorMsg);
+					}
+			    }
+			};
+			
+			this.superAddEventListener = this.addEventListener;
+			this.addEventListener = function(type, listener) {
+			    var key = false;
+				if (type == "changed") {
+					key = null;
+				} else if (type.indexOf("changed:") == 0) {
+					// Tell the controller which keys we want to subscribe to
+					key = type.split(":")[1];
+				}
+				
+				if (key !== false) {
+					if (archiveId) {
+						key = "TB_archive_" + archiveId + "_";
+					}
+				    // Tell the controller that we want to subscribe to all keys
+					if (controllerId) {
+						try {
+							var controller = document.getElementById(controllerId);
+							controller.subscribeToKeyChange(key);
+						} catch(err) {
+							var errorMsg = "StateManager.addEventListener :: " + err;
+							error(errorMsg);
+							throw new Error(errorMsg);
+						}
+					}
+				}
+				
+				this.superAddEventListener(type, listener);
+			};
+			
+			// Need to figure out how to know whether there are any event listeners for a key
+			// if there are none then we can stop listening on the shared object, otherwise we should
+			// keep listening.
+		// this.superRemoveEventListener = this.removeEventListener;
+		// this.removeEventListener = function(type, listener) {
+		//     var key = false;
+		//  if (type == "changed") {
+		//                 key = null;
+		//  } else if (type.indexOf("changed:") == 0) {
+		//      // Tell the controller which keys we want to subscribe to
+		//                 key = type.split(":")[1];
+		//  }
+		//  
+		//  if (key !== false) {
+		//      // Tell the controller that we want to subscribe to all keys
+		//      if (controllerId) {
+		//                  try {
+		//                      var controller = document.getElementById(controllerId);
+		//                      controller.unsubscribeFromKeyChange(key);
+		//                  } catch(err) {
+		//                      var errorMsg = "StateManager.removeEventListener :: " + err;
+		//                      error(errorMsg);
+		//                      throw new Error(errorMsg);
+		//                  }
+		//              }
+		//  }
+		//     
+		//     this.superRemoveEventListener(type, listener);
+		// };
+		}
+		
+
+		//--------------------------------------
+		//  PRIVATE HELPER FUNCTIONS
+		//--------------------------------------	
+
+		function setEchoSuppressionEnabled(sessionId, groupId, isEnabled) {
+			try {
+				var controller = document.getElementById("controller_" + sessionId);
+				controller.setEchoSuppressionEnabled(groupId, isEnabled);
+			} catch(err) {
+				var errorMsg = "Group :: " + err;
+				error(errorMsg);
+				throw new Error(errorMsg);
+			}
+		}
+
+		function getGroupProperties(sessionId, groupId) {
+			var groupProperties = null;
+			try {
+				var controller = document.getElementById("controller_" + sessionId);
+				var groupObject = controller.getGroupProperties(groupId);
+
+				groupProperties = new GroupProperties(groupObject);
+			} catch(err) {
+				var errorMsg = "Group :: " + err;
+				error(errorMsg);
+				throw new Error(errorMsg);
+			}
+
+			return groupProperties;
+		}
+
+		function embedCallback (event) {
+			if (!event.success) {
+				error("Failed to embed SWF " + event.id);
+				TB.exceptionHandler("Failed to embed SWF " + event.id, "Embed Failed", 2001);
+			}
+		}
+
+		function embedSWF(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj) {
+			if (!swfobject.hasFlashPlayerVersion(swfVersionStr)) {
+				error("Flash Player " + swfVersionStr + " or higher required");
+				TB.exceptionHandler("Flash Player " + swfVersionStr + " or higher required", "Embed Failed", 2001);
+				return;
+			}
+
+			swfobject.embedSWF(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, embedCallback);
+		}
+
+		function createHandler(func, event) {
+			return function() {
+				if(func != null) {
+					func(event);
+				} else {
+					error('Event handler is null');
+				}
+			};
+	    }
+
+		function flashdebug (str) {
+			window.opentokdebug.debug("[FLASHDEBUG] opentok: " + str);
+		}
+
+		function debug (str) {
+			window.opentokdebug.debug("[DEBUG] opentok: " + str);
+		}
+
+		function info (str) {
+			window.opentokdebug.info("[INFO] opentok: " + str);
+		}
+
+		function warn (str) {
+			window.opentokdebug.warn("[WARN] opentok: " + str);
+		}
+
+	    function error (str) {
+			window.opentokdebug.error("[ERROR] opentok: " + str);
+		}
+
+		function traceOut (level, str) {
+			var element = document.getElementById('opentok_console');
+			if (element) element.innerHTML += (str + '<br>');
+		}
+		
+		function getConnectionFromConnectionId (connectionId) {
+			if (connectionMap.hasOwnProperty(connectionId)) {
+				var connection = connectionMap[connectionId];
+			} else {
+				connection = new Connection(connectionId, NaN, null);
+			}
+			return connection;
+		}
+		
+		function getStream(streamObject, sessionId) {
+		    return new Stream(streamObject.streamId, getConnectionFromConnectionId(streamObject.connectionId), streamObject.name, streamObject.streamData, streamObject.type, streamObject.creationTime, streamObject.hasAudio, streamObject.hasVideo, streamObject.orientation, sessionId, streamObject.peerId, streamObject.quality);
+		}	
+
+		function getStreams (streamObjects, sessionId) {
+			var streams = [];
+			for (var i=0; i < streamObjects.length; i++) {
+				streams.push(getStream(streamObjects[i], sessionId));
+			}
+
+			return streams;
+		}
+		
+		function getArchive (archive, sessionId) {
+			var newArchive = new Archive(archive.id, archive.type, archive.title, sessionId, archive.status);
+			if (!createdArchives.hasOwnProperty(sessionId)) createdArchives[sessionId] = {};
+			createdArchives[sessionId][archive.id] = newArchive;
+			
+			return newArchive;
+		}
+
+		function getConnections (connectionObjects) {
+			var connections = [];
+
+			for (var i=0; i < connectionObjects.length; i++) {
+				var connection = new Connection(connectionObjects[i].connectionId, connectionObjects[i].creationTime, connectionObjects[i].data);
+			    connections.push(connection);
+			
+				connectionMap[connection.connectionId] = connection;
+			};
+
+			return connections;
+		}
+
+		function getGroups (sessionId,groupObjects) {
+			var groups = [];
+			for (var key in groupObjects) {
+				if (groupObjects[key].hasOwnProperty("groupId"))
+				    groups.push(new Group(sessionId,groupObjects[key].groupId));
+			}
+
+			return groups;
+		}
+
+		function getCamera (cameraObj) {
+			if (cameraObj.status == TB.ACTIVE) {
+				return new Camera(cameraObj.name, TB.ACTIVE);
+			} else if (cameraObj.status == TB.INACTIVE) {
+				return new Camera(cameraObj.name, TB.INACTIVE);
+			} else {
+				return new Camera(cameraObj.name, TB.UNKNOWN);
+			}
+		}
+
+		function getMicrophone (microphoneObj) {
+			return new Microphone(microphoneObj.name, microphoneObj.status);
+		}
+
+		function getCameras (cameraObjects) {
+			var cameras = new Array();
+
+			for (var i=0; i < cameraObjects.length; i++) {
+				cameras.push(new Camera(cameraObjects[i].name, cameraObjects[i].status));
+			};
+
+			return cameras;
+		}
+
+		function getMicrophones (microphoneObjects) {
+			var microphones = new Array();
+
+			for (var i=0; i < microphoneObjects.length; i++) {
+				microphones.push(new Microphone(microphoneObjects[i].name, microphoneObjects[i].status));
+			};
+
+			return microphones;
+		}
+
+		function disconnectComponent(component) {
+			if(!component.hasOwnProperty("id")){
+				return;
+			}
+			var uicomponent = document.getElementById(component.id);
+
+			if (uicomponent) {
+				try {
+					uicomponent.cleanupView();
+				} catch(e) {
+					warn("Disconnecting " + component.id + " failed");
+				}
+			} else {
+				warn("Disconnecting " + component.id + " failed");
+			}
+		}
+
+		function unloadComponent (component) {
+			var uicomponent = document.getElementById(component.id);
+			if (uicomponent) {
+				try {
+					uicomponent.cleanupView();
+
+					var parentNode = uicomponent.parentNode;
+					parentNode.removeChild(uicomponent);
+				} catch(e) {
+					warn("Removing " + component.id + " failed " + e);
+				}
+			} else {
+				warn("Element " + component.id + " does not exist");
+			}
+		}
+
+		function removeSWF (componentId, message) {
+			try {
+				if (componentId) {
+					swfobject.removeSWF(componentId);
+					componentId = null;
+				}
+			} catch(err) {
+				var errorMsg = message + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		}
+
+		function setStreamProperty (id, property, value) {
+			var component = document.getElementById(id);
+			if (component) {
+				try {
+					component.setStreamProperty(property, value);
+				} catch (err) {
+					var errorMsg = "Changing settings on component " + id + " failed.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			} else {
+				errorMsg = "Component "+id + " does not exist.";
+				error(errorMsg);
+				throw new Error(errorMsg);
+			}
+		}
+
+		function setDevice (id, device, isCamera) {
+			var component = document.getElementById(id);
+			if (component) {
+				try {
+					if (isCamera) component.setCamera(device.name);
+					else component.setMicrophone(device.name);
+				} catch (err) {
+					var errorMsg = "Changing hardware settings on publisher " + id + " failed.";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+			} else {
+				errorMsg = "Publisher "+ id + " does not exist.";
+				error(errorMsg);
+				throw new Error(errorMsg);
+			}
+		}
+
+		// Find highest Z-index - via StackOverflow <http://bit.ly/dFaOw9>
+		function highZ(parent, limit){
+			limit = limit || Infinity;
+			parent = parent || document.body;
+			var who, temp, max= 1, A= [], i= 0;
+			var children = parent.childNodes, length = children.length;
+			while(i<length){
+				who = children[i++];
+				if (who.nodeType != 1) continue;
+				if (deepCss(who,"position") !== "static") { // element nodes only
+					temp = deepCss(who,"z-index");
+					if (temp == "auto") { // z-index is auto, so not a new stacking context
+						temp = highZ(who);
+					} else {
+						temp = parseInt(temp, 10) || 0;
+					}
+				} else { // non-positioned element, so not a new stacking context
+					temp = highZ(who);
+				}
+				if (temp > max && temp <= limit) max = temp;
+			}
+			return max;
+		}
+
+		// This function is only intended for highZ(). Other uses may be unpredictable.
+		function deepCss(who, css) {
+			var sty, val, dv= document.defaultView || window;
+			if (who.nodeType == 1) {
+				sty = css.replace(/\-([a-z])/g, function(a, b){
+					return b.toUpperCase();
+				});
+				val = who.style[sty];
+				if (!val) {
+					if(who.currentStyle) val= who.currentStyle[sty];
+					else if (dv.getComputedStyle) {
+						val= dv.getComputedStyle(who,"").getPropertyValue(css);
+					}
+				}
+			}
+			return val || "";
+		}
+
+		function createHiddenElement (form, key, value) {
+			var hiddenField = document.createElement("input");
+			hiddenField.setAttribute("name", key);
+			hiddenField.setAttribute("value", value);
+			hiddenField.setAttribute("type", "hidden");
+			form.appendChild(hiddenField);
+		}
+
+		function getDataForUIComponent (componentId) {
+			try {
+				var element = document.getElementById(componentId);
+				if (element) {
+					return element.fetchData();
+				}
+			} catch (err) {
+				warn("Failed to get logs for " + componentId + " " + err);
+				return "";
+			}
+		}
+		
+		function JSONify(object) {
+			// JSONify the style property
+			var styleString = "{ ";
+			for (var key in object) {
+				if (typeof(object[key]) == "boolean")
+					styleString += '"' + key + '":' + object[key] + ', ';
+				else 
+					styleString += '"' + key + '":"' + object[key].toString() + '", ';
+			};
+			if (styleString.length > 1) {
+				styleString = styleString.substring(0, styleString.length - 2) + " }";
+			} else {
+				styleString = "{}";
+			}
+			
+			return styleString;
+		}
+		
+		function copyObject(obj) {
+			var newObj = (obj instanceof Array) ? [] : {};
+			for (var i in obj) {
+				if (i == 'clone') continue;
+				if (obj[i] && typeof obj[i] == "object") {
+					newObj[i] = copyObject(obj[i]);
+				} else newObj[i] = obj[i];
+			}
+			return newObj;
+		}
+
+
+		//--------------------------------------
+		//  EVENT HANDLERS
+		//--------------------------------------
+
+		this.isUnloading = false;
+		window.onunload = function() {
+			isUnloading = true;
+			for (var i in TB.sessions) {
+				if (TB.sessions[i].hasOwnProperty("disconnect")) {
+					// Stop sessionDisconnectedHandler from happening. Was causing crashes on Safari.
+					// We are just doing all the cleanup now.
+					TB.sessionDisconnectedHandler = function() {};
+
+					TB.sessions[i].disconnect();
+					TB.sessions[i].cleanupConnection();
+					TB.sessions[i].cleanup();
+				}
+			}
+		};
+
+
+		//--------------------------------------
+		//  PRIVATE STATIC VARIABLES
+		//--------------------------------------
+
+		var MIN_FLASH_VERSION = "10.0.0";
+
+		// Minimum width and height to fit the adobe settings UI
+		var MIN_ADOBE_WIDTH = 215;
+		var MIN_ADOBE_HEIGHT = 138;
+
+		var deviceManager;
+		var recorderManager;
+		var deviceDetectorId;
+		var cameraSelected = false;
+		var showingIssueForm = false;
+				
+		var connectionMap = {};
+		
+		var SUPPORT_SSL = "true";
+		
+		var WIDGET_URL = "http://staging.tokbox.com";
+		
+		if (SUPPORT_SSL == "true" && window.location.protocol == "https:") {
+			WIDGET_URL = "https://staging.tokbox.com";
+		}
+		
+		var dispatcher = new EventDispatcher();
+		var createdArchives = {};
+		var loadedArchives = {};
+
+		var controllerLoaded = false;
+
+		return {
+
+			//--------------------------------------
+			//  TB PUBLIC STATIC VARIABLES
+			//--------------------------------------
+
+			sessions: {},
+			groups: {},
+
+			LOG:      5,
+			DEBUG:    4,
+			INFO:     3,
+			WARN:     2,
+			ERROR:    1,
+			NONE:     0,
+
+			// Activity Status for cams/mics
+			ACTIVE: "active",
+			INACTIVE: "inactive",
+			UNKNOWN: "unknown",
+
+			// Archive types
+			PER_SESSION: "perSession",
+			PER_STREAM: "perStream",
+
+			// TB Events
+			EXCEPTION: "exception",
+
+			// Session Events
+			SESSION_CONNECTED: "sessionConnected",
+			SESSION_DISCONNECTED: "sessionDisconnected",
+			STREAM_CREATED: "streamCreated",
+			STREAM_DESTROYED: "streamDestroyed",
+			CONNECTION_CREATED: "connectionCreated",
+			CONNECTION_DESTROYED: "connectionDestroyed",
+			SIGNAL_RECEIVED: "signalReceived",
+			STREAM_PROPERTY_CHANGED: "streamPropertyChanged",
+			MICROPHONE_LEVEL_CHANGED: "microphoneLevelChanged",
+			ARCHIVE_CREATED: "archiveCreated",
+			ARCHIVE_CLOSED: "archiveClosed",
+			ARCHIVE_LOADED: "archiveLoaded",
+			ARCHIVE_SAVED: "archiveSaved",
+			SESSION_RECORDING_STARTED: "sessionRecordingStarted",
+			SESSION_RECORDING_STOPPED: "sessionRecordingStopped",
+			SESSION_RECORDING_IN_PROGRESS: "sessionRecordingInProgress",
+			STREAM_RECORDING_IN_PROGRESS: "streamRecordingInProgress",
+			SESSION_NOT_RECORDING: "sessionNotRecording",
+			STREAM_RECORDING_STARTED: "streamRecordingStarted",
+			STREAM_RECORDING_STOPPED: "streamRecordingStopped",
+			PLAYBACK_STARTED: "playbackStarted",
+			PLAYBACK_STOPPED: "playbackStopped",
+			RECORDING_STARTED: "recordingStarted",
+			RECORDING_STOPPED: "recordingStopped",
+			// Group Events
+			GROUP_PROPERTIES_UPDATED: "groupPropertiesUpdated",
+
+			// Publisher Events
+			RESIZE: "resize",
+			SETTINGS_BUTTON_CLICK: "settingsButtonClick",
+			DEVICE_INACTIVE: "deviceInactive",
+			ACCESS_ALLOWED: "accessAllowed",
+			ACCESS_DENIED: "accessDenied",
+			ECHO_CANCELLATION_MODE_CHANGED: "echoCancellationModeChanged",
+
+			// DeviceManager Events
+			DEVICES_DETECTED: "devicesDetected",
+
+			// DevicePanel Events
+			DEVICES_SELECTED: "devicesSelected",
+			CLOSE_BUTTON_CLICK: "closeButtonClick",
+
+			HAS_REQUIREMENTS: 1,
+			OLD_FLASH_VERSION: 0,
+
+			// Stream types
+			BASIC_STREAM: "basic",
+			MULTIPLEXED_STREAM: "multiplexed",
+			ARCHIVED: "archive",
+
+			// Global group ID
+			GLOBAL_GROUP: "global",
+
+			// Multiplexer Switch Type
+			MULTIPLEXER_TIMEOUT_BASED_SWITCH: 0,
+			MULTIPLEXER_ACTIVITY_BASED_SWITCH: 1,
+
+			simulateMobile: false,
+
+			//--------------------------------------
+			//  TB STATIC FUNCTIONS
+			//--------------------------------------
+			
+			setLogLevel: function(value) {
+				window.opentokdebug.setLevel(value);
+				if (value == this.NONE) window.opentokdebug.setCallback(null);
+				else window.opentokdebug.setCallback(traceOut, true);
+				debug("TB.setLogLevel(" + value + ")" );
+			},
+
+
+			log: function(str) {
+				window.opentokdebug.log("[LOG] opentok: " + str);
+			},
+
+			initSession: function(sessionId) {
+				debug("TB.initSession(" + sessionId + ")");
+				if (sessionId == null || sessionId == "") {
+					var errorMsg = "TB.initSession :: sessionId cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+
+				if (!this.sessions.hasOwnProperty(sessionId)) {
+					this.sessions[sessionId] = new Session(sessionId);
+				}
+
+				return this.sessions[sessionId];
+			},
+
+			initDeviceManager: function(apiKey) {
+				debug("TB.initDeviceManager(" + apiKey + ")");
+				if (!apiKey) {
+					var errorMsg = "TB.initDeviceManager :: apiKey cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (!deviceManager) {
+					deviceManager = new DeviceManager(apiKey);
+				}
+				return deviceManager;
+			},
+			
+			initRecorderManager: function(apiKey) {
+				debug("TB.initRecorderManager(" + apiKey + ")");
+				if (!apiKey) {
+					var errorMsg = "TB.initRecorderManager :: apiKey cannot be null";
+					error(errorMsg);
+					throw new Error(errorMsg);
+				}
+				if (!recorderManager) {
+					recorderManager = new RecorderManager(apiKey);
+				}
+				return recorderManager;
+			},
+
+			addEventListener: function(type, callback) {
+				debug("TB.addEventListener(" + type + ")");
+				dispatcher.addEventListener(type, callback);
+			},
+
+			removeEventListener: function(type, callback) {
+				debug("TB.removeEventListener(" + type + ")");
+				dispatcher.removeEventListener(type, callback);
+			},
+
+			dispatchEvent: function(event) {
+				debug("TB.dispatchEvent()");
+				event.target = this;
+				dispatcher.dispatchEvent(event);
+			},
+
+			checkSystemRequirements: function() {
+				debug("TB.checkSystemRequirements()");
+				return swfobject.hasFlashPlayerVersion(MIN_FLASH_VERSION) ? this.HAS_REQUIREMENTS : this.OLD_FLASH_VERSION;
+			},
+
+			//--------------------------------------
+			//  FLASH CALLBACK HANDLERS
+			//--------------------------------------
+
+			// TB callbacks
+			exceptionHandler: function(msg, title, errorCode) {
+				error("TB.exception :: title: " + title + " msg: " + msg + " errorCode: " + errorCode);
+				try {
+					this.dispatchEvent(new ExceptionEvent(this.EXCEPTION, msg, title, errorCode));
+				} catch(err) {
+					var errorMsg = "TB.exception :: Failed to dispatch exception - " + err;
+					error(errorMsg);
+					// Don't throw an error because this is asynchronous
+					// don't do an exceptionHandler because that would be recursive
+				}
+			},
+
+			// private callback
+			controllerLoadedHandler: function() {
+				controllerLoaded = true;
+			},
+
+			controllerLoadCheck: function(event) {
+				if (!controllerLoaded) {
+					var confirmMsg = "The connection timed out. Make sure that you have allowed this page in the"
+									+ "Flash Player Global Settings Manager. Go to:";
+					adobeURL = "http://www.macromedia.com/support/documentation/en/flashplayer/help/settings_manager04.html";
+					prompt(confirmMsg, adobeURL);
+				}
+			},
+
+			// private callback
+			flashLogger: function(msg) {
+				flashdebug(msg);
+			},
+
+			// private callback
+			destroyStreamHandler: function(sessionId, streamObjects) {
+				debug("TB.destroyStream");
+				try {
+					var session = this.sessions[sessionId];
+					var streams = getStreams(streamObjects, sessionId);
+
+					var action = function() {
+						for (var i = 0; i < streams.length; i++) {
+							var publisher = session.getPublisherForStream(streams[i]);
+							if (publisher) {
+								session.unpublish(publisher);
+							}
+						}
+					};
+
+					// The event handler is called asynchronously after 2 milliseconds.
+					setTimeout(action, 2);
+				} catch(err) {
+					var errorMsg = "TB.destroyStream :: " + err;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				}
+			},
+
+			// Session callbacks
+			sessionConnectedHandler: function(sessionId, connectionId, connectionObjects, streamObjects, groupObjects, capabilities, connectionQuality, p_archives) {
+				debug("TB.sessionConnected");
+				try {
+					var session = this.sessions[sessionId];
+					for(var i=0, len = connectionObjects.length; i < len; i++) {
+					    connection = connectionObjects[i];
+					    if(connection.connectionId == connectionId) {
+						session.connection = new Connection(connectionId, connection.creationTime, connection.data);
+						break;
+					    }
+					}
+					session.connected = true;
+					session.connecting = false;
+					session.connection.quality = connectionQuality;
+					session.capabilities = capabilities;
+					var connections = getConnections(connectionObjects);
+					var streams = getStreams(streamObjects, session.sessionId);
+					var groups = getGroups(sessionId,groupObjects);
+					for (var i=0; i < groups.length; i++) {
+						this.groups[sessionId + "_" + groups[i].groupId] = groups[i];
+					}
+					
+					var archives = [];
+					for (var i=0; i < p_archives.length; i++) {
+						var newArchive = getArchive(p_archives[i], sessionId);
+						archives.push(newArchive);
+					};
+					
+					session.dispatchEvent(new SessionConnectEvent(this.SESSION_CONNECTED, connections, streams, groups, archives));
+				}
+				catch(err) {
+					var errorMsg = "TB.sessionConnected :: "+err;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				}
+			},
+
+			sessionDisconnectedHandler: function(sessionId, reason) {
+				debug("TB.sessionDisconnected(" + reason + ")");
+				try {
+					var session = this.sessions[sessionId];
+					session.disconnectComponents();
+					session.cleanupConnection();
+					session.connected = false;
+
+					var event = new SessionDisconnectEvent(this.SESSION_DISCONNECTED, reason, true);
+					session.dispatchEvent(event);
+
+					var defaultAction = function() {
+						if (!event.isDefaultPrevented()) {
+							session.cleanup();
+						}
+					};
+
+					// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+					setTimeout(defaultAction, 2);
+				} catch(err) {
+					var errorMsg = "TB.sessionDisconnected :: " + err;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				}
+			},
+
+			streamCreatedHandler: function(sessionId, streamObjects, reason) {
+				debug("TB.streamCreated");
+				try {
+					var session = this.sessions[sessionId];
+
+					var streams = getStreams(streamObjects, sessionId);
+					session.dispatchEvent(new StreamEvent(this.STREAM_CREATED, streams, reason));
+
+					//notify publisher if there's an archive in flight
+					var myArchives = createdArchives[sessionId];
+					for (var bob in myArchives) {
+						for (var i=0; i<streams.length; i++) {
+							if (streams[i].connection.connectionId == connection.connectionId) {
+								for (var pub in session.publishers) {
+									if (session.publishers[pub].hasOwnProperty("id")) {
+										var publisher = document.getElementById(session.publishers[pub].id);
+							if (bob && myArchives[bob] &&  myArchives[bob].type == TB.PER_SESSION && myArchives[bob].recording == true) {
+								publisher.signalRecordingStarted();
+					    }
+									}
+								}
+							}
+						}
+					}
+
+				} catch(err) {
+					var errorMsg = "TB.streamCreated :: "+err;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				}
+			},
+
+			streamDestroyedHandler: function(sessionId, streamObjects, reason) {
+				debug("TB.streamDestroyed");
+				try {
+					var session = this.sessions[sessionId];
+					var streams = getStreams(streamObjects, sessionId);
+					var event = new StreamEvent(this.STREAM_DESTROYED, streams, reason, true);
+					session.dispatchEvent(event);
+
+					var defaultAction = function() {
+						if (!event.isDefaultPrevented()) {
+							for (var i = 0; i < event.streams.length; i++) {
+								var subscribers = session.getSubscribersForStream(event.streams[i]);
+								for (var j = 0; j < subscribers.length; j++) {
+									session.unsubscribe(subscribers[j]);
+								}
+								var publisher = session.getPublisherForStream(event.streams[i]);
+								if (publisher) {
+									session.unpublish(publisher);
+								}
+							}
+						}
+					};
+
+					// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+					setTimeout(defaultAction, 2);
+				} catch(err) {
+					var errorMsg = "TB.streamDestroyed :: " + err;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				}
+			},
+
+		streamPropertyChangedHandler: function(sessionId, streamObj, changedProperty, oldValue, newValue) {
+				debug("TB.streamPropertyChangedHandler");
+
+				var session = this.sessions[sessionId];
+				var stream = getStream(streamObj, sessionId);
+
+			var event = new StreamPropertyChangedEvent(this.STREAM_PROPERTY_CHANGED, stream, changedProperty, oldValue, newValue);
+
+			session.dispatchEvent(event);
+
+			try {
+				var subscriber;
+				if ("hasAudio" == changedProperty) {
+					for (var componentId in session.subscribers) {
+						subscriber = session.subscribers[componentId];
+						if (subscriber.hasOwnProperty("stream") && subscriber.stream.streamId == stream.streamId) {
+							subscriber._subscribeToAudio(newValue, true);
+							break;
+						}
+					}
+				} else if ("hasVideo" == changedProperty) {
+					for (componentId in session.subscribers) {
+						subscriber = session.subscribers[componentId];
+						if (subscriber.hasOwnProperty("stream") && subscriber.stream.streamId == stream.streamId) {
+							subscriber._subscribeToVideo(newValue, true);
+							break;
+						}
+					}
+				} else if ("orientation" == changedProperty) {
+					for (componentId in session.subscribers) {
+						subscriber = session.subscribers[componentId];
+						if (subscriber.hasOwnProperty("stream") && subscriber.stream.streamId == stream.streamId) {
+							subscriber.changeOrientation(newValue);
+							break;
+						}
+					}
+				} else if ("quality" == changedProperty) {
+				    //do nothing.
+				} else {
+					debug("Unknown property changed");
+				}
+			} catch(err) {
+				var errorMsg = "TB.streamPropertyChangedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+        },
+        
+		microphoneLevelChangedHandler: function(sessionId, componentId, streamId, volume){
+		                       //debug("TB.microphoneLevelChangedHandler: " + streamId);                                                                                                                                  
+						   try {
+		                           var session = this.sessions[sessionId];
+		
+		                           if (!session) {
+		                               var errorMsg = "TB.microphoneLevelChangedHandler :: Invalid session ID: " + sessionId;
+		                               error(errorMsg);
+		                               TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+		                               return;
+		                           }
+		                               
+		                           var subscriber = session.subscribers[componentId];
+		                               
+		                           var event = new VolumeEvent(this.MICROPHONE_LEVEL_CHANGED, streamId, volume);
+								   session.dispatchEvent(event);
+		                       } catch (err) {
+		                           errorMsg = "microphoneLevelChanged :: " + err;
+		                           error(errorMsg);
+		                           TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+		                       }
+		},
+
+		connectionCreatedHandler: function(sessionId, connectionObjects, reason) {
+			debug("TB.connectionCreated");
+			try {
+				var session = this.sessions[sessionId];
+
+				var connections = getConnections(connectionObjects);
+				session.dispatchEvent(new ConnectionEvent(this.CONNECTION_CREATED, connections, reason));
+			} catch(err) {
+				var errorMsg = "TB.connectionCreated :: "+err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		connectionDestroyedHandler: function(sessionId, connectionObjects, reason) {
+			debug("TB.connectionDestroyed");
+			try {
+				var session = this.sessions[sessionId];
+
+				var connections = getConnections(connectionObjects);
+
+				session.dispatchEvent(new ConnectionEvent(this.CONNECTION_DESTROYED, connections, reason));
+			} catch(err) {
+				var errorMsg = "TB.connectionDestroyed :: "+err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		signalHandler: function(sessionId, fromId) {
+			debug("TB.signal");
+			try {
+				var session = this.sessions[sessionId];
+
+				session.dispatchEvent(new SignalEvent(this.SIGNAL_RECEIVED, getConnectionFromConnectionId(fromId)));
+			} catch(err) {
+				var errorMsg = "TB.signal ::"+err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		archiveCreatedHandler: function(sessionId, archive) {
+			debug("TB.archiveCreatedHandler:" + sessionId + " - " + archive);
+			try {
+				var session = this.sessions[sessionId];
+				var newArchive = getArchive(archive, sessionId);
+				session.dispatchEvent(new ArchiveEvent(this.ARCHIVE_CREATED, [newArchive]));
+			} catch(err) {
+				var errorMsg = "TB.archiveCreatedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		archiveClosedHandler: function(sessionId, archive) {
+			debug("TB.archiveClosedHandler:" + sessionId + " - " + archive.id);
+			try {
+				var session = this.sessions[sessionId];
+				session.dispatchEvent(new ArchiveEvent(this.ARCHIVE_CLOSED, [createdArchives[sessionId][archive.id]]));
+				delete createdArchives[sessionId][archive.id];
+			} catch(err) {
+				var errorMsg = "TB.archiveClosedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		archiveLoadedHandler: function(sessionId, archive) {
+			debug("TB.archiveLoadedHandler:" + sessionId + " - " + archive.archiveId);
+			try {
+				var session = this.sessions[sessionId];
+				var newArchive = new Archive(archive.id, archive.type, archive.title, sessionId);
+				if (!loadedArchives.hasOwnProperty(sessionId)) loadedArchives[sessionId] = {};
+				loadedArchives[sessionId][archive.id] = newArchive;
+				session.dispatchEvent(new ArchiveEvent(this.ARCHIVE_LOADED, [newArchive]));
+			} catch(err) {
+				var errorMsg = "TB.archiveLoadedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		sessionRecordingStartedHandler: function(sessionId, archive) {
+			debug("TB.sessionRecordingStartedHandler:" + sessionId + " - " + archive.id);
+			try {
+				var session = this.sessions[sessionId];
+				session.dispatchEvent(new ArchiveEvent(this.SESSION_RECORDING_STARTED, [createdArchives[archive.id]]));
+			} catch(err) {
+				var errorMsg = "TB.sessionRecordingStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		sessionRecordingStoppedHandler: function(sessionId, archive) {
+			debug("TB.sessionRecordingStoppedHandler:" + sessionId + " - " + archive);
+			try {
+				var session = this.sessions[sessionId];
+				session.dispatchEvent(new ArchiveEvent(this.SESSION_RECORDING_STOPPED, [createdArchives[archive.id]]));
+				
+				for (var pub in session.publishers) {
+					if (session.publishers[pub].hasOwnProperty("id")) {
+						var publisher = document.getElementById(session.publishers[pub].id);
+						publisher.signalRecordingStopped();
+					}
+				};
+			} catch(err) {
+				var errorMsg = "TB.sessionRecordingStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		sessionRecordingInProgressHandler: function(sessionId) {
+			debug("TB.sessionRecordingInProgressHandler");
+			try {
+				var session = this.sessions[sessionId];
+				session.dispatchEvent(new Event(this.SESSION_RECORDING_IN_PROGRESS, false));
+			} catch(err) {
+				var errorMsg = "TB.sessionRecordingStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		sessionNotRecordingHandler: function(sessionId) {
+			debug("TB.sessionNotRecordingHandler");
+			try {
+				var session = this.sessions[sessionId];
+				session.dispatchEvent(new Event(this.SESSION_NOT_RECORDING, false));
+			} catch(err) {
+				var errorMsg = "TB.sessionNotRecordingHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		streamRecordingStartedHandler: function(sessionId, streamObjects) {
+			debug("TB.streamRecordingStartedHandler:" + sessionId);
+			try {
+				var session = this.sessions[sessionId];
+				var streams = getStreams(streamObjects, sessionId);
+				session.dispatchEvent(new StreamEvent(this.STREAM_RECORDING_STARTED, streams, "", false));
+				
+				for (var pub in session.publishers) {
+					if (session.publishers[pub].hasOwnProperty("id")) {
+						var publisher = document.getElementById(session.publishers[pub].id);
+						for (var i=0; i < streamObjects.length; i++) {
+							if (publisher.getStreamId() == streamObjects[i].streamId) {
+								publisher.signalRecordingStarted();
+								debug("TB.streamRecordingStartedHandler: signal: " + streamObjects[i].streamId);
+								break;
+							}
+						};
+					}			
+				};
+			} catch(err) {
+				var errorMsg = "TB.streamRecordingStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		streamRecordingStoppedHandler: function(sessionId, streamObjects) {
+			debug("TB.streamRecordingStoppedHandler");
+			try {
+				var session = this.sessions[sessionId];
+				var streams = getStreams(streamObjects, sessionId);
+				session.dispatchEvent(new StreamEvent(this.STREAM_RECORDING_STOPPED, streams, "", false));
+				
+				for (var pub in session.publishers) {
+					if (session.publishers[pub].hasOwnProperty("id")) {
+						var publisher = document.getElementById(session.publishers[pub].id);
+						
+						for (var i=0; i < streamObjects.length; i++) {
+							if (publisher.getStreamId() == streamObjects[i].streamId) {
+								publisher.signalRecordingStopped();
+								debug("TB.streamRecordingStoppedHandler: signal: " + streamObjects[i].streamId);
+								break;
+							}
+						}
+					}			
+				};
+			} catch(err) {
+				var errorMsg = "TB.streamRecordingStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		streamRecordingInProgressHandler: function(sessionId, streamObjects) {
+			debug("TB.streamRecordingInProgressHandler");
+			try {
+				var session = this.sessions[sessionId];
+				var streams = getStreams(streamObjects, sessionId);
+				session.dispatchEvent(new StreamEvent(this.STREAM_RECORDING_IN_PROGRESS, streams, "", false));
+			} catch(err) {
+				var errorMsg = "TB.streamRecordingInProgressHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		playbackStartedHandler: function(sessionId, archive) {
+			debug("TB.playbackStartedHandler");
+			try {
+				var session = this.sessions[sessionId];
+				archiveObj = new Archive(archive.id, archive.type, archive.title, sessionId);
+				session.dispatchEvent(new ArchiveEvent(this.PLAYBACK_STARTED, [archiveObj]));
+			} catch(err) {
+				var errorMsg = "TB.playbackStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		playbackStoppedHandler: function(sessionId, archive) {
+			debug("TB.playbackStoppedHandler");
+			try {
+				var session = this.sessions[sessionId];
+				archiveObj = new Archive(archive.id, archive.type, archive.title, sessionId);
+				session.dispatchEvent(new ArchiveEvent(this.PLAYBACK_STOPPED, [archiveObj]));
+			} catch(err) {
+				var errorMsg = "TB.playbackStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// Group callbacks
+		groupPropertiesUpdatedHandler: function(sessionId, groupObject) {
+			debug("TB.groupPropertiesUpdated");
+			try {
+				var group = this.groups[sessionId + "_" + groupObject.groupId];
+                if(!group) {
+                    error("TB.groupPropertiesUpdated :: Invalid group ID: " + sessionId + "_" + groupObject.groupId);
+                    return;
+                }
+
+    			group.dispatchEvent(new Event(this.GROUP_PROPERTIES_UPDATED));
+			} catch(err) {
+				var errorMsg ="TB.groupPropertiesUpdated :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// Publisher or Subscriber callbacks
+		
+		//publisher callbacks:
+		
+		videoComponentLoadedHandler: function(sessionId, componentId) {
+			try {
+				if (sessionId) {
+					var session = this.sessions[sessionId];
+	    			if(!session) return;
+
+					var publisher = session.publishers[componentId];
+					var subscriber = session.subscribers[componentId];
+
+					if (publisher && !publisher.loaded) {
+						publisher.loaded = true;
+						if (publisher.modified) {
+							if (publisher.audioPublished != null) publisher.publishAudio(publisher.audioPublished);
+							if (publisher.videoPublished != null) publisher.publishVideo(publisher.videoPublished);
+							publisher.setMicrophoneGain(publisher.gain);
+							publisher.setStyle(publisher._style);
+							publisher.modified = false;
+						}
+						publisher.dispatchEvent(new Event("loaded"));
+					}
+
+					if (subscriber && !subscriber.loaded) {
+						subscriber.loaded = true;
+						if (subscriber.modified) {
+							if (subscriber.audioSubscribed != null) subscriber.subscribeToAudio(subscriber.audioSubscribed);
+							if (subscriber.videoSubscribed != null) subscriber.subscribeToVideo(subscriber.videoSubscribed);
+							subscriber.setAudioVolume(subscriber.audioVolume);
+							subscriber.setStyle(subscriber._style);
+							subscriber.modified = false;
+						}
+						subscriber.dispatchEvent(new Event("loaded"));
+					}
+				} else {
+					var player = recorderManager.players[componentId];
+					if (player && player._archiveId) { 
+						player.loadArchive(player._archiveId);
+						player._archiveId = null;
+					}
+					
+					if (player && player._play) { 
+						player.play();
+						player._play = false;
+					}
+
+					var recorder = recorderManager.recorders[componentId];
+					var component = player ? player : recorder;
+					if (component && !component.loaded) {
+						component.loaded = true;
+						if (component.modified) {
+							component.setStyle(component._style);
+							if (component == recorder && component._title) {
+								component.setTitle(_title);
+								_title = "";
+							}
+							component.modified = false;
+						}
+						component.dispatchEvent(new Event("loaded"));
+					}
+					
+				}
+			} catch (err) {
+				var errorMsg = "videoComponentLoaded:: initialize component " + componentId + " - " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// Used in resizing the publisher
+		pubWidgetStyleHeightFrom: null,
+		pubWidgetStyleWidthFrom: null,
+
+		// Publisher callbacks
+		resizePublisherToTarget: function(sessionId, publisherId) {
+			debug("TB.resize");
+			try {
+				var session = this.sessions[sessionId];
+				if (!session) {
+					var errorMsg = "TB.resize :: Invalid session ID: " + sessionId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var publisher = session.publishers[publisherId];
+				if (!publisher) {
+					errorMsg = "TB.resize :: Invalid publisher ID: " + publisherId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var pubWidget = document.getElementById(publisherId);
+				if (!pubWidget) {
+					errorMsg = "TB.resize :: Publisher " + publisherId + " does not exist in the DOM";
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var widthFrom = pubWidget.width;
+				var heightFrom = pubWidget.height;
+
+				if (pubWidget.width != publisher.properties.width) {
+					pubWidget.width = publisher.properties.width;
+				}
+
+				if (pubWidget.height != publisher.properties.height) {
+					pubWidget.height = publisher.properties.height;
+				}
+				if (pubWidget.style.height != pubWidgetStyleHeightFrom) {
+					pubWidget.style.height = pubWidgetStyleHeightFrom;
+				}
+
+				if (pubWidget.style.width != pubWidgetStyleWidthFrom) {
+					pubWidget.style.width = pubWidgetStyleWidthFrom;
+				}
+
+				var widthTo = pubWidget.width;
+				var heightTo = pubWidget.height;
+
+				if (widthFrom != widthTo || heightFrom != heightTo) {
+					// Only dispatch the resize event if we did resize
+					publisher.dispatchEvent(new ResizeEvent(this.RESIZE, widthFrom, widthTo, heightFrom, heightTo));
+				}
+			} catch(err) {
+				errorMsg = "resizePublisherToTarget :: Error resizing publisher - " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+
+		resizePublisherToShowSecurity: function(sessionId, publisherId, scaleFactor){
+			debug("TB.resize");
+			var session = this.sessions[sessionId];
+			if (!session) {
+				var errorMsg = "TB.resize :: Invalid session ID: " + sessionId;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				return;
+			}
+
+			var publisher = session.publishers[publisherId];
+			if (!publisher) {
+				errorMsg = "TB.resize :: Invalid publisher ID: " + publisherId;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				return;
+			}
+
+			var pubWidget = document.getElementById(publisherId);
+			if (!pubWidget) {
+				errorMsg = "TB.resize :: Publisher " + publisherId + " does not exist in the DOM";
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				return;
+			}
+
+			var widthFrom = publisher.properties.width = pubWidget.width;
+			var heightFrom = publisher.properties.height = pubWidget.height;
+
+			pubWidgetStyleHeightFrom = pubWidget.style.height;
+			pubWidgetStyleWidthFrom = pubWidget.style.width;
+
+			// The scaleFactor takes browser zoom into account
+			var minWidth = MIN_ADOBE_WIDTH * scaleFactor;
+			var minHeight = MIN_ADOBE_HEIGHT * scaleFactor;
+
+			if (pubWidget.width < minWidth) {
+				pubWidget.width = minWidth;
+				pubWidget.style.width = minWidth + "px";
+			}
+			if (pubWidget.height < minHeight) {
+				pubWidget.height = minHeight;
+				pubWidget.style.height = minHeight + "px";
+			}
+
+			var widthTo = pubWidget.width;
+			var heightTo = pubWidget.height;
+			var styleTo = pubWidget.style;
+
+			if (widthFrom != widthTo || heightFrom != heightTo || pubWidgetStyleWidthFrom != styleTo.width || pubWidgetStyleHeightFrom != styleTo.height) {
+				// Only dispatch the resize event if we did resize
+				publisher.dispatchEvent(new ResizeEvent(this.RESIZE, widthFrom, widthTo, heightFrom, heightTo));
+			}
+
+		},
+
+		settingsButtonClickHandler: function(sessionId, publisherId) {
+			debug("TB.settingsButtonClick");
+			try {
+				var session = this.sessions[sessionId];
+				if(!session) {
+					var errorMsg = "TB.settingsButtonClick :: Invalid session ID: "+sessionId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var publisher = session.publishers[publisherId];
+				if(!publisher) {
+					errorMsg = "TB.settingsButtonClick :: Invalid publisher ID: "+publisherId;
+                    error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+                    return;
+                }
+
+				var event = new Event(this.SETTINGS_BUTTON_CLICK, true);
+				publisher.dispatchEvent(event);
+
+				var defaultAction = function() {
+					if (!event.isDefaultPrevented()) {
+						var dm = TB.initDeviceManager(session.apiKey);
+						dm.displayPanel(null, publisher, {});
+					}
+				};
+
+				// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+				setTimeout(defaultAction, 2);
+			} catch(err){
+				errorMsg = "settingsButtonClick :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+		
+		
+		
+		recorderSettingsButtonClickHandler: function(recorderId) {
+			debug("TB.recorderSettingsButtonClick");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				if(!recorder) {
+					errorMsg = "TB.recorderSettingsButtonClick :: Invalid recorder ID: "+recorderId;
+                    error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+                    return;
+                }
+
+				var event = new Event(this.SETTINGS_BUTTON_CLICK, true);
+				recorder.dispatchEvent(event);
+
+				var defaultAction = function() {
+					if (!event.isDefaultPrevented()) {
+						var dm = TB.initDeviceManager(recorderManager.apiKey);
+						dm.displayPanel(null, recorder, {});
+					}
+				};
+
+				// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+				setTimeout(defaultAction, 2);
+			} catch(err){
+				errorMsg = "recorderSettingsButtonClick :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		deviceAccessHandler: function(sessionId, publisherId, type) {
+			debug("TB.deviceAccessHandler: " + type);
+			try {
+				var session = this.sessions[sessionId];
+				if (!session) {
+					var errorMsg = "TB.deviceAccessHandler :: Invalid session ID: " + sessionId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var publisher = session.publishers[publisherId];
+				if (!publisher) {
+					errorMsg = "TB.deviceAccessHandler :: Invalid publisher ID: " + publisherId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var event = new Event(type, true);
+				publisher.dispatchEvent(event);
+
+				if (type == TB.ACCESS_DENIED) {
+					var defaultAction = function() {
+						var publisherElement = document.getElementById(publisher.id);
+						if (publisherElement) {
+							var parentNode = publisherElement.parentNode;						
+							session.unpublish(publisher);
+						
+							var replaceElement = document.createElement("div");
+							replaceElement.setAttribute("id", publisher.replacedDivId);
+							parentNode.appendChild(replaceElement);
+						
+							session._embedPublisher(publisher);
+						}
+					};
+
+					// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+					setTimeout(defaultAction, 2);
+				}
+			} catch(err) {
+				errorMsg = type + " :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		deviceInactiveHandler: function(sessionId, publisherId, camera, microphone){
+			debug("TB.deviceInactiveHandler");
+
+			try {
+				var session = this.sessions[sessionId];
+
+				if (!session) {
+					var errorMsg = "TB.deviceInactiveHandler :: Invalid session ID: " + sessionId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var publisher = session.publishers[publisherId];
+
+				if (!publisher) {
+					error("TB.deviceInactiveHandler :: Invalid publisher ID: " + publisherId);
+					return;
+				}
+
+				var event = new DeviceEvent(this.DEVICE_INACTIVE, camera, microphone);
+				publisher.dispatchEvent(event);
+			} catch (err) {
+				errorMsg = "deviceInactive :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+		
+		echoCancellationModeChangedHandler: function(sessionId, publisherId, camera, microphone){
+			debug("TB.echoCancellationModeChangedHandler");
+
+			try {
+				var session = this.sessions[sessionId];
+
+				if (!session) {
+					var errorMsg = "TB.echoCancellationModeChangedHandler :: Invalid session ID: " + sessionId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+					return;
+				}
+
+				var publisher = session.publishers[publisherId];
+
+				if (!publisher) {
+					error("TB.echoCancellationModeChangedHandler :: Invalid publisher ID: " + publisherId);
+					return;
+				}
+
+				var event = new DeviceEvent(this.ECHO_CANCELLATION_MODE_CHANGED, camera, microphone);
+				publisher.dispatchEvent(event);
+			} catch (err) {
+				errorMsg = "echoCancellationModeChanged :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// DeviceManager callbacks
+		devicesDetectedHandler: function(cameraObjects, microphoneObjects, selectedCameraIndex, selectedMicrophoneIndex) {
+			debug("TB.devicesDetected");
+			try {
+				var cameras = getCameras(cameraObjects);
+				var microphones = getMicrophones(microphoneObjects);
+
+				deviceManager.dispatchEvent(new DeviceStatusEvent(this.DEVICES_DETECTED, cameras, microphones, cameras[selectedCameraIndex], microphones[selectedMicrophoneIndex]));
+				setTimeout(function() { removeSWF(deviceDetectorId, "devicesDetectedHandler :: "); deviceDetectorId = null; }, 0); // must be asynchronous
+			} catch(err) {
+				var errorMsg = "devicesDetectedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// DevicePanel callbacks
+		devicesSelectedHandler: function(devicePanelId, camera, microphone) {
+			debug("TB.devicesSelected");
+			try {
+				cameraSelected = true;
+				var devicePanel = deviceManager.panels[devicePanelId];
+				if(!devicePanel) {
+				    error("TB.devicesSelected :: Invalid DevicePanel ID: "+devicePanelId);
+				    return;
+				}
+
+				if (devicePanel.component) {
+					devicePanel.component.setCamera(camera);
+					devicePanel.component.setMicrophone(microphone);
+				}
+
+				devicePanel.dispatchEvent(new DeviceEvent(this.DEVICES_SELECTED, camera, microphone));
+			} catch(err){
+				var errorMsg = "devicesSelected :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		closeButtonClickHandler: function(devicePanelId) {
+			debug("TB.closeButtonClick");
+			try {
+				var devicePanel = deviceManager.panels[devicePanelId];
+				if(!devicePanel) {
+					var errorMsg = "TB.devicesSelected :: Invalid DevicePanel ID: "+devicePanelId;
+					error(errorMsg);
+					TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				    return;
+				}
+
+				var event = new Event(this.CLOSE_BUTTON_CLICK, true);
+				devicePanel.dispatchEvent(event);
+
+				var defaultAction = function() {
+					if (!event.isDefaultPrevented()) {
+						deviceManager.removePanel(devicePanel);
+					}
+				};
+
+				// The event handler is called asynchronously after 1 millisecond. The default action happens after that.
+				setTimeout(defaultAction, 2);
+			} catch(err) {
+				errorMsg = "closeButtonClick :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// Player callbacks
+		playerArchiveLoadedHandler: function(playerId) {
+			debug("Player.archiveLoadedHandler");
+			try {
+				var player = recorderManager.players[playerId];
+				player.dispatchEvent(new Event(this.ARCHIVE_LOADED));
+			} catch(err) {
+				var errorMsg = "Player.archiveLoadedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		playingStartedHandler: function(playerId) {
+			debug("Player.playingHandler");
+			try {
+				var player = recorderManager.players[playerId];
+				player.dispatchEvent(new Event(this.PLAYBACK_STARTED));
+			} catch(err) {
+				var errorMsg = "Player.playingStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		playingStoppedHandler: function(playerId, archive) {
+			debug("Player.playingStoppedHandler");
+			try {
+				var player = recorderManager.players[playerId];
+				player.dispatchEvent(new Event(this.PLAYBACK_STOPPED));
+			} catch(err) {
+				var errorMsg = "Player.playingStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		// Recorder callbacks
+		recordingStartedHandler: function(recorderId) {
+			debug("Recorder.recordingStartedHandler");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				recorder.dispatchEvent(new Event(this.RECORDING_STARTED));
+			} catch(err) {
+				var errorMsg = "Recorder.recordingStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		recordingStoppedHandler: function(recorderId) {
+			debug("Recorder.recordingStoppedHandler");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				recorder.dispatchEvent(new Event(this.RECORDING_STOPPED));
+			} catch(err) {
+				var errorMsg = "Recorder.recordingStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		recorderPlaybackStartedHandler: function(recorderId) {
+			debug("Recorder.playbackStartedddHandler");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				recorder.dispatchEvent(new Event(this.PLAYBACK_STARTED));
+			} catch(err) {
+				var errorMsg = "Recorder.playbackStartedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		recorderPlaybackStoppedHandler: function(recorderId) {
+			debug("Recorder.playbackStoppedHandler");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				recorder.dispatchEvent(new Event(this.PLAYBACK_STOPPED));
+			} catch(err) {
+				var errorMsg = "Recorder.playbackStoppedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+
+		archiveSavedHandler: function(recorderId, archive) {
+			debug("Recorder.archiveSavedHandler");
+			try {
+				var recorder = recorderManager.recorders[recorderId];
+				var newArchive = new Archive(archive.id, archive.type, archive.title);
+				recorder.dispatchEvent(new ArchiveEvent(this.ARCHIVE_SAVED, [newArchive]));
+			} catch(err) {
+				var errorMsg = "Recorder.archiveSavedHandler :: " + err;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+			}
+		},
+		
+		stateChangedHandler: function(sessionId, values) {
+		    debug("TB.stateChangeHandler");
+		    var session = this.sessions[sessionId];
+			if(!session) {
+				var errorMsg = "TB.stateChangedHandler :: Invalid session ID: "+sessionId;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				return;
+			}
+
+			function getStateMgrForKey(key) {
+				key = key.replace(/"/g, "");
+				var match = key.match(/TB_archive_([^_]+)_(.*)/);
+				if (match) {
+					archiveId = match[1];
+					key = match[2];
+					var archive = loadedArchives[sessionId][archiveId];
+					if (!archive) {
+						var errorMsg = "Archive.startPlayback :: Archive not loaded.";
+						error(errorMsg);
+						TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+						return;
+					}
+
+					return archive.getStateManager();
+				}
+
+				return session.getStateManager();
+			}
+
+			var changedEventDispatched = false;
+			for (var key in values) {
+				var stateMgr = getStateMgrForKey(key);
+
+				if (!changedEventDispatched) {
+					stateMgr.dispatchEvent(new StateChangedEvent("changed", values));
+					changedEventDispatched = true;
+				}
+
+				var changedValues = {};
+				changedValues[key] = values[key];
+
+				stateMgr.dispatchEvent(new StateChangedEvent("changed:" + key, changedValues));
+			}
+			
+			if (!changedEventDispatched) {
+			    session.getStateManager().dispatchEvent(new StateChangedEvent("changed", values));
+			}
+		},
+
+		stateChangedFailedHandler: function(sessionId, reasonCode, reason, failedValues){
+            debug("TB.stateChangedFailedHandler");
+		    var session = this.sessions[sessionId];
+			if(!session) {
+				var errorMsg = "TB.stateChangedFailedHandler :: Invalid session ID: "+sessionId;
+				error(errorMsg);
+				TB.exceptionHandler(errorMsg, "Internal Error", 2000);
+				return;
+			}
+			
+			var stateMgr = session.getStateManager();
+			stateMgr.dispatchEvent(new ChangeFailedEvent("changeFailed", reasonCode, reason, failedValues));
+		},
+
+		reportIssueHandler: function(issueId, showReport){
+			debug("TB.reportIssue");
+
+			if (showReport == null) showReport = false;
+			if (showingIssueForm) return;
+
+			// Setup form
+			var form = document.createElement("form");
+			form.setAttribute("action", "http://staging.tokbox.com/reportIssue.php");
+			form.setAttribute("method", "post");
+			form.setAttribute("target", "formresult");
+
+			createHiddenElement(form, "issueId", issueId);
+
+			// Add client info
+			createHiddenElement(form, "userAgent", navigator.userAgent);
+			createHiddenElement(form, "environment", "JS");
+			var playerVersion = swfobject.getFlashPlayerVersion();
+			createHiddenElement(form, "flashVersion", playerVersion.major + "." + playerVersion.minor + "." + playerVersion.release);
+
+			// Add JS Logs
+			var jsLogs = window.opentokdebug.getLogs();
+			createHiddenElement(form, "jsLogs", jsLogs);
+
+			var addedAPIKey = false;
+
+			var sessionCount = 0;
+			for (var i in TB.sessions) {
+				var session = TB.sessions[i];
+				if (!session.hasOwnProperty("sessionId")) {
+					continue;
+				}
+				if (!addedAPIKey) {
+					createHiddenElement(form, "apiKey", session.apiKey);
+					addedAPIKey = true;
+				}
+				var widgetCount = 0;
+
+				createHiddenElement(form, "session_" + ++sessionCount, session.sessionId);
+				// Add controller logs
+				var controllerId = "controller_" + session.sessionId;
+				var controllerLogs = getDataForUIComponent(controllerId);
+
+				// This may be undefined if a session was initialized but never connected
+				if(controllerLogs)
+                    createHiddenElement(form, "widget_" + session.sessionId + "_" + ++widgetCount, controllerLogs);
+
+				// Add subscriber logs
+				if (session.hasOwnProperty("subscribers")) {
+					for (var subscriber in session.subscribers) {
+						if (session.subscribers[subscriber].hasOwnProperty("id")) {
+							var subscriberLogs = getDataForUIComponent(session.subscribers[subscriber].id);
+							createHiddenElement(form, "widget_" + session.sessionId + "_" + ++widgetCount, subscriberLogs);
+						}
+					}
+				}
+
+				// Add publisher logs
+				if (session.hasOwnProperty("publishers")) {
+					var publisherCount = 0;
+					for (var publisher in session.publishers) {
+						if (session.publishers[publisher].hasOwnProperty("id")) {
+							var publisherLogs = getDataForUIComponent(session.publishers[publisher].id);
+							createHiddenElement(form, "widget_" + session.sessionId + "_" + ++widgetCount, publisherLogs);
+						}
+					}
+				}
+			}
+
+			if (!showReport) {
+				var textField = document.createElement("textarea");
+				textField.setAttribute("name", "description");
+				textField.setAttribute("rows", 8);
+				textField.setAttribute("cols", 40);
+				textField.style.height = "110px";
+				textField.style.width = "300px";
+				textField.style.display = "block";
+				textField.style.visibility = "visible";
+				form.appendChild(textField);
+
+				var submitBtn = document.createElement("input");
+				submitBtn.setAttribute("type", "submit");
+				submitBtn.setAttribute("value", "Report Issue");
+				submitBtn.style.display = "inline";
+				submitBtn.style.visibility = "visible";
+				form.appendChild(submitBtn);
+
+				var cancelBtn = document.createElement("input");
+				cancelBtn.setAttribute("type", "button");
+				cancelBtn.setAttribute("value", "Cancel");
+				cancelBtn.style.display = "inline";
+				cancelBtn.style.visibility = "visible";
+				form.appendChild(cancelBtn);
+
+				var width = 390;
+				var height = 242;
+				var div = document.createElement("div");
+				div.setAttribute('id', 'opentokReportIssue');
+				div.style.position = "absolute";
+				div.style.top = "25%";
+				div.style.left = "50%";
+				div.style.width = width + "px";
+				div.style.height = height + "px";
+				div.style.marginLeft = (0 - width/2) + "px";
+				div.style.marginTop = (0 - height/4) + "px";
+				div.style.paddingLeft = "32px";
+				div.style.paddingRight = "15px";
+				div.style.paddingTop = "15px";
+				div.style.display = "block";
+				div.style.visibility = "visible";
+				div.style.lineHeight = "15px";
+				div.style.zIndex = highZ() + 1;
+
+				div.innerHTML = "<span style=\"color:#4c4c4c;font-size:18px;display:inline;visibility:visible;\">We're sorry to hear that something went wrong.</span><br/><br/>Please help us to debug your issue by providing a description of what happened.";
+				div.style.backgroundColor = "#F7F7F7";
+				div.style.border = "1px solid #CCC";
+				div.style.fontWeight = "normal";
+				div.style.fontFamily = "'Lucida Grande', 'Trebuchet MS', sans-serif";
+				div.style.color = "#4c4c4c";
+				div.style.fontSize = "13px";
+
+				div.appendChild(form);
+				document.body.appendChild(div);
+				
+                showingIssueForm = true;
+
+				closeForm = function() {
+					document.body.removeChild(div);
+					showingIssueForm = false;
+				};
+
+				cancelBtn.onclick = closeForm;
+			}
+
+			form.onsubmit = function() {
+				window.open('#', 'formresult', 'scrollbars=no,menubar=no,height=200,width=400,resizable=yes,toolbar=no,status=no');
+				setTimeout(function() {closeForm();}, 1000);
+			};
+			
+			if (showReport) {
+				createHiddenElement(form, "showReport", true);
+				document.body.appendChild(form);
+				
+				form.submit();
+			}
+		}
+
+	};
+}();
+/*!
+ *	SWFObject v2.2 <http://code.google.com/p/swfobject/> 
+ * 	is released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
+ * 	
+ * 	Permission is hereby granted, free of charge, to any person obtaining a copy
+ * 	of this software and associated documentation files (the "Software"), to deal
+ * 	in the Software without restriction, including without limitation the rights
+ * 	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * 	copies of the Software, and to permit persons to whom the Software is
+ * 	furnished to do so, subject to the following conditions:
+ * 	
+ * 	The above copyright notice and this permission notice shall be included in
+ * 	all copies or substantial portions of the Software
+ */
+var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;if(typeof t.plugins!=D&&typeof t.plugins[S]==r){ab=t.plugins[S].description;if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){T=true;X=false;ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0}}else{if(typeof O.ActiveXObject!=D){try{var ad=new ActiveXObject(W);if(ad){ab=ad.GetVariable("$version");if(ab){X=true;ab=ab.split(" ")[1].split(",");ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}}catch(Z){}}}return{w3:aa,pv:ag,wk:af,ie:X,win:ae,mac:ac}}(),k=function(){if(!M.w3){return}if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){f()}if(!J){if(typeof j.addEventListener!=D){j.addEventListener("DOMContentLoaded",f,false)}if(M.ie&&M.win){j.attachEvent(x,function(){if(j.readyState=="complete"){j.detachEvent(x,arguments.callee);f()}});if(O==top){(function(){if(J){return}try{j.documentElement.doScroll("left")}catch(X){setTimeout(arguments.callee,0);return}f()})()}}if(M.wk){(function(){if(J){return}if(!/loaded|complete/.test(j.readyState)){setTimeout(arguments.callee,0);return}f()})()}s(f)}}();function f(){if(J){return}try{var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));Z.parentNode.removeChild(Z)}catch(aa){return}J=true;var X=U.length;for(var Y=0;Y<X;Y++){U[Y]()}}function K(X){if(J){X()}else{U[U.length]=X}}function s(Y){if(typeof O.addEventListener!=D){O.addEventListener("load",Y,false)}else{if(typeof j.addEventListener!=D){j.addEventListener("load",Y,false)}else{if(typeof O.attachEvent!=D){i(O,"onload",Y)}else{if(typeof O.onload=="function"){var X=O.onload;O.onload=function(){X();Y()}}else{O.onload=Y}}}}}function h(){if(T){V()}else{H()}}function V(){var X=j.getElementsByTagName("body")[0];var aa=C(r);aa.setAttribute("type",q);var Z=X.appendChild(aa);if(Z){var Y=0;(function(){if(typeof Z.GetVariable!=D){var ab=Z.GetVariable("$version");if(ab){ab=ab.split(" ")[1].split(",");M.pv=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}else{if(Y<10){Y++;setTimeout(arguments.callee,10);return}}X.removeChild(aa);Z=null;H()})()}else{H()}}function H(){var ag=o.length;if(ag>0){for(var af=0;af<ag;af++){var Y=o[af].id;var ab=o[af].callbackFn;var aa={success:false,id:Y};if(M.pv[0]>0){var ae=c(Y);if(ae){if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){w(Y,true);if(ab){aa.success=true;aa.ref=z(Y);ab(aa)}}else{if(o[af].expressInstall&&A()){var ai={};ai.data=o[af].expressInstall;ai.width=ae.getAttribute("width")||"0";ai.height=ae.getAttribute("height")||"0";if(ae.getAttribute("class")){ai.styleclass=ae.getAttribute("class")}if(ae.getAttribute("align")){ai.align=ae.getAttribute("align")}var ah={};var X=ae.getElementsByTagName("param");var ac=X.length;for(var ad=0;ad<ac;ad++){if(X[ad].getAttribute("name").toLowerCase()!="movie"){ah[X[ad].getAttribute("name")]=X[ad].getAttribute("value")}}P(ai,ah,Y,ab)}else{p(ae);if(ab){ab(aa)}}}}}else{w(Y,true);if(ab){var Z=z(Y);if(Z&&typeof Z.SetVariable!=D){aa.success=true;aa.ref=Z}ab(aa)}}}}}function z(aa){var X=null;var Y=c(aa);if(Y&&Y.nodeName=="OBJECT"){if(typeof Y.SetVariable!=D){X=Y}else{var Z=Y.getElementsByTagName(r)[0];if(Z){X=Z}}}return X}function A(){return !a&&F("6.0.65")&&(M.win||M.mac)&&!(M.wk&&M.wk<312)}function P(aa,ab,X,Z){a=true;E=Z||null;B={success:false,id:X};var ae=c(X);if(ae){if(ae.nodeName=="OBJECT"){l=g(ae);Q=null}else{l=ae;Q=X}aa.id=R;if(typeof aa.width==D||(!/%$/.test(aa.width)&&parseInt(aa.width,10)<310)){aa.width="310"}if(typeof aa.height==D||(!/%$/.test(aa.height)&&parseInt(aa.height,10)<137)){aa.height="137"}j.title=j.title.slice(0,47)+" - Flash Player Installation";var ad=M.ie&&M.win?"ActiveX":"PlugIn",ac="MMredirectURL="+O.location.toString().replace(/&/g,"%26")+"&MMplayerType="+ad+"&MMdoctitle="+j.title;if(typeof ab.flashvars!=D){ab.flashvars+="&"+ac}else{ab.flashvars=ac}if(M.ie&&M.win&&ae.readyState!=4){var Y=C("div");X+="SWFObjectNew";Y.setAttribute("id",X);ae.parentNode.insertBefore(Y,ae);ae.style.display="none";(function(){if(ae.readyState==4){ae.parentNode.removeChild(ae)}else{setTimeout(arguments.callee,10)}})()}u(aa,ab,X)}}function p(Y){if(M.ie&&M.win&&Y.readyState!=4){var X=C("div");Y.parentNode.insertBefore(X,Y);X.parentNode.replaceChild(g(Y),X);Y.style.display="none";(function(){if(Y.readyState==4){Y.parentNode.removeChild(Y)}else{setTimeout(arguments.callee,10)}})()}else{Y.parentNode.replaceChild(g(Y),Y)}}function g(ab){var aa=C("div");if(M.win&&M.ie){aa.innerHTML=ab.innerHTML}else{var Y=ab.getElementsByTagName(r)[0];if(Y){var ad=Y.childNodes;if(ad){var X=ad.length;for(var Z=0;Z<X;Z++){if(!(ad[Z].nodeType==1&&ad[Z].nodeName=="PARAM")&&!(ad[Z].nodeType==8)){aa.appendChild(ad[Z].cloneNode(true))}}}}}return aa}function u(ai,ag,Y){var X,aa=c(Y);if(M.wk&&M.wk<312){return X}if(aa){if(typeof ai.id==D){ai.id=Y}if(M.ie&&M.win){var ah="";for(var ae in ai){if(ai[ae]!=Object.prototype[ae]){if(ae.toLowerCase()=="data"){ag.movie=ai[ae]}else{if(ae.toLowerCase()=="styleclass"){ah+=' class="'+ai[ae]+'"'}else{if(ae.toLowerCase()!="classid"){ah+=" "+ae+'="'+ai[ae]+'"'}}}}}var af="";for(var ad in ag){if(ag[ad]!=Object.prototype[ad]){af+='<param name="'+ad+'" value="'+ag[ad]+'" />'}}aa.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+ah+">"+af+"</object>";N[N.length]=ai.id;X=c(ai.id)}else{var Z=C(r);Z.setAttribute("type",q);for(var ac in ai){if(ai[ac]!=Object.prototype[ac]){if(ac.toLowerCase()=="styleclass"){Z.setAttribute("class",ai[ac])}else{if(ac.toLowerCase()!="classid"){Z.setAttribute(ac,ai[ac])}}}}for(var ab in ag){if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){e(Z,ab,ag[ab])}}aa.parentNode.replaceChild(Z,aa);X=Z}}return X}function e(Z,X,Y){var aa=C("param");aa.setAttribute("name",X);aa.setAttribute("value",Y);Z.appendChild(aa)}function y(Y){var X=c(Y);if(X&&X.nodeName=="OBJECT"){if(M.ie&&M.win){X.style.display="none";(function(){if(X.readyState==4){b(Y)}else{setTimeout(arguments.callee,10)}})()}else{X.parentNode.removeChild(X)}}}function b(Z){var Y=c(Z);if(Y){for(var X in Y){if(typeof Y[X]=="function"){Y[X]=null}}Y.parentNode.removeChild(Y)}}function c(Z){var X=null;try{X=j.getElementById(Z)}catch(Y){}return X}function C(X){return j.createElement(X)}function i(Z,X,Y){Z.attachEvent(X,Y);I[I.length]=[Z,X,Y]}function F(Z){var Y=M.pv,X=Z.split(".");X[0]=parseInt(X[0],10);X[1]=parseInt(X[1],10)||0;X[2]=parseInt(X[2],10)||0;return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false}function v(ac,Y,ad,ab){if(M.ie&&M.mac){return}var aa=j.getElementsByTagName("head")[0];if(!aa){return}var X=(ad&&typeof ad=="string")?ad:"screen";if(ab){n=null;G=null}if(!n||G!=X){var Z=C("style");Z.setAttribute("type","text/css");Z.setAttribute("media",X);n=aa.appendChild(Z);if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){n=j.styleSheets[j.styleSheets.length-1]}G=X}if(M.ie&&M.win){if(n&&typeof n.addRule==r){n.addRule(ac,Y)}}else{if(n&&typeof j.createTextNode!=D){n.appendChild(j.createTextNode(ac+" {"+Y+"}"))}}}function w(Z,X){if(!m){return}var Y=X?"visible":"hidden";if(J&&c(Z)){c(Z).style.visibility=Y}else{v("#"+Z,"visibility:"+Y)}}function L(Y){var Z=/[\\\"<>\.;]/;var X=Z.exec(Y)!=null;return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y}var d=function(){if(M.ie&&M.win){window.attachEvent("onunload",function(){var ac=I.length;for(var ab=0;ab<ac;ab++){I[ab][0].detachEvent(I[ab][1],I[ab][2])}var Z=N.length;for(var aa=0;aa<Z;aa++){y(N[aa])}for(var Y in M){M[Y]=null}M=null;for(var X in swfobject){swfobject[X]=null}swfobject=null})}}();return{registerObject:function(ab,X,aa,Z){if(M.w3&&ab&&X){var Y={};Y.id=ab;Y.swfVersion=X;Y.expressInstall=aa;Y.callbackFn=Z;o[o.length]=Y;w(ab,false)}else{if(Z){Z({success:false,id:ab})}}},getObjectById:function(X){if(M.w3){return z(X)}},embedSWF:function(ab,ah,ae,ag,Y,aa,Z,ad,af,ac){var X={success:false,id:ah};if(M.w3&&!(M.wk&&M.wk<312)&&ab&&ah&&ae&&ag&&Y){w(ah,false);K(function(){ae+="";ag+="";var aj={};if(af&&typeof af===r){for(var al in af){aj[al]=af[al]}}aj.data=ab;aj.width=ae;aj.height=ag;var am={};if(ad&&typeof ad===r){for(var ak in ad){am[ak]=ad[ak]}}if(Z&&typeof Z===r){for(var ai in Z){if(typeof am.flashvars!=D){am.flashvars+="&"+ai+"="+Z[ai]}else{am.flashvars=ai+"="+Z[ai]}}}if(F(Y)){var an=u(aj,am,ah);if(aj.id==ah){w(ah,true)}X.success=true;X.ref=an}else{if(aa&&A()){aj.data=aa;P(aj,am,ah,ac);return}else{w(ah,true)}}if(ac){ac(X)}})}else{if(ac){ac(X)}}},switchOffAutoHideShow:function(){m=false},ua:M,getFlashPlayerVersion:function(){return{major:M.pv[0],minor:M.pv[1],release:M.pv[2]}},hasFlashPlayerVersion:F,createSWF:function(Z,Y,X){if(M.w3){return u(Z,Y,X)}else{return undefined}},showExpressInstall:function(Z,aa,X,Y){if(M.w3&&A()){P(Z,aa,X,Y)}},removeSWF:function(X){if(M.w3){y(X)}},createCSS:function(aa,Z,Y,X){if(M.w3){v(aa,Z,Y,X)}},addDomLoadEvent:K,addLoadEvent:s,getQueryParamValue:function(aa){var Z=j.location.search||j.location.hash;if(Z){if(/\?/.test(Z)){Z=Z.split("?")[1]}if(aa==null){return L(Z)}var Y=Z.split("&");for(var X=0;X<Y.length;X++){if(Y[X].substring(0,Y[X].indexOf("="))==aa){return L(Y[X].substring((Y[X].indexOf("=")+1)))}}}return""},expressInstallCallback:function(){if(a){var X=c(R);if(X&&l){X.parentNode.replaceChild(l,X);if(Q){w(Q,true);if(M.ie&&M.win){l.style.display="block"}}if(E){E(B)}}a=false}}}}();/*!
+ * JavaScript Debug - v0.4 - 6/22/2010
+ * http://benalman.com/projects/javascript-debug-console-log/
+ *
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ */
+
+// Script: JavaScript Debug: A simple wrapper for console.log
+//
+// *Version: 0.4, Last Updated: 6/22/2010*
+//
+// Tested with Internet Explorer 6-8, Firefox 3-3.6, Safari 3-4, Chrome 3-5, Opera 9.6-10.5
+//
+// Home       - http://benalman.com/projects/javascript-debug-console-log/
+// GitHub     - http://github.com/cowboy/javascript-debug/
+// Source     - http://github.com/cowboy/javascript-debug/raw/master/ba-debug.js
+// (Minified) - http://github.com/cowboy/javascript-debug/raw/master/ba-debug.min.js (1.1kb)
+//
+// About: License
+//
+// Copyright (c) 2010 "Cowboy" Ben Alman,
+// Dual licensed under the MIT and GPL licenses.
+// http://benalman.com/about/license/
+//
+// About: Support and Testing
+//
+// Information about what browsers this code has been tested in.
+//
+// Browsers Tested - Internet Explorer 6-8, Firefox 3-3.6, Safari 3-4, Chrome
+// 3-5, Opera 9.6-10.5
+//
+// About: Examples
+//
+// These working examples, complete with fully commented code, illustrate a few
+// ways in which this plugin can be used.
+//
+// Examples - http://benalman.com/code/projects/javascript-debug/examples/debug/
+//
+// About: Revision History
+//
+// 0.4 - (6/22/2010) Added missing passthrough methods: exception,
+//       groupCollapsed, table
+// 0.3 - (6/8/2009) Initial release
+//
+// Topic: Pass-through console methods
+//
+// assert, clear, count, dir, dirxml, exception, group, groupCollapsed,
+// groupEnd, profile, profileEnd, table, time, timeEnd, trace
+//
+// These console methods are passed through (but only if both the console and
+// the method exists), so use them without fear of reprisal. Note that these
+// methods will not be passed through if the logging level is set to 0 via
+// <debug.setLevel>.
+
+window.opentokdebug = (function(){
+	var window = this,
+
+	// Some convenient shortcuts.
+	aps = Array.prototype.slice,
+		con = window.console,
+
+	// Public object to be returned.
+	that = {},
+
+	callback_func, callback_force,
+
+	// OpenTok has a default of no logging.
+	log_level = 0,
+
+	// Logging methods, in "priority order". Not all console implementations
+	// will utilize these, but they will be used in the callback passed to
+	// setCallback.
+	log_methods = ['error', 'warn', 'info', 'debug', 'log'],
+
+	// Pass these methods through to the console if they exist, otherwise just
+	// fail gracefully. These methods are provided for convenience.
+	pass_methods = 'assert clear count dir dirxml exception group groupCollapsed groupEnd profile profileEnd table time timeEnd trace'.split(' '),
+		idx = pass_methods.length,
+
+	// Logs are stored here so that they can be recalled as necessary.
+	logs = [];
+
+	while (--idx >= 0) {
+		(function(method) {
+
+			// Generate pass-through methods. These methods will be called, if they
+			// exist, as long as the logging level is non-zero.
+			that[method] = function() {
+				log_level !== 0 && con && con[method] && con[method].apply(con, arguments);
+			};
+
+		})(pass_methods[idx]);
+	}
+
+	idx = log_methods.length;
+	while (--idx >= 0) {
+		(function(idx, level) {
+
+			// Method: debug.log
+			//
+			// Call the console.log method if available. Adds an entry into the logs
+			// array for a callback specified via <debug.setCallback>.
+			//
+			// Usage:
+			//
+			//  debug.log( object [, object, ...] );                               - -
+			//
+			// Arguments:
+			//
+			//  object - (Object) Any valid JavaScript object.
+			// Method: debug.debug
+			//
+			// Call the console.debug method if available, otherwise call console.log.
+			// Adds an entry into the logs array for a callback specified via
+			// <debug.setCallback>.
+			//
+			// Usage:
+			//
+			//  debug.debug( object [, object, ...] );                             - -
+			//
+			// Arguments:
+			//
+			//  object - (Object) Any valid JavaScript object.
+			// Method: debug.info
+			//
+			// Call the console.info method if available, otherwise call console.log.
+			// Adds an entry into the logs array for a callback specified via
+			// <debug.setCallback>.
+			//
+			// Usage:
+			//
+			//  debug.info( object [, object, ...] );                              - -
+			//
+			// Arguments:
+			//
+			//  object - (Object) Any valid JavaScript object.
+			// Method: debug.warn
+			//
+			// Call the console.warn method if available, otherwise call console.log.
+			// Adds an entry into the logs array for a callback specified via
+			// <debug.setCallback>.
+			//
+			// Usage:
+			//
+			//  debug.warn( object [, object, ...] );                              - -
+			//
+			// Arguments:
+			//
+			//  object - (Object) Any valid JavaScript object.
+			// Method: debug.error
+			//
+			// Call the console.error method if available, otherwise call console.log.
+			// Adds an entry into the logs array for a callback specified via
+			// <debug.setCallback>.
+			//
+			// Usage:
+			//
+			//  debug.error( object [, object, ...] );                             - -
+			//
+			// Arguments:
+			//
+			//  object - (Object) Any valid JavaScript object.
+			that[level] = function() {
+				var args = aps.call(arguments),
+					log_arr = [level].concat(args);
+
+				logs.push(log_arr);
+
+				if (!con || !is_level(idx)) {
+					return;
+				}
+				exec_callback(log_arr); // OpenTok executes callback only if the proper level
+				// OpenTok - this is a fix for firebug 1.6.0 submitted by someone else. hopefully it'll get incorporated into
+				// the next official release and it can be removed.
+				(con.firebug || window.Firebug) ? con[level].apply(con, args) : con[level] ? con[level](args) : con.log(args);
+			};
+
+		})(idx, log_methods[idx]);
+	}
+
+	// Execute the callback function if set.
+	function exec_callback(args) {
+		if (callback_func && (callback_force || !con || !con.log)) {
+			callback_func.apply(window, args);
+		}
+	};
+
+	// Method: debug.setLevel
+	//
+	// Set a minimum or maximum logging level for the console. Doesn't affect
+	// the <debug.setCallback> callback function, but if set to 0 to disable
+	// logging, <Pass-through console methods> will be disabled as well.
+	//
+	// Usage:
+	//
+	//  debug.setLevel( [ level ] )                                            - -
+	//
+	// Arguments:
+	//
+	//  level - (Number) If 0, disables logging. If negative, shows N lowest
+	//    priority levels of log messages. If positive, shows N highest priority
+	//    levels of log messages.
+	//
+	// Priority levels:
+	//
+	//   log (1) < debug (2) < info (3) < warn (4) < error (5)
+	that.setLevel = function(level) {
+		log_level = typeof level === 'number' ? level : 9;
+	};
+
+	// Determine if the level is visible given the current log_level.
+	function is_level(level) {
+		return log_level > 0 ? log_level > level : log_methods.length + log_level <= level;
+	};
+
+	// Method: debug.setCallback
+	//
+	// Set a callback to be used if logging isn't possible due to console.log
+	// not existing. If unlogged logs exist when callback is set, they will all
+	// be logged immediately unless a limit is specified.
+	//
+	// Usage:
+	//
+	//  debug.setCallback( callback [, force ] [, limit ] )
+	//
+	// Arguments:
+	//
+	//  callback - (Function) The aforementioned callback function. The first
+	//    argument is the logging level, and all subsequent arguments are those
+	//    passed to the initial debug logging method.
+	//  force - (Boolean) If false, log to console.log if available, otherwise
+	//    callback. If true, log to both console.log and callback.
+	//  limit - (Number) If specified, number of lines to limit initial scrollback
+	//    to.
+	that.setCallback = function() {
+		var args = aps.call(arguments),
+			max = logs.length,
+			i = max;
+
+		callback_func = args.shift() || null;
+		callback_force = typeof args[0] === 'boolean' ? args.shift() : false;
+
+		i -= typeof args[0] === 'number' ? args.shift() : max;
+
+		while (i < max) {
+			exec_callback(logs[i++]);
+		}
+	};
+
+	that.getLogs = function() {
+		return logs.join('\n');
+	};
+
+	return that;
+})();// Add missing IE methods
+
+// This was taken from:
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) Object.keys = function(o) {
+	if (o !== Object(o)) throw new TypeError('Object.keys called on non-object');
+	var ret = [],
+		p;
+	for (p in o) {
+		if (Object.prototype.hasOwnProperty.call(o, p)) {
+			ret.push(p);
+		}
+	}
+	return ret;
+};
+
+// This was taken from:
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
+if (!Array.prototype.indexOf) {
+	Array.prototype.indexOf = function(searchElement) {
+		"use strict";
+		if (this === void 0 || this === null) {
+			throw new TypeError();
+		}
+		var t = Object(this);
+		var len = t.length >>> 0;
+		if (len === 0) {
+			return -1;
+		}
+		var n = 0;
+		if (arguments.length > 0) {
+			n = Number(arguments[1]);
+			if (n !== n) { // shortcut for verifying if it's NaN  
+				n = 0;
+			} else if (n !== 0 && n !== Infinity && n !== -Infinity) {
+				n = (n > 0 || -1) * Math.floor(Math.abs(n));
+			}
+		}
+		if (n >= len) {
+			return -1;
+		}
+		var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+		for (; k < len; k++) {
+			if (k in t && t[k] === searchElement) {
+				return k;
+			}
+		}
+		return -1;
+	};
+}