Merge branch 'feature/mob-506' into feature/heath-shades

PepperDashEssentials/AppServer/Messengers/AudioCodecBaseMessenger.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+using PepperDash.Essentials.Devices.Common.Codec;
+using PepperDash.Essentials.Devices.Common.AudioCodec;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+    /// <summary>
+    /// Provides a messaging bridge for an AudioCodecBase device
+    /// </summary>
+    public class AudioCodecBaseMessenger : MessengerBase
+    {
+        /// <summary>
+        /// Device being bridged
+        /// </summary>
+        public AudioCodecBase Codec { get; set; }
+
+        /// <summary>
+        /// Constuctor
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="codec"></param>
+        /// <param name="messagePath"></param>
+        public AudioCodecBaseMessenger(string key, AudioCodecBase codec, string messagePath)
+            : base(key, messagePath)
+        {
+            if (codec == null)
+                throw new ArgumentNullException("codec");
+
+            Codec = codec;
+            codec.CallStatusChange += new EventHandler<CodecCallStatusItemChangeEventArgs>(codec_CallStatusChange);
+
+        }
+
+        protected override void CustomRegisterWithAppServer(CotijaSystemController appServerController)
+        {
+            appServerController.AddAction(MessagePath + "/fullStatus", new Action(SendAtcFullMessageObject));
+            appServerController.AddAction(MessagePath + "/dial", new Action<string>(s => Codec.Dial(s)));
+            appServerController.AddAction(MessagePath + "/endCallById", new Action<string>(s =>
+            {
+                var call = GetCallWithId(s);
+                if (call != null)
+                    Codec.EndCall(call);
+            }));
+            appServerController.AddAction(MessagePath + "/endAllCalls", new Action(Codec.EndAllCalls));
+            appServerController.AddAction(MessagePath + "/dtmf", new Action<string>(s => Codec.SendDtmf(s)));
+            appServerController.AddAction(MessagePath + "/rejectById", new Action<string>(s =>
+            {
+                var call = GetCallWithId(s);
+                if (call != null)
+                    Codec.RejectCall(call);
+            }));
+            appServerController.AddAction(MessagePath + "/acceptById", new Action<string>(s =>
+            {
+                var call = GetCallWithId(s);
+                if (call != null)
+                    Codec.AcceptCall(call);
+            }));
+        }
+
+        /// <summary>
+        /// Helper to grab a call with string ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        CodecActiveCallItem GetCallWithId(string id)
+        {
+            return Codec.ActiveCalls.FirstOrDefault(c => c.Id == id);
+        }
+
+        void codec_CallStatusChange(object sender, CodecCallStatusItemChangeEventArgs e)
+        {
+            SendAtcFullMessageObject();
+        }
+
+        /// <summary>
+        /// Helper method to build call status for vtc
+        /// </summary>
+        /// <returns></returns>
+        void SendAtcFullMessageObject()
+        {
+
+            var info = Codec.CodecInfo;
+            PostStatusMessage(new
+            {
+                isInCall = Codec.IsInCall,
+                calls = Codec.ActiveCalls,
+                info = new
+                {
+                    phoneNumber = info.PhoneNumber
+                }
+            });
+        }
+    }
+}

PepperDashEssentials/AppServer/Messengers/Ddvc01AtcMessenger.cs

@@ -16,12 +16,33 @@ namespace PepperDash.Essentials.AppServer.Messengers
 	{
 		BasicTriList EISC;
 
+		/// <summary>
+		/// 221
+		/// </summary>
 		const uint BDialHangup = 221;
+		/// <summary>
+		/// 251
+		/// </summary>
 		const uint BIncomingAnswer = 251;
+		/// <summary>
+		/// 252
+		/// </summary>
 		const uint BIncomingReject = 252;
+		/// <summary>
+		/// 241
+		/// </summary>
 		const uint BSpeedDial1 = 241;
+		/// <summary>
+		/// 242
+		/// </summary>
 		const uint BSpeedDial2 = 242;
+		/// <summary>
+		/// 243
+		/// </summary>
 		const uint BSpeedDial3 = 243;
+		/// <summary>
+		/// 244
+		/// </summary>
 		const uint BSpeedDial4 = 244;
 
 		/// <summary>
@@ -31,14 +52,22 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// <summary>
 		/// 211
 		/// </summary>
-		const uint SCurrentCallString = 211;
+		const uint SCurrentCallNumber = 211;
+        /// <summary>
+        /// 212
+        /// </summary>
+        const uint SCurrentCallName = 212;
 		/// <summary>
 		/// 221
 		/// </summary>
 		const uint SHookState = 221;
+        /// <summary>
+        /// 222
+        /// </summary>
+        const uint SCallDirection = 222;
 
 		/// <summary>
-		/// 
+		/// 201-212 0-9*#
 		/// </summary>
 		Dictionary<string, uint> DTMFMap = new Dictionary<string, uint>
 		{
@@ -56,6 +85,9 @@ namespace PepperDash.Essentials.AppServer.Messengers
 			{ "#", 212 },
 		};
 
+		/// <summary>
+		/// 
+		/// </summary>
 		CodecActiveCallItem CurrentCallItem;
 
 
@@ -64,8 +96,8 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// </summary>
 		/// <param name="eisc"></param>
 		/// <param name="messagePath"></param>
-		public Ddvc01AtcMessenger(BasicTriList eisc, string messagePath)
+		public Ddvc01AtcMessenger(string key, BasicTriList eisc, string messagePath)
-			: base(messagePath)
+			: base(key, messagePath)
 		{
 			EISC = eisc;
 
@@ -79,12 +111,14 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// </summary>
 		void SendFullStatus()
 		{
+            
+
 			this.PostStatusMessage(new
 			{				
 				calls = GetCurrentCallList(),
-				callStatus = EISC.GetString(SHookState),
+				currentCallString = EISC.GetString(SCurrentCallNumber),
-				currentCallString = EISC.GetString(SCurrentCallString),
 				currentDialString = EISC.GetString(SCurrentDialString),
+                isInCall = EISC.GetString(SHookState) == "Connected"
 			});
 		}
 
@@ -94,31 +128,33 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// <param name="appServerController"></param>
 		protected override void CustomRegisterWithAppServer(CotijaSystemController appServerController)
 		{
-			Action<object> send = this.PostStatusMessage;
+            //EISC.SetStringSigAction(SCurrentDialString, s => PostStatusMessage(new { currentDialString = s }));
-			EISC.SetStringSigAction(SCurrentDialString, s => send(new { currentDialString = s }));
 
 			EISC.SetStringSigAction(SHookState, s => 
 			{
 				CurrentCallItem.Status = (eCodecCallStatus)Enum.Parse(typeof(eCodecCallStatus), s, true);
-				GetCurrentCallList();
+                //GetCurrentCallList();
-				send(new 
+				SendCallsList();
-				{ 
-					calls = GetCurrentCallList(),
-					callStatus = s 
-				});
 			});
 
-			EISC.SetStringSigAction(SCurrentCallString, s => 
+			EISC.SetStringSigAction(SCurrentCallNumber, s => 
 			{
-				CurrentCallItem.Name = s;
 				CurrentCallItem.Number = s;
-				send(new 
+                SendCallsList();
-				{
-					calls = GetCurrentCallList(),
-					currentCallString = s 			
-				});
 			});
 
+            EISC.SetStringSigAction(SCurrentCallName, s =>
+            {
+                CurrentCallItem.Name = s;
+                SendCallsList();
+            });
+
+            EISC.SetStringSigAction(SCallDirection, s =>
+            {
+                CurrentCallItem.Direction = (eCodecCallDirection)Enum.Parse(typeof(eCodecCallDirection), s, true);
+                SendCallsList();
+            });
+
 			// Add press and holds using helper
 			Action<string, uint> addPHAction = (s, u) => 
 				AppServerController.AddAction(MessagePath + s, new PressAndHoldAction(b => EISC.SetBool(u, b)));
@@ -126,9 +162,9 @@ namespace PepperDash.Essentials.AppServer.Messengers
 			// Add straight pulse calls
 			Action<string, uint> addAction = (s, u) =>
 				AppServerController.AddAction(MessagePath + s, new Action(() => EISC.PulseBool(u, 100)));
-			addAction("/endCall", BDialHangup);
+            addAction("/endCallById", BDialHangup);
-			addAction("/incomingAnswer", BIncomingAnswer);
+            addAction("/acceptById", BIncomingAnswer);
-			addAction("/incomingReject", BIncomingReject);
+            addAction("/rejectById", BIncomingReject);
 			addAction("/speedDial1", BSpeedDial1);
 			addAction("/speedDial2", BSpeedDial2);
 			addAction("/speedDial3", BSpeedDial3);
@@ -148,6 +184,17 @@ namespace PepperDash.Essentials.AppServer.Messengers
 			}));
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+        void SendCallsList()
+        {
+            PostStatusMessage(new
+            {
+                calls = GetCurrentCallList(),
+            });
+        }
+
 		/// <summary>
 		/// Turns the 
 		/// </summary>

PepperDashEssentials/AppServer/Messengers/Ddvc01VtcMessenger.cs

@@ -0,0 +1,604 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.EthernetCommunication;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Devices.Common.Codec;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+	public class Ddvc01VtcMessenger : MessengerBase
+	{
+		BasicTriList EISC;
+
+		/********* Bools *********/
+		/// <summary>
+		/// 724
+		/// </summary>
+		const uint BDialHangup = 724;
+		/// <summary>
+		/// 750
+		/// </summary>
+		const uint BCallIncoming = 750;
+		/// <summary>
+		/// 751
+		/// </summary>
+		const uint BIncomingAnswer = 751;
+		/// <summary>
+		/// 752
+		/// </summary>
+		const uint BIncomingReject = 752;
+		/// <summary>
+		/// 741
+		/// </summary>
+		const uint BSpeedDial1 = 741;
+		/// <summary>
+		/// 742
+		/// </summary>
+		const uint BSpeedDial2 = 742;
+		/// <summary>
+		/// 743
+		/// </summary>
+		const uint BSpeedDial3 = 743;
+		/// <summary>
+		/// 744
+		/// </summary>
+		const uint BSpeedDial4 = 744;
+		/// <summary>
+		/// 800
+		/// </summary>
+		const uint BDirectorySearchBusy = 800;
+		/// <summary>
+		/// 801 
+		/// </summary>
+		const uint BDirectoryLineSelected = 801;
+		/// <summary>
+		/// 801 when selected entry is a contact
+		/// </summary>
+		const uint BDirectoryEntryIsContact = 801;
+		/// <summary>
+		/// 802 To show/hide back button
+		/// </summary>
+		const uint BDirectoryIsRoot = 802;
+		/// <summary>
+		/// 803 Pulse from system to inform us when directory is ready
+		/// </summary>
+		const uint DDirectoryHasChanged = 803;
+		/// <summary>
+		/// 804
+		/// </summary>
+		const uint BDirectoryRoot = 804;
+		/// <summary>
+		/// 805
+		/// </summary>
+		const uint BDirectoryFolderBack = 805;
+		/// <summary>
+		/// 806
+		/// </summary>
+		const uint BDirectoryDialSelectedLine = 806;
+		/// <summary>
+		/// 811
+		/// </summary>
+		const uint BCameraControlUp = 811;
+		/// <summary>
+		/// 812
+		/// </summary>
+		const uint BCameraControlDown = 812;
+		/// <summary>
+		/// 813
+		/// </summary>
+		const uint BCameraControlLeft = 813;
+		/// <summary>
+		/// 814
+		/// </summary>
+		const uint BCameraControlRight = 814;
+		/// <summary>
+		/// 815
+		/// </summary>
+		const uint BCameraControlZoomIn = 815;
+		/// <summary>
+		/// 816
+		/// </summary>
+		const uint BCameraControlZoomOut = 816;
+		/// <summary>
+		/// 821 - 826
+		/// </summary>
+		const uint BCameraPresetStart = 821;
+
+		/// <summary>
+		/// 831
+		/// </summary>
+		const uint BCameraModeAuto = 831;
+		/// <summary>
+		/// 832
+		/// </summary>
+		const uint BCameraModeManual = 832;
+		/// <summary>
+		/// 833
+		/// </summary>
+		const uint BCameraModeOff = 833;
+
+
+
+		/********* Ushorts *********/
+		/// <summary>
+		/// 760
+		/// </summary>
+		const uint UCameraNumberSelect = 760;
+		/// <summary>
+		/// 801
+		/// </summary>
+		const uint UDirectorySelectRow = 801;
+		/// <summary>
+		/// 801
+		/// </summary>
+		const uint UDirectoryRowCount = 801;
+
+
+
+		/********* Strings *********/
+		/// <summary>
+		/// 701
+		/// </summary>
+		const uint SCurrentDialString = 701;
+		/// <summary>
+		/// 702
+		/// </summary>
+		const uint SCurrentCallName = 702;
+        /// <summary>
+		/// 703
+        /// </summary>
+		const uint SCurrentCallNumber = 703;
+		/// <summary>
+		/// 731
+		/// </summary>
+		const uint SHookState = 731;
+        /// <summary>
+		/// 722
+        /// </summary>
+        const uint SCallDirection = 722;
+		/// <summary>
+		/// 751
+		/// </summary>
+		const uint SIncomingCallName = 751;
+		/// <summary>
+		/// 752
+		/// </summary>
+		const uint SIncomingCallNumber = 752;
+
+		/// <summary>
+		/// 800
+		/// </summary>
+		const uint SDirectorySearchString = 800;
+		/// <summary>
+		/// 801-1055
+		/// </summary>
+		const uint SDirectoryEntriesStart = 801;
+		/// <summary>
+		/// 1056
+		/// </summary>
+		const uint SDirectoryEntrySelectedName = 1056;
+		/// <summary>
+		/// 1057
+		/// </summary>
+		const uint SDirectoryEntrySelectedNumber = 1057;
+		/// <summary>
+		/// 1058
+		/// </summary>
+		const uint SDirectorySelectedFolderName = 1058;
+
+
+		/// <summary>
+		/// 701-712 0-9*#
+		/// </summary>
+		Dictionary<string, uint> DTMFMap = new Dictionary<string, uint>
+		{
+			{ "1", 701 },
+			{ "2", 702 },
+			{ "3", 703 },
+			{ "4", 704 },
+			{ "5", 705 },
+			{ "6", 706 },
+			{ "7", 707 },
+			{ "8", 708 },
+			{ "9", 709 },
+			{ "0", 710 },
+			{ "*", 711 },
+			{ "#", 712 },
+		};
+
+		CodecActiveCallItem CurrentCallItem;
+		CodecActiveCallItem IncomingCallItem;
+
+		ushort PreviousDirectoryLength = 0;
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="eisc"></param>
+		/// <param name="messagePath"></param>
+		public Ddvc01VtcMessenger(string key, BasicTriList eisc, string messagePath)
+			: base(key, messagePath)
+		{
+			EISC = eisc;
+
+			CurrentCallItem = new CodecActiveCallItem();
+			CurrentCallItem.Type = eCodecCallType.Video;
+			CurrentCallItem.Id = "-video-";
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="appServerController"></param>
+		protected override void CustomRegisterWithAppServer(CotijaSystemController appServerController)
+		{
+			var asc = appServerController;
+			EISC.SetStringSigAction(SHookState, s => 
+			{
+				CurrentCallItem.Status = (eCodecCallStatus)Enum.Parse(typeof(eCodecCallStatus), s, true);
+				PostFullStatus(); // SendCallsList();
+			});
+
+			EISC.SetStringSigAction(SCurrentCallNumber, s => 
+			{
+				CurrentCallItem.Number = s;
+                PostCallsList();
+			});
+
+            EISC.SetStringSigAction(SCurrentCallName, s =>
+            {
+                CurrentCallItem.Name = s;
+                PostCallsList();
+            });
+
+            EISC.SetStringSigAction(SCallDirection, s =>
+            {
+                CurrentCallItem.Direction = (eCodecCallDirection)Enum.Parse(typeof(eCodecCallDirection), s, true);
+                PostCallsList();
+            });
+
+			EISC.SetBoolSigAction(BCallIncoming, b =>
+			{
+				if (b)
+				{
+					var ica = new CodecActiveCallItem()
+					{
+						Direction = eCodecCallDirection.Incoming,
+						Id = "-video-incoming",
+						Name = EISC.GetString(SIncomingCallName),
+						Number = EISC.GetString(SIncomingCallNumber),
+						Status = eCodecCallStatus.Ringing,
+						Type = eCodecCallType.Video
+					};
+					IncomingCallItem = ica;
+				}
+				else
+				{
+					IncomingCallItem = null;
+				}
+				PostCallsList();
+			});
+
+			// Directory insanity
+			EISC.SetUShortSigAction(UDirectoryRowCount, u =>
+			{
+				// The length of the list comes in before the list does.
+				// Splice the sig change operation onto the last string sig that will be changing
+				// when the directory entries make it through.
+				if (PreviousDirectoryLength > 0)
+				{
+					EISC.ClearStringSigAction(SDirectoryEntriesStart + PreviousDirectoryLength - 1);
+				}
+				EISC.SetStringSigAction(SDirectoryEntriesStart + u - 1, s => PostDirectory());
+				PreviousDirectoryLength = u;
+			});
+
+			EISC.SetStringSigAction(SDirectoryEntrySelectedName, s =>
+			{
+				PostStatusMessage(new
+				{
+					directoryContactSelected = new
+					{
+						name = EISC.GetString(SDirectoryEntrySelectedName),
+					}
+				});
+			});
+
+			EISC.SetStringSigAction(SDirectoryEntrySelectedNumber, s =>
+			{
+				PostStatusMessage(new
+				{
+					directoryContactSelected = new
+					{
+						number = EISC.GetString(SDirectoryEntrySelectedNumber),
+					}
+				});
+			});
+
+			EISC.SetStringSigAction(SDirectorySelectedFolderName, s => PostStatusMessage(new
+			{
+				directorySelectedFolderName = EISC.GetString(SDirectorySelectedFolderName)
+			}));
+
+			EISC.SetSigTrueAction(BCameraModeAuto, () => PostCameraMode());
+			EISC.SetSigTrueAction(BCameraModeManual, () => PostCameraMode());
+			EISC.SetSigTrueAction(BCameraModeOff, () => PostCameraMode());
+
+			EISC.SetUShortSigAction(UCameraNumberSelect, (u) => PostSelectedCamera());
+
+
+			// Add press and holds using helper action
+			Action<string, uint> addPHAction = (s, u) => 
+				AppServerController.AddAction(MessagePath + s, new PressAndHoldAction(b => EISC.SetBool(u, b)));
+			addPHAction("/cameraUp", BCameraControlUp);
+			addPHAction("/cameraDown", BCameraControlDown);
+			addPHAction("/cameraLeft", BCameraControlLeft);
+			addPHAction("/cameraRight", BCameraControlRight);
+			addPHAction("/cameraZoomIn", BCameraControlZoomIn);
+			addPHAction("/cameraZoomOut", BCameraControlZoomOut);
+
+			// Add straight pulse calls using helper action
+			Action<string, uint> addAction = (s, u) =>
+				AppServerController.AddAction(MessagePath + s, new Action(() => EISC.PulseBool(u, 100)));
+			addAction("/endCallById", BDialHangup);
+            addAction("/acceptById", BIncomingAnswer);
+            addAction("/rejectById", BIncomingReject);
+			addAction("/speedDial1", BSpeedDial1);
+			addAction("/speedDial2", BSpeedDial2);
+			addAction("/speedDial3", BSpeedDial3);
+			addAction("/speedDial4", BSpeedDial4);
+			addAction("/cameraModeAuto", BCameraModeAuto);
+			addAction("/cameraModeManual", BCameraModeManual);
+			addAction("/cameraModeOff", BCameraModeOff);
+
+			asc.AddAction("/cameraSelect", new Action<string>(SelectCamera));
+
+			// camera presets
+			for(uint i = 0; i < 6; i++) 
+			{
+				addAction("/cameraPreset" + (i + 1), BCameraPresetStart + i);
+			}
+
+			asc.AddAction(MessagePath + "/isReady", new Action(PostIsReady));
+			// Get status
+			asc.AddAction(MessagePath + "/fullStatus", new Action(PostFullStatus));
+			// Dial on string
+			asc.AddAction(MessagePath + "/dial", new Action<string>(s => 
+				EISC.SetString(SCurrentDialString, s)));
+			// Pulse DTMF
+			asc.AddAction(MessagePath + "/dtmf", new Action<string>(s =>
+			{
+				if (DTMFMap.ContainsKey(s))
+				{
+					EISC.PulseBool(DTMFMap[s], 100);
+				}
+			}));
+
+			// Directory madness
+			asc.AddAction(MessagePath + "/directoryRoot", new Action(() => EISC.PulseBool(BDirectoryRoot)));
+			asc.AddAction(MessagePath + "/directoryBack", new Action(() => EISC.PulseBool(BDirectoryFolderBack)));
+			asc.AddAction(MessagePath + "/directoryById", new Action<string>(s =>
+			{
+				// the id should contain the line number to forward to simpl
+				try
+				{
+					var u = ushort.Parse(s);
+					EISC.SetUshort(UDirectorySelectRow, u);
+					EISC.PulseBool(BDirectoryLineSelected);
+				}
+				catch (Exception)
+				{
+					Debug.Console(1, this, Debug.ErrorLogLevel.Warning, 
+						"/directoryById request contains non-numeric ID incompatible with DDVC bridge");
+				}
+
+			}));
+			asc.AddAction(MessagePath + "/directorySelectContact", new Action<string>(s =>
+			{
+				try
+				{
+					var u = ushort.Parse(s);
+					EISC.SetUshort(UDirectorySelectRow, u);
+					EISC.PulseBool(BDirectoryLineSelected);
+				}
+				catch
+				{
+					
+				}
+			}));
+			asc.AddAction(MessagePath + "/directoryDialContact", new Action(() => {
+				EISC.PulseBool(BDirectoryDialSelectedLine);
+			}));
+			asc.AddAction(MessagePath + "/getDirectory", new Action(() =>
+			{
+				if (EISC.GetUshort(UDirectoryRowCount) > 0)
+				{
+					PostDirectory();
+				}
+				else
+				{
+					EISC.PulseBool(BDirectoryRoot);
+				}
+			}));
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void PostFullStatus()
+		{
+			this.PostStatusMessage(new
+			{
+				calls = GetCurrentCallList(),
+				cameraMode = GetCameraMode(),
+				currentCallString = EISC.GetString(SCurrentCallNumber),
+				currentDialString = EISC.GetString(SCurrentDialString),
+				directoryContactSelected = new
+				{
+					name = EISC.GetString(SDirectoryEntrySelectedName),
+					number = EISC.GetString(SDirectoryEntrySelectedNumber)
+				},
+				directorySelectedFolderName = EISC.GetString(SDirectorySelectedFolderName),
+				isInCall = EISC.GetString(SHookState) == "Connected",
+				hasDirectory = true,
+				hasDirectorySearch = false,
+				hasRecents = true,
+				hasCameras = true,
+				selectedCamera = GetSelectedCamera(),
+			});
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void PostDirectory()
+		{
+			var u = EISC.GetUshort(UDirectoryRowCount);
+			var items = new List<object>();
+			for (uint i = 0; i < u; i++)
+			{
+				var name = EISC.GetString(SDirectoryEntriesStart + i);
+				var id = (i + 1).ToString();
+				// is folder or contact?
+				if (name.StartsWith("[+]"))
+				{
+					items.Add(new
+					{
+						folderId = id,
+						name = name
+					});
+				}
+				else
+				{
+					items.Add(new
+					{
+						contactId = id,
+						name = name
+					});
+				}
+			}
+
+			var directoryMessage = new
+			{
+				currentDirectory = new
+				{
+					isRootDirectory = EISC.GetBool(BDirectoryIsRoot),
+					directoryResults = items
+				}
+			};
+			PostStatusMessage(directoryMessage);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void PostCameraMode()
+		{
+			PostStatusMessage(new
+			{
+				cameraMode = GetCameraMode()
+			});
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="mode"></param>
+		string GetCameraMode()
+		{
+			string m;
+			if (EISC.GetBool(BCameraModeAuto)) m = "auto";
+			else if (EISC.GetBool(BCameraModeManual)) m = "manual";
+			else m = "off";
+			return m;
+		}
+
+		void PostSelectedCamera()
+		{
+			PostStatusMessage(new
+			{
+				selectedCamera = GetSelectedCamera()
+			});
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		string GetSelectedCamera()
+		{
+			var num = EISC.GetUshort(UCameraNumberSelect);
+			string m;
+			if (num == 100)
+			{
+				m = "cameraFar";
+			}
+			else
+			{
+				m = "camera" + num;
+			}
+			return m;
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void PostIsReady()
+		{
+			PostStatusMessage(new
+			{
+				isReady = true
+			});
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+        void PostCallsList()
+        {
+            PostStatusMessage(new
+            {
+                calls = GetCurrentCallList(),
+            });
+        }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="s"></param>
+		void SelectCamera(string s)
+		{
+			var cam = s.Substring(6);
+			if (cam.ToLower() == "far")
+			{
+				EISC.SetUshort(UCameraNumberSelect, 100);
+			}
+			else
+			{
+				EISC.SetUshort(UCameraNumberSelect, UInt16.Parse(cam));
+			}
+		}
+
+		/// <summary>
+		/// Turns the 
+		/// </summary>
+		/// <returns></returns>
+		List<CodecActiveCallItem> GetCurrentCallList()
+		{
+			var list = new List<CodecActiveCallItem>();
+			if (CurrentCallItem.Status != eCodecCallStatus.Disconnected)
+			{
+				list.Add(CurrentCallItem);
+			}
+			if (EISC.GetBool(BCallIncoming)) {
+
+			}
+			return list;
+		}
+	}
+}

PepperDashEssentials/AppServer/Messengers/MessengerBase.cs

@@ -7,6 +7,8 @@ using Crestron.SimplSharp;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
+using PepperDash.Core;
+
 using PepperDash.Essentials.Devices.Common.Codec;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
 
@@ -15,8 +17,10 @@ namespace PepperDash.Essentials.AppServer.Messengers
 	/// <summary>
 	/// Provides a messaging bridge for a VideoCodecBase
 	/// </summary>
-	public abstract class MessengerBase
+	public abstract class MessengerBase : IKeyed
 	{
+        public string Key { get; private set; }
+
 		/// <summary>
 		/// 
 		/// </summary>
@@ -28,8 +32,10 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// 
 		/// </summary>
 		/// <param name="codec"></param>
-		public MessengerBase(string messagePath)
+		public MessengerBase(string key, string messagePath)
 		{
+            Key = key;
+
 			if (string.IsNullOrEmpty(messagePath))
 				throw new ArgumentException("messagePath must not be empty or null");
 
@@ -62,11 +68,14 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// <param name="contentObject">The contents of the content object</param>
 		protected void PostStatusMessage(object contentObject)
 		{
-			AppServerController.SendMessageToServer(JObject.FromObject(new
+            if (AppServerController != null)
-			{
+            {
-				type = MessagePath,
+                AppServerController.SendMessageToServer(JObject.FromObject(new
-				content = contentObject
+                {
-			}));
+                    type = MessagePath,
+                    content = contentObject
+                }));
+            }
 		}
 	}
 }

PepperDashEssentials/AppServer/Messengers/SystemMonitorMessenger.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Monitoring;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+    public class SystemMonitorMessenger : MessengerBase
+    {
+        public SystemMonitorController SysMon { get; private set; }
+
+        public SystemMonitorMessenger(string key, SystemMonitorController sysMon, string messagePath)
+            : base(key, messagePath)
+        {
+            if (sysMon == null)
+                throw new ArgumentNullException("sysMon");
+
+            SysMon = sysMon;
+
+            SysMon.SystemMonitorPropertiesChanged += new EventHandler<EventArgs>(SysMon_SystemMonitorPropertiesChanged);
+
+            foreach (var p in SysMon.ProgramStatusFeedbackCollection)
+            {
+                p.Value.ProgramInfoChanged += new EventHandler<ProgramInfoEventArgs>(ProgramInfoChanged);
+            }
+
+            CrestronConsole.AddNewConsoleCommand(s => SendFullStatusMessage(), "SendFullSysMonStatus", "Sends the full System Monitor Status", ConsoleAccessLevelEnum.AccessOperator);
+        }
+
+        /// <summary>
+        /// Posts the program information message
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void ProgramInfoChanged(object sender, ProgramInfoEventArgs e)
+        {
+            Debug.Console(1, "Posting Status Message: {0}", e.ProgramInfo.ToString());
+            PostStatusMessage(e.ProgramInfo);
+        }
+
+        /// <summary>
+        /// Posts the system monitor properties
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void SysMon_SystemMonitorPropertiesChanged(object sender, EventArgs e)
+        {
+            SendSystemMonitorStatusMessage();
+        }
+
+        void SendFullStatusMessage()
+        {
+            SendSystemMonitorStatusMessage();
+
+            foreach (var p in SysMon.ProgramStatusFeedbackCollection)
+            {
+                PostStatusMessage(p.Value.ProgramInfo);               
+            }
+        }
+
+        void SendSystemMonitorStatusMessage()
+        {
+            Debug.Console(1, "Posting System Monitor Status Message.");
+
+            // This takes a while, launch a new thread
+            CrestronInvoke.BeginInvoke((o) =>
+            {
+                PostStatusMessage(new
+                {
+                    timeZone = SysMon.TimeZoneFeedback.IntValue,
+                    timeZoneName = SysMon.TimeZoneTextFeedback.StringValue,
+                    ioControllerVersion = SysMon.IOControllerVersionFeedback.StringValue,
+                    snmpVersion = SysMon.SnmpVersionFeedback.StringValue,
+                    bacnetVersion = SysMon.BACnetAppVersionFeedback.StringValue,
+                    controllerVersion = SysMon.ControllerVersionFeedback.StringValue
+                });
+            });
+        }
+
+        protected override void CustomRegisterWithAppServer(CotijaSystemController appServerController)
+        {
+            AppServerController.AddAction(MessagePath + "/fullStatus", new Action(SendFullStatusMessage));
+        }
+
+    }
+}

PepperDashEssentials/AppServer/Messengers/VideoCodecBaseMessenger.cs

@@ -13,7 +13,7 @@ using PepperDash.Essentials.Devices.Common.VideoCodec;
 namespace PepperDash.Essentials.AppServer.Messengers
 {
 	/// <summary>
-	/// Provides a messaging bridge for a VideoCodecBase
+	/// Provides a messaging bridge for a VideoCodecBase device
 	/// </summary>
 	public class VideoCodecBaseMessenger : MessengerBase
 	{
@@ -26,7 +26,8 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// 
 		/// </summary>
 		/// <param name="codec"></param>
-		public VideoCodecBaseMessenger(VideoCodecBase codec, string messagePath) : base(messagePath)
+		public VideoCodecBaseMessenger(string key, VideoCodecBase codec, string messagePath)
+            : base(key, messagePath)
 		{
 			if (codec == null)
 				throw new ArgumentNullException("codec");
@@ -40,7 +41,31 @@ namespace PepperDash.Essentials.AppServer.Messengers
 			{
 				dirCodec.DirectoryResultReturned += new EventHandler<DirectoryEventArgs>(dirCodec_DirectoryResultReturned);
 			}
+
+            var recCodec = codec as IHasCallHistory;
+            if (recCodec != null)
+            {
+                recCodec.CallHistory.RecentCallsListHasChanged += new EventHandler<EventArgs>(CallHistory_RecentCallsListHasChanged);
+            }
 		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void CallHistory_RecentCallsListHasChanged(object sender, EventArgs e)
+        {
+            var recents = (sender as CodecCallHistory).RecentCalls;
+
+            if (recents != null)
+            {
+                PostStatusMessage(new
+                {
+                    recentCalls = recents
+                });
+            }
+        }
 		
 		/// <summary>
 		/// 
@@ -49,7 +74,6 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// <param name="e"></param>
 		void dirCodec_DirectoryResultReturned(object sender, DirectoryEventArgs e)
 		{
-			var dir = e.Directory;
 			PostStatusMessage(new
 			{
 				currentDirectory = e.Directory
@@ -98,9 +122,10 @@ namespace PepperDash.Essentials.AppServer.Messengers
 				if (call != null)
 					Codec.AcceptCall(call);
 			}));
-			appServerController.AddAction(MessagePath + "/directoryRoot", new Action(GetDirectoryRoot));			
+			appServerController.AddAction(MessagePath + "/getDirectory", new Action(GetDirectoryRoot));			
 			appServerController.AddAction(MessagePath + "/directoryById", new Action<string>(s => GetDirectory(s)));
 			appServerController.AddAction(MessagePath + "/directorySearch", new Action<string>(s => DirectorySearch(s)));
+            appServerController.AddAction(MessagePath + "/getCallHistory", new Action(GetCallHistory));
 			appServerController.AddAction(MessagePath + "/privacyModeOn", new Action(Codec.PrivacyModeOn));
 			appServerController.AddAction(MessagePath + "/privacyModeOff", new Action(Codec.PrivacyModeOff));
 			appServerController.AddAction(MessagePath + "/privacyModeToggle", new Action(Codec.PrivacyModeToggle));
@@ -110,6 +135,24 @@ namespace PepperDash.Essentials.AppServer.Messengers
 			appServerController.AddAction(MessagePath + "/standbyOff", new Action(Codec.StandbyDeactivate));
 		}
 
+        void GetCallHistory()
+        {
+            var codec = (Codec as IHasCallHistory);
+
+            if (codec != null)
+            {
+                var recents = codec.CallHistory.RecentCalls;
+
+                if (recents != null)
+                {
+                    PostStatusMessage(new
+                    {
+                        recentCalls = recents
+                    });
+                }
+            }
+        }
+
 		public void GetFullStatusMessage()
 		{
 
@@ -227,7 +270,9 @@ namespace PepperDash.Essentials.AppServer.Messengers
 					sipURI = info.SipUri
 				},
 				showSelfViewByDefault = Codec.ShowSelfViewByDefault,
-				hasDirectory = Codec is IHasDirectory
+				hasDirectory = Codec is IHasDirectory,
+                hasRecents = Codec is IHasCallHistory,
+                hasCameras = Codec is IHasCameraControl
 			});
 		}
 	}

PepperDashEssentials/AppServer/RoomBridges/CotijaDdvc01RoomBridge.cs

@@ -56,7 +56,10 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// 1
 			/// </summary>
 			public const uint MasterVolumeMuteToggle = 1;
-
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint VolumeMutesJoinStart = 1;
 			/// <summary>
 			/// 61
 			/// </summary>
@@ -72,7 +75,7 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// <summary>
 			/// 72
 			/// </summary>
-			public const uint SourceHasChanged = 72;
+			public const uint SourceHasChanged = 71;
 			/// <summary>
 			/// 261 - The start of the range of speed dial visibles
 			/// </summary>
@@ -81,6 +84,11 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// 501
 			/// </summary>
 			public const uint ConfigIsReady = 501;
+			/// <summary>
+			/// 601
+			/// </summary>
+			public const uint SourceShareDisableStartJoin = 601;
+
 		}
 
 		public class UshortJoin
@@ -89,15 +97,26 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// 1
 			/// </summary>
 			public const uint MasterVolumeLevel = 1;
-
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint VolumeSlidersJoinStart = 1;
 			/// <summary>
 			/// 61
 			/// </summary>
 			public const uint ShutdownPromptDuration = 61;
+			/// <summary>
+			/// 101
+			/// </summary>
+			public const uint VolumeSliderCount = 101;
 		}
 
 		public class StringJoin
 		{
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint VolumeSliderNamesJoinStart = 1;
 			/// <summary>
 			/// 71
 			/// </summary>
@@ -141,6 +160,38 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// 402
 			/// </summary>
 			public const uint ServerUrl = 402;
+			/// <summary>
+			/// 512
+			/// </summary>
+			public const uint RoomSpeedDialNamesJoinStart = 512;
+			/// <summary>
+			/// 516
+			/// </summary>
+			public const uint RoomSpeedDialNumberssJoinStart = 516;
+			/// <summary>
+			/// 601
+			/// </summary>
+			public const uint SourceNameJoinStart = 601;
+			/// <summary>
+			/// 621
+			/// </summary>
+			public const uint SourceIconJoinStart = 621;
+			/// <summary>
+			/// 641
+			/// </summary>
+			public const uint SourceKeyJoinStart = 641;
+			/// <summary>
+			/// 661
+			/// </summary>
+			public const uint SourceTypeJoinStart = 661;
+			/// <summary>
+			/// 761
+			/// </summary>
+			public const uint CameraNearNameStart = 761;
+			/// <summary>
+			/// 770 - presence of this name on the input will cause the camera to be added
+			/// </summary>
+			public const uint CameraFarName = 770;
 		}
 
 		/// <summary>
@@ -166,6 +217,7 @@ namespace PepperDash.Essentials.Room.Cotija
 		CotijaDdvc01DeviceBridge SourceBridge;
 
 		Ddvc01AtcMessenger AtcMessenger;
+		Ddvc01VtcMessenger VtcMessenger;
 
 
 		/// <summary>
@@ -204,9 +256,14 @@ namespace PepperDash.Essentials.Room.Cotija
 			SetupFunctions();
 			SetupFeedbacks();
 
-			AtcMessenger = new Ddvc01AtcMessenger(EISC, "/device/audioCodec");
+            var atcKey = string.Format("atc-{0}-{1}", this.Key, Parent.Key);
+			AtcMessenger = new Ddvc01AtcMessenger(atcKey, EISC, "/device/audioCodec");
 			AtcMessenger.RegisterWithAppServer(Parent);
 
+            var vtcKey = string.Format("atc-{0}-{1}", this.Key, Parent.Key);
+			VtcMessenger = new Ddvc01VtcMessenger(vtcKey, EISC, "/device/videoCodec");
+			VtcMessenger.RegisterWithAppServer(Parent);
+
 			EISC.SigChange += EISC_SigChange;
 			EISC.OnlineStatusChange += (o, a) =>
 			{
@@ -250,7 +307,6 @@ namespace PepperDash.Essentials.Room.Cotija
 		/// </summary>
 		void SetupFunctions()
 		{
-#warning need join numbers for these
 			Parent.AddAction(@"/room/room1/promptForCode", new Action(() => EISC.PulseBool(BoolJoin.PromptForCode)));
 			Parent.AddAction(@"/room/room1/clientJoined", new Action(() => EISC.PulseBool(BoolJoin.ClientJoined)));
 
@@ -384,8 +440,8 @@ namespace PepperDash.Essentials.Room.Cotija
 			//Room
 			//if (co.Rooms == null)
 			// always start fresh in case simpl changed
-			co.Rooms = new List<EssentialsRoomConfig>();
+			co.Rooms = new List<DeviceConfig>();
-			var rm = new EssentialsRoomConfig();
+			var rm = new DeviceConfig();
             if (co.Rooms.Count == 0)
             {
                 Debug.Console(0, this, "Adding room to config");
@@ -396,7 +452,7 @@ namespace PepperDash.Essentials.Room.Cotija
                 Debug.Console(0, this, "Replacing Room[0] in config");
                 co.Rooms[0] = rm;
             }
-			rm.Name = EISC.StringOutput[501].StringValue;
+			rm.Name = EISC.StringOutput[StringJoin.ConfigRoomName].StringValue;
 			rm.Key = "room1";
 			rm.Type = "ddvc01";
 
@@ -407,15 +463,17 @@ namespace PepperDash.Essentials.Room.Cotija
 				rmProps = JsonConvert.DeserializeObject<DDVC01RoomPropertiesConfig>(rm.Properties.ToString());
 
 			rmProps.Help = new EssentialsHelpPropertiesConfig();
-			rmProps.Help.CallButtonText = EISC.StringOutput[503].StringValue;
+			rmProps.Help.CallButtonText = EISC.StringOutput[StringJoin.ConfigHelpNumber].StringValue;
-			rmProps.Help.Message = EISC.StringOutput[502].StringValue;
+			rmProps.Help.Message = EISC.StringOutput[StringJoin.ConfigHelpMessage].StringValue;
 
 			rmProps.Environment = new EssentialsEnvironmentPropertiesConfig(); // enabled defaults to false
 
-			rmProps.RoomPhoneNumber = EISC.StringOutput[504].StringValue;
+			rmProps.RoomPhoneNumber = EISC.StringOutput[StringJoin.ConfigRoomPhoneNumber].StringValue;
-			rmProps.RoomURI = EISC.StringOutput[505].StringValue;
+			rmProps.RoomURI = EISC.StringOutput[StringJoin.ConfigRoomURI].StringValue;
 			rmProps.SpeedDials = new List<DDVC01SpeedDial>();
 			// add speed dials as long as there are more - up to 4
+
+#warning fix speed dials - 512-515 names, 516-519 numbers
 			for (uint i = 512; i <= 519; i = i + 2)
 			{
 				var num = EISC.StringOutput[i].StringValue;
@@ -427,10 +485,10 @@ namespace PepperDash.Essentials.Room.Cotija
 
 			// This MAY need a check 
 			rmProps.AudioCodecKey = "audioCodec";
-			rmProps.VideoCodecKey = null; // "videoCodec";
+			rmProps.VideoCodecKey = "videoCodec";
 
 			// volume control names
-			var volCount = EISC.UShortOutput[701].UShortValue;
+			var volCount = EISC.UShortOutput[UshortJoin.VolumeSliderCount].UShortValue;
 
             //// use Volumes object or?
             //rmProps.VolumeSliderNames = new List<string>();
@@ -458,24 +516,39 @@ namespace PepperDash.Essentials.Room.Cotija
 
 			co.SourceLists = new Dictionary<string,Dictionary<string,SourceListItem>>();
 			var newSl = new Dictionary<string, SourceListItem>();
-			// add sources...
+			// add "none" source if VTC present
-			for (uint i = 0; i<= 19; i++)
+
+			if (!string.IsNullOrEmpty(rmProps.VideoCodecKey))
 			{
-				var name = EISC.StringOutput[601 + i].StringValue;
+				var codecOsd = new SourceListItem()
+				{
+					Name = "None",
+					IncludeInSourceList = true,
+					Order = 1,
+					Type = eSourceListItemType.Route,
+					SourceKey = ""
+				};
+				newSl.Add("Source-None", codecOsd);
+			}
+			// add sources...
+			for (uint i = 0; i <= 19; i++)
+			{
+				var name = EISC.StringOutput[StringJoin.SourceNameJoinStart + i].StringValue;
 				if(string.IsNullOrEmpty(name))
 					break;
-				var icon = EISC.StringOutput[651 + i].StringValue;
+				var icon = EISC.StringOutput[StringJoin.SourceIconJoinStart + i].StringValue;
-				var key = EISC.StringOutput[671 + i].StringValue;
+				var key = EISC.StringOutput[StringJoin.SourceKeyJoinStart + i].StringValue;
-
+				var type = EISC.StringOutput[StringJoin.SourceTypeJoinStart + i].StringValue;
-				var type = EISC.StringOutput[701 + i].StringValue;
+				var disableShare = EISC.BooleanOutput[BoolJoin.SourceShareDisableStartJoin + i].BoolValue;
 
 				Debug.Console(0, this, "Adding source {0} '{1}'", key, name);
 				var newSLI = new SourceListItem{
 					Icon = icon,
 					Name = name,
-					Order = (int)i + 1,
+					Order = (int)i + 10,
 					SourceKey = key,
-					Type = eSourceListItemType.Route
+					Type = eSourceListItemType.Route,
+					DisableCodecSharing = disableShare,
 				};
 				newSl.Add(key, newSLI);
                 
@@ -535,7 +608,68 @@ namespace PepperDash.Essentials.Room.Cotija
 					Properties = JToken.FromObject(acProps)
 				};
 				co.Devices.Add(acConf);
-			}	
+			}
+
+			if (!string.IsNullOrEmpty(rmProps.VideoCodecKey))
+			{
+#warning Break out these video codec favs
+				var favs = new List<PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem>();
+				for (uint i = 0; i < 4; i++)
+				{
+					if (!EISC.GetBool(BoolJoin.SpeedDialVisibleStartJoin + i))
+					{
+						break;
+					}
+					favs.Add(new PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem()
+					{
+						Name = EISC.GetString(StringJoin.SpeedDialNameStartJoin + i),
+						Number = EISC.GetString(StringJoin.SpeedDialNumberStartJoin + i),
+						Type = PepperDash.Essentials.Devices.Common.Codec.eCodecCallType.Audio
+					});
+				}
+
+
+
+				// cameras
+				var camsProps = new List<object>();
+				for (uint i = 0; i < 9; i++)
+				{
+					var name = EISC.GetString(i + StringJoin.CameraNearNameStart);
+					if (!string.IsNullOrEmpty(name))
+					{
+						camsProps.Add(new
+						{
+							name = name,
+							selector = "camera" + (i + 1),
+						});
+					}
+				}
+				var farName = EISC.GetString(StringJoin.CameraFarName);
+				if (!string.IsNullOrEmpty(farName))
+				{
+					camsProps.Add(new
+					{
+						name = farName,
+						selector = "cameraFar",
+					});
+				}
+
+				var props = new
+				{
+					favorites = favs,
+					cameras = camsProps,
+				};
+				var str = "videoCodec";
+				var conf = new DeviceConfig()
+				{
+					Group = str,
+					Key = str,
+					Name = str,
+					Type = str,
+					Properties = JToken.FromObject(props)
+				};
+				co.Devices.Add(conf);
+			}
 
 			Debug.Console(0, this, "******* CONFIG FROM DDVC: \r{0}", JsonConvert.SerializeObject(ConfigReader.ConfigObject, Formatting.Indented));
 

PepperDashEssentials/AppServer/RoomBridges/CotijaEssentialsHuddleSpaceRoomBridge.cs

@@ -12,6 +12,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Room.Cotija;
 using PepperDash.Essentials.Devices.Common.Codec;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
+using PepperDash.Essentials.Devices.Common.AudioCodec;
 
 namespace PepperDash.Essentials
 {
@@ -22,6 +23,8 @@ namespace PepperDash.Essentials
 
 		public VideoCodecBaseMessenger VCMessenger { get; private set; }
 
+        public AudioCodecBaseMessenger ACMessenger { get; private set; }
+
 		/// <summary>
 		/// 
 		/// </summary>
@@ -92,29 +95,25 @@ namespace PepperDash.Essentials
 				sscRoom.CurrentSingleSourceChange += new SourceInfoChangeHandler(Room_CurrentSingleSourceChange);
 
 			var vcRoom = Room as IHasVideoCodec;
-			if (vcRoom != null)
+			if (vcRoom != null && vcRoom.VideoCodec != null)
 			{
 				var codec = vcRoom.VideoCodec;
-				VCMessenger = new VideoCodecBaseMessenger(vcRoom.VideoCodec, "/device/videoCodec");
+                var key = vcRoom.VideoCodec.Key + "-" + parent.Key;
+				VCMessenger = new VideoCodecBaseMessenger(key, vcRoom.VideoCodec, "/device/videoCodec");
 				VCMessenger.RegisterWithAppServer(Parent);
 
-				// May need to move this or remove this 
-				codec.CallStatusChange += new EventHandler<CodecCallStatusItemChangeEventArgs>(codec_CallStatusChange);
-
 				vcRoom.IsSharingFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(IsSharingFeedback_OutputChange);
-
-				//Parent.AddAction("/device/videoCodec/dial", new Action<string>(s => codec.Dial(s)));
-				//Parent.AddAction("/device/videoCodec/endCall", new Action<string>(s =>
-				//{
-				//    var call = codec.ActiveCalls.FirstOrDefault(c => c.Id == s);
-				//    if (call != null)
-				//    {
-				//        codec.EndCall(call);
-				//    }
-				//}));
-				//Parent.AddAction("/device/videoCodec/endAllCalls", new Action(() => codec.EndAllCalls()));
 			}
 
+            var acRoom = Room as IHasAudioCodec;
+            if (acRoom != null && acRoom.AudioCodec != null)
+            {
+                var codec = acRoom.AudioCodec;
+                var key = acRoom.AudioCodec.Key + "-" + parent.Key;
+                ACMessenger = new AudioCodecBaseMessenger(key, acRoom.AudioCodec, "/device/audioCodec");
+                ACMessenger.RegisterWithAppServer(Parent);
+            }
+
 			var defCallRm = Room as IRunDefaultCallRoute;
 			if (defCallRm != null)
 			{
@@ -169,18 +168,18 @@ namespace PepperDash.Essentials
 			});
 		}
 
-		/// <summary>
+        ///// <summary>
-		/// Handler for codec changes
+        ///// Handler for codec changes
-		/// </summary>
+        ///// </summary>
-		void codec_CallStatusChange(object sender, CodecCallStatusItemChangeEventArgs e)
+        //void codec_CallStatusChange(object sender, CodecCallStatusItemChangeEventArgs e)
-		{
+        //{
-			PostStatusMessage(new
+        //    PostStatusMessage(new
-			{
+        //    {
-				calls = GetCallsMessageObject(),
+        //        calls = GetCallsMessageObject(),
-				//vtc = GetVtcCallsMessageObject()
+        //        //vtc = GetVtcCallsMessageObject()
-			});
+        //    });
 
-		}
+        //}
 
 		/// <summary>
 		/// Helper for posting status message
@@ -417,7 +416,7 @@ namespace PepperDash.Essentials
 			if (rmVc != null)
 			{
 				var vc = rmVc.CurrentVolumeControls as IBasicVolumeWithFeedback;
-				if (rmVc != null)
+				if (vc != null)
 				{
 					volumes.Master = new Volume("master", vc.VolumeLevelFeedback.UShortValue, vc.MuteFeedback.BoolValue, "Volume", true, "");
 				}
@@ -425,52 +424,52 @@ namespace PepperDash.Essentials
 
 			PostStatusMessage(new
 			{
-				calls = GetCallsMessageObject(),
+                //calls = GetCallsMessageObject(),
 				isOn = room.OnFeedback.BoolValue,
 				selectedSourceKey = sourceKey,
-				vtc = GetVtcCallsMessageObject(),
+                //vtc = GetVtcCallsMessageObject(),
 				volumes = volumes
 			});
         }
 
-		/// <summary>
+        ///// <summary>
-		/// Helper to return a anonymous object with the call data for JSON message
+        ///// Helper to return a anonymous object with the call data for JSON message
-		/// </summary>
+        ///// </summary>
-		/// <returns></returns>
+        ///// <returns></returns>
-		object GetCallsMessageObject()
+        //object GetCallsMessageObject()
-		{
+        //{
-			var callRm = Room as IHasVideoCodec;
+        //    var callRm = Room as IHasVideoCodec;
-			if (callRm == null)
+        //    if (callRm == null)
-				return null;
+        //        return null;
-			return new
+        //    return new
-			{
+        //    {
-				activeCalls = callRm.VideoCodec.ActiveCalls,
+        //        activeCalls = callRm.VideoCodec.ActiveCalls,
-				callType = callRm.CallTypeFeedback.IntValue,
+        //        callType = callRm.CallTypeFeedback.IntValue,
-				inCall = callRm.InCallFeedback.BoolValue,
+        //        inCall = callRm.InCallFeedback.BoolValue,
-				isSharing = callRm.IsSharingFeedback.BoolValue,
+        //        isSharing = callRm.IsSharingFeedback.BoolValue,
-				privacyModeIsOn = callRm.PrivacyModeIsOnFeedback.BoolValue
+        //        privacyModeIsOn = callRm.PrivacyModeIsOnFeedback.BoolValue
-			};
+        //    };
-		}
+        //}
 
-		/// <summary>
+        ///// <summary>
-		/// Helper method to build call status for vtc
+        ///// Helper method to build call status for vtc
-		/// </summary>
+        ///// </summary>
-		/// <returns></returns>
+        ///// <returns></returns>
-		object GetVtcCallsMessageObject()
+        //object GetVtcCallsMessageObject()
-		{
+        //{
-			var callRm = Room as IHasVideoCodec;
+        //    var callRm = Room as IHasVideoCodec;
-			object vtc = null;
+        //    object vtc = null;
-			if (callRm != null)
+        //    if (callRm != null)
-			{
+        //    {
-				var codec = callRm.VideoCodec;
+        //        var codec = callRm.VideoCodec;
-				vtc = new
+        //        vtc = new
-				{
+        //        {
-					isInCall = codec.IsInCall,
+        //            isInCall = codec.IsInCall,
-					calls = codec.ActiveCalls
+        //            calls = codec.ActiveCalls
-				};
+        //        };
-			}
+        //    }
-			return vtc;
+        //    return vtc;
-		}     
+        //}     
     }
 
 	/// <summary>

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -5,9 +5,17 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.EthernetCommunication;
 
+using Newtonsoft.Json;
+
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Lighting;
 using PepperDash.Essentials.Core.Devices;
+using PepperDash.Essentials.Devices.Common;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.CrestronIO;
+using PepperDash.Essentials.DM;
+//using PepperDash.Essentials.Devices.Common.Cameras;
 
 namespace PepperDash.Essentials.Bridges
 {
@@ -44,17 +52,93 @@ namespace PepperDash.Essentials.Bridges
     /// </summary>
     public class EiscApi : BridgeApi
     {
+        public EiscApiPropertiesConfig PropertiesConfig { get; private set; }
+
         public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
 
 
-        public EiscApi(string key, uint ipid, string hostname) :
+        public EiscApi(DeviceConfig dc) :
-            base(key)
+            base(dc.Key)
         {
-            Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(ipid, hostname, Global.ControlSystem);
+            PropertiesConfig = JsonConvert.DeserializeObject<EiscApiPropertiesConfig>(dc.Properties.ToString());
+
+            Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(PropertiesConfig.Control.IpIdInt, PropertiesConfig.Control.TcpSshProperties.Address, Global.ControlSystem);
 
             Eisc.SigChange += new Crestron.SimplSharpPro.DeviceSupport.SigEventHandler(Eisc_SigChange);
 
             Eisc.Register();
+
+            AddPostActivationAction( () =>
+            {
+                Debug.Console(1, this, "Linking Devices...");
+
+                foreach (var d in PropertiesConfig.Devices)
+                {
+                    var device = DeviceManager.GetDeviceForKey(d.DeviceKey);
+
+                    if (device != null)
+                    {
+                        if (device is PepperDash.Essentials.Core.Monitoring.SystemMonitorController)
+                        {
+                            (device as PepperDash.Essentials.Core.Monitoring.SystemMonitorController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is GenericComm)
+                        {
+                            (device as GenericComm).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+						//else if (device is CameraBase)
+						//{
+						//    (device as CameraBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+						//    continue;
+						//}
+						//else if (device is PepperDash.Essentials.Core.TwoWayDisplayBase)
+						//{
+						//    (device as TwoWayDisplayBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+						//    continue;
+						//}
+                        else if (device is DmChassisController)
+                        {
+                            (device as DmChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+						
+                        else if (device is DmTxControllerBase)
+                        {
+                            (device as DmTxControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is DmRmcControllerBase)
+                        {
+                            (device as DmRmcControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is GenericRelayDevice)
+                        {
+                            (device as GenericRelayDevice).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is IDigitalInput)
+                        {
+                            (device as IDigitalInput).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+						//else if (device is LightingBase)
+						//{
+						//    (device as LightingBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+						//    continue;
+						//}
+						//else if (device is DigitalLogger)
+						//{
+						//    (device as DigitalLogger).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+						//    continue;
+						//}
+                    }
+                }
+
+                Debug.Console(1, this, "Devices Linked.");
+            });
         }
 
         /// <summary>
@@ -65,7 +149,7 @@ namespace PepperDash.Essentials.Bridges
         void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args)
         {
             if (Debug.Level >= 1)
-                Debug.Console(1, this, "BridgeApi EISC change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+                Debug.Console(1, this, "EiscApi change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
             var uo = args.Sig.UserObject;
             if (uo is Action<bool>)
                 (uo as Action<bool>)(args.Sig.BoolValue);
@@ -76,138 +160,27 @@ namespace PepperDash.Essentials.Bridges
         }
     }
 
-
+    public class EiscApiPropertiesConfig
-
-
-    /// <summary>
-    /// Defines each type and it's matching API type
-    /// </summary>
-    public static class DeviceApiFactory
     {
-        public static Dictionary<Type, Type> TypeMap = new Dictionary<Type, Type>
+        [JsonProperty("control")]
+        public EssentialsControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("devices")]
+        public List<ApiDevice> Devices { get; set; }
+
+
+        public class ApiDevice
         {
-            { typeof(DmChassisController), typeof(DmChassisControllerApi) },
+            [JsonProperty("deviceKey")]
-            { typeof(IBasicCommunication), typeof(IBasicCommunicationApi) }
+            public string DeviceKey { get; set; }
-            //{ typeof(SomeShittyDisplayController), typeof(SomeShittyDisplayControllerApi) }
-        };
-    }
 
+            [JsonProperty("joinStart")]
+            public uint JoinStart { get; set; }
 
-    /// <summary>
+            [JsonProperty("joinMapKey")]
-    /// API class for IBasicCommunication devices
+            public string JoinMapKey { get; set; }
-    /// </summary>
-    public class IBasicCommunicationApi : DeviceApiBase
-    {
-        public IBasicCommunication Device { get; set; }
-
-        SerialFeedback TextReceivedFeedback;
-
-        public IBasicCommunicationApi(IBasicCommunication dev)
-        {
-            TextReceivedFeedback = new SerialFeedback();
-
-            Device = dev;
-
-            SetupFeedbacks();
-
-            ActionApi = new Dictionary<string, Object>
-            {
-                { "connect", new Action(Device.Connect) },
-                { "disconnect", new Action(Device.Disconnect) },
-                { "connectstate", new Action<bool>( b => ConnectByState(b) ) },
-                { "sendtext", new Action<string>( s => Device.SendText(s) ) }
-
-            };
-
-            FeedbackApi = new Dictionary<string, Feedback>
-            {
-                { "isconnected", new BoolFeedback( () => Device.IsConnected ) },
-                { "textrecieved", TextReceivedFeedback }
-            };
         }
 
-        /// <summary>
-        /// Controls connection based on state of input
-        /// </summary>
-        /// <param name="state"></param>
-        void ConnectByState(bool state)
-        {
-            if (state)
-                Device.Connect();
-            else
-                Device.Disconnect();                             
-        }
-
-        void SetupFeedbacks()
-        {
-            Device.TextReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(Device_TextReceived);
-
-            if(Device is ISocketStatus)
-                (Device as ISocketStatus).ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(IBasicCommunicationApi_ConnectionChange);
-        }
-
-        void IBasicCommunicationApi_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
-        {
-            FeedbackApi["isconnected"].FireUpdate();
-        }
-
-        void Device_TextReceived(object sender, GenericCommMethodReceiveTextArgs e)
-        {
-            TextReceivedFeedback.FireUpdate(e.Text);
-        }
-    }
-
- 
-
-    public class DmChassisController : Device
-    {
-        public DmChassisController(string key)
-            : base(key)
-        {
-
-        }
-
-        public void SetInput(int input)
-        {
-            Debug.Console(2, this, "Dm Chassis {0}, input {1}", Key, input);
-        }
-    }
-
-    /// <summary>
-    /// Each flavor of API is a static class with static properties and a static constructor that
-    /// links up the things to do.
-    /// </summary>
-    public class DmChassisControllerApi : DeviceApiBase
-    {
-        IntFeedback Output1Feedback;
-        IntFeedback Output2Feedback;
-
-        public DmChassisControllerApi(DmChassisController dev)
-        {
-            Output1Feedback = new IntFeedback( new Func<int>(() => 1));
-            Output2Feedback = new IntFeedback( new Func<int>(() => 2));
-
-            ActionApi = new Dictionary<string, Object>
-            {
-                
-            };
-
-            FeedbackApi = new Dictionary<string, Feedback>
-            {
-                { "Output-1/fb", Output1Feedback },
-                { "Output-2/fb", Output2Feedback }
-            };
-        }
-
-        /// <summary>
-        /// Factory method
-        /// </summary>
-        /// <param name="dev"></param>
-        /// <returns></returns>
-        public static DmChassisControllerApi GetActionApiForDevice(DmChassisController dev)
-        {
-            return new DmChassisControllerApi(dev);
-        }
     }
 
 

PepperDashEssentials/Bridges/BridgeFactory.cs

@@ -9,176 +9,133 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Bridges;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.EthernetCommunication;
 
 namespace PepperDash.Essentials 
+
 {
-	public class BridgeFactory 
+public class BridgeFactory 
-    {
+{
-		public static IKeyed GetDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc) 
+	public static IKeyed GetDevice(DeviceConfig dc) 
-        {
+	{
-			// ? why is this static JTA 2018-06-13? 
+		// ? why is this static JTA 2018-06-13? 
 			
-			var key = dc.Key;
+		var key = dc.Key;
-			var name = dc.Name;
+		var name = dc.Name;
-			var type = dc.Type;
+		var type = dc.Type;
-			var properties = dc.Properties;
+		var properties = dc.Properties;
-			var propAnon = new { };
+		var propAnon = new { };
-			JsonConvert.DeserializeAnonymousType(dc.Properties.ToString(), propAnon);
 			
-			var typeName = dc.Type.ToLower();
+		var typeName = dc.Type.ToLower();
-			var groupName = dc.Group.ToLower();
+		var groupName = dc.Group.ToLower();
 
-			Debug.Console(0, "Name {0}, Key {1}, Type {2}, Properties {3}", name, key, type, properties.ToString());
+		//Debug.Console(2, "Name {0}, Key {1}, Type {2}, Properties {3}", name, key, type, properties.ToString());
-			if (typeName == "dm") 
+
-            {
+		if (typeName == "eiscapi") 
-			    return new DmBridge(key, name, properties);
+		{
+			return new EiscApi(dc);
+		}
+
+		return null;
+	}
+}
+
+
+public class CommBridge : Device
+{
+	public CommBridgeProperties Properties { get; private set; }
+
+	public List<IBasicCommunication> CommDevices { get; private set; }
+
+	public CommBridge(string key, string name, JToken properties)
+		: base(key, name)
+	{
+		Properties = JsonConvert.DeserializeObject<CommBridgeProperties>(properties.ToString());
+	}
+
+	public override bool CustomActivate()
+	{
+		// Create EiscApis 
+		if (Properties.Eiscs != null)
+		{
+			foreach (var eisc in Properties.Eiscs)
+			{
+				var ApiEisc = new BridgeApiEisc(eisc.IpId, eisc.Hostname);
 			}
-            else if (typeName == "comm")
-            {
-                return new CommBridge(key, name, properties);
-            }
-            else
-			    return null;
 		}
-	}
 
-	public class DmBridge : Device 
+		foreach (var deviceKey in Properties.CommDevices)
-    {
+		{
-        public EiscBridgeProperties Properties { get; private set; }
+			var device = DeviceManager.GetDeviceForKey(deviceKey);
 
-        public PepperDash.Essentials.DM.DmChassisController DmSwitch { get; private set; }
+			if (device != null)
-
+			{
-		public DmBridge(string key, string name, JToken properties) : base(key, name) 
+				Debug.Console(0, "deviceKey {0} Found in Device Manager", device.Key);
-        {
+				CommDevices.Add(device as IBasicCommunication);
-	        Properties = JsonConvert.DeserializeObject<EiscBridgeProperties>(properties.ToString());
-	    }
-
-		public override bool CustomActivate() 
-        {
-			// Create EiscApis 
-			if (Properties.Eiscs != null) 
-            {
-				foreach (var eisc in Properties.Eiscs) 
-                {
-					var ApiEisc = new BridgeApiEisc(eisc.IpId, eisc.Hostname);
-
-					ApiEisc.Eisc.SetUShortSigAction(101, u => DmSwitch.ExecuteSwitch(u,1, eRoutingSignalType.Video));
-					ApiEisc.Eisc.SetUShortSigAction(102, u => DmSwitch.ExecuteSwitch(u,2, eRoutingSignalType.Video));								
-				}
 			}
-
+			else
-			foreach (var device in DeviceManager.AllDevices) 
+			{
-            {
+				Debug.Console(0, "deviceKey {0} Not Found in Device Manager", deviceKey);
-				if (device.Key == this.Properties.ParentDeviceKey) 
-                {
-					Debug.Console(0, "deviceKey {0} Matches", device.Key);
-					DmSwitch = DeviceManager.GetDeviceForKey(device.Key) as PepperDash.Essentials.DM.DmChassisController;
-				} 
-				else 
-                {
-					Debug.Console(0, "deviceKey {0} doesn't match", device.Key);
-				}
 			}
-
-			Debug.Console(0, "Bridge {0} Activated", this.Name);
-			return true;
 		}
+
+		// Iterate through all the CommDevices and link up their Actions and Feedbacks
+
+		Debug.Console(0, "Bridge {0} Activated", this.Name);
+
+		return true;
 	}
-
+}
-    public class CommBridge : Device
-    {
-        public CommBridgeProperties Properties { get; private set; }
-
-        public List<IBasicCommunication> CommDevices { get; private set; }
-
-        public CommBridge(string key, string name, JToken properties)
-            : base(key, name)
-        {
-            Properties = JsonConvert.DeserializeObject<CommBridgeProperties>(properties.ToString());
-        }
-
-        public override bool CustomActivate()
-        {
-            // Create EiscApis 
-            if (Properties.Eiscs != null)
-            {
-                foreach (var eisc in Properties.Eiscs)
-                {
-                    var ApiEisc = new BridgeApiEisc(eisc.IpId, eisc.Hostname);
-                }
-            }
-
-            foreach (var deviceKey in Properties.CommDevices)
-            {
-                var device = DeviceManager.GetDeviceForKey(deviceKey);
-
-                if (device != null)
-                {
-                    Debug.Console(0, "deviceKey {0} Found in Device Manager", device.Key);
-                    CommDevices.Add(device as IBasicCommunication);
-                }
-                else
-                {
-                    Debug.Console(0, "deviceKey {0} Not Found in Device Manager", deviceKey);
-                }
-            }
-
-            // Iterate through all the CommDevices and link up their Actions and Feedbacks
-
-            Debug.Console(0, "Bridge {0} Activated", this.Name);
-
-            return true;
-        }
-    }
 
 
-	public class EiscBridgeProperties 
+public class EiscBridgeProperties 
-    {
+{
-        public string ParentDeviceKey { get; set; }
+	public string ParentDeviceKey { get; set; }
-        public eApiType ApiType { get; set; } 
+	public eApiType ApiType { get; set; } 
-        public List<EiscProperties> Eiscs { get; set; }
+	public List<EiscProperties> Eiscs { get; set; }
-        public string ApiOverrideFilePath { get; set; }
+	public string ApiOverrideFilePath { get; set; }
 
-        public class EiscProperties
+	public class EiscProperties
-        {
+	{
-            public string IpId { get; set; }
+		public string IpId { get; set; }
-            public string Hostname { get; set; }
+		public string Hostname { get; set; }
-        }
 	}
+}
 
-    public class CommBridgeProperties : EiscBridgeProperties
+public class CommBridgeProperties : EiscBridgeProperties
-    {
+{
-        public List<string> CommDevices { get; set; }
+	public List<string> CommDevices { get; set; }
-    }
+}
 
-    public enum eApiType { Eisc = 0 }
+public enum eApiType { Eisc = 0 }
 
-	public class BridgeApiEisc 
+public class BridgeApiEisc 
-    {
+{
-        public uint Ipid { get; private set; }
+	public uint Ipid { get; private set; }
-        public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
+	public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
 
-		public BridgeApiEisc(string ipid, string hostname) 
+	public BridgeApiEisc(string ipid, string hostname) 
-        {
+	{
-			Ipid = (UInt32)int.Parse(ipid, System.Globalization.NumberStyles.HexNumber);
+		Ipid = (UInt32)int.Parse(ipid, System.Globalization.NumberStyles.HexNumber);
-			Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(Ipid, hostname, Global.ControlSystem);
+		Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(Ipid, hostname, Global.ControlSystem);
-			Eisc.Register();
+		Eisc.Register();
-			Eisc.SigChange += Eisc_SigChange;
+		Eisc.SigChange += Eisc_SigChange;
-			Debug.Console(0, "BridgeApiEisc Created at Ipid {0}", ipid);
+		Debug.Console(0, "BridgeApiEisc Created at Ipid {0}", ipid);
-		}
-		void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args) 
-        {
-			if (Debug.Level >= 1)
-				Debug.Console(1, "BridgeApiEisc change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
-			var uo = args.Sig.UserObject;
-			if (uo is Action<bool>)
-				(uo as Action<bool>)(args.Sig.BoolValue);
-			else if (uo is Action<ushort>)
-				(uo as Action<ushort>)(args.Sig.UShortValue);
-			else if (uo is Action<string>)
-				(uo as Action<string>)(args.Sig.StringValue);
-		}
 	}
-}
+	void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args) 
+	{
+		if (Debug.Level >= 1)
+			Debug.Console(1, "BridgeApiEisc change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+		var uo = args.Sig.UserObject;
+		if (uo is Action<bool>)
+			(uo as Action<bool>)(args.Sig.BoolValue);
+		else if (uo is Action<ushort>)
+			(uo as Action<ushort>)(args.Sig.UShortValue);
+		else if (uo is Action<string>)
+			(uo as Action<string>)(args.Sig.StringValue);
+	}
+}
+}
+ 

PepperDashEssentials/Bridges/Bridges.BridgeFactory.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+using PepperDash.Essentials.Bridges;
+
+namespace PepperDash.Essentials {
+	public class BridgeFactory {
+		public static IKeyed GetDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc) {
+			// ? why is this static JTA 2018-06-13? 
+
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+			var propAnon = new { };
+			JsonConvert.DeserializeAnonymousType(dc.Properties.ToString(), propAnon);
+
+			var typeName = dc.Type.ToLower();
+			var groupName = dc.Group.ToLower();
+
+			Debug.Console(2, "Name {0}, Key {1}, Type {2}, Properties {3}", name, key, type, properties.ToString());
+			if (typeName == "essentialdm") 
+			{
+				return new EssentialDM(key, name, properties);
+			} 
+			else if (typeName == "essentialcomm") 
+			{
+				Debug.Console(2, "Launch Essential Comm");
+				return new EssentialComm(key, name, properties);
+			}
+			else if (typeName == "essentialdsp")
+			{
+				Debug.Console(2, "Launch EssentialDsp");
+				return new EssentialDsp(key, name, properties);
+			}
+			else if (typeName == "essentialstvone")
+			{
+				Debug.Console(2, "Launch essentialstvone");
+				return new EssentialsTVOne(key, name, properties);
+			}
+			else if (typeName == "essentialslighting")
+			{
+				Debug.Console(2, "Launch essentialslighting");
+				return new EssentialsLightsBridge(key, name, properties);
+			}
+			else if (typeName == "eiscapi") 
+            {
+			    return new EiscApi(dc);
+			}
+			return null;
+			}
+		}
+	public class BridgeApiEisc {
+		public uint Ipid;
+		public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc; 
+		public BridgeApiEisc(string ipid) {
+			Ipid = (UInt32)int.Parse(ipid, System.Globalization.NumberStyles.HexNumber);
+			Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(Ipid, "127.0.0.2", Global.ControlSystem);
+			Eisc.Register();
+			Eisc.SigChange += Eisc_SigChange;
+			Debug.Console(2, "BridgeApiEisc Created at Ipid {0}", ipid);
+			}
+		void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args) {
+			if (Debug.Level >= 1)
+				Debug.Console(2, "DDVC EISC change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+			var uo = args.Sig.UserObject;
+			if (uo is Action<bool>)
+				(uo as Action<bool>)(args.Sig.BoolValue);
+			else if (uo is Action<ushort>)
+				(uo as Action<ushort>)(args.Sig.UShortValue);
+			else if (uo is Action<string>)
+				(uo as Action<string>)(args.Sig.StringValue);
+			}
+		}
+	
+	}
+
+
+	
+	

PepperDashEssentials/Bridges/CameraControllerBridge.cs

@@ -0,0 +1,187 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.Devices.Common;
+
+//namespace PepperDash.Essentials.Bridges
+//{
+//    public static class CameraControllerApiExtensions
+//    {
+
+//        public static BasicTriList _TriList;
+//        public static CameraControllerJoinMap JoinMap; 
+//        public static void LinkToApi(this PepperDash.Essentials.Devices.Common.Cameras.CameraBase cameraDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+//        {
+//            JoinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as CameraControllerJoinMap;
+			
+//            _TriList = trilist;
+//            if (JoinMap == null)
+//            {
+//                JoinMap = new CameraControllerJoinMap();
+//            }
+			
+//            JoinMap.OffsetJoinNumbers(joinStart);
+//            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+//            Debug.Console(0, "Linking to Bridge Type {0}", cameraDevice.GetType().Name.ToString());
+
+//            var commMonitor = cameraDevice as ICommunicationMonitor;
+//            commMonitor.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[JoinMap.IsOnline]);
+
+
+//            trilist.SetBoolSigAction(JoinMap.Left, (b) =>
+//                {
+//                    if (b)
+//                    {
+//                        cameraDevice.PanLeft();
+//                    }
+//                    else
+//                    {
+//                        cameraDevice.Stop();
+//                    }
+//                });
+//            trilist.SetBoolSigAction(JoinMap.Right, (b) =>
+//            {
+//                if (b)
+//                {
+//                    cameraDevice.PanRight();
+//                }
+//                else
+//                {
+//                    cameraDevice.Stop();
+//                }
+//            });
+
+//            trilist.SetBoolSigAction(JoinMap.Up, (b) =>
+//            {
+//                if (b)
+//                {
+//                    cameraDevice.TiltUp();
+//                }
+//                else
+//                {
+//                    cameraDevice.Stop();
+//                }
+//            });
+//            trilist.SetBoolSigAction(JoinMap.Down, (b) =>
+//            {
+//                if (b)
+//                {
+//                    cameraDevice.TiltDown();
+//                }
+//                else
+//                {
+//                    cameraDevice.Stop();
+//                }
+//            });
+
+//            trilist.SetBoolSigAction(JoinMap.ZoomIn, (b) =>
+//            {
+//                if (b)
+//                {
+//                    cameraDevice.ZoomIn();
+//                }
+//                else
+//                {
+//                    cameraDevice.Stop();
+//                }
+//            });
+
+//            trilist.SetBoolSigAction(JoinMap.ZoomOut, (b) =>
+//            {
+//                if (b)
+//                {
+//                    cameraDevice.ZoomOut();
+//                }
+//                else
+//                {
+//                    cameraDevice.Stop();
+//                }
+//            });
+
+
+//            if (cameraDevice.GetType().Name.ToString().ToLower() == "cameravisca")
+//            {
+//                var viscaCamera = cameraDevice as PepperDash.Essentials.Devices.Common.Cameras.CameraVisca;
+//                trilist.SetSigTrueAction(JoinMap.PowerOn, () => viscaCamera.PowerOn());
+//                trilist.SetSigTrueAction(JoinMap.PowerOff, () => viscaCamera.PowerOff());
+
+//                viscaCamera.PowerIsOnFeedback.LinkInputSig(trilist.BooleanInput[JoinMap.PowerOn]);
+//                viscaCamera.PowerIsOnFeedback.LinkComplementInputSig(trilist.BooleanInput[JoinMap.PowerOff]);
+
+//                viscaCamera.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[JoinMap.IsOnline]);
+//                for (int i = 0; i < JoinMap.NumberOfPresets; i++)
+//                    {	
+//                        int tempNum = i;
+//                        trilist.SetSigTrueAction((ushort)(JoinMap.PresetRecallOffset + tempNum), () =>
+//                            {
+//                                viscaCamera.RecallPreset(tempNum);
+//                            });
+//                        trilist.SetSigTrueAction((ushort)(JoinMap.PresetSaveOffset + tempNum), () =>
+//                        {
+//                            viscaCamera.SavePreset(tempNum);
+//                        });
+//                    }
+//            }
+
+			
+			
+//        }
+
+
+//    }
+//    public class CameraControllerJoinMap : JoinMapBase
+//    {
+//        public uint IsOnline { get; set; }
+//        public uint PowerOff { get; set; }
+//        public uint PowerOn { get; set; }
+//        public uint Up { get; set; }
+//        public uint Down { get; set; }
+//        public uint Left { get; set; }
+//        public uint Right { get; set; }
+//        public uint ZoomIn { get; set; }
+//        public uint ZoomOut { get; set; }
+//        public uint PresetRecallOffset { get; set; }
+//        public uint PresetSaveOffset { get; set; }
+//        public uint NumberOfPresets { get; set;  }
+
+//        public CameraControllerJoinMap()
+//        {
+//            // Digital
+//            IsOnline = 9;
+//            PowerOff = 8;
+//            PowerOn = 7;
+//            Up = 1;
+//            Down = 2;
+//            Left = 3;
+//            Right = 4;
+//            ZoomIn = 5;
+//            ZoomOut = 6;
+//            PresetRecallOffset = 10;
+//            PresetSaveOffset = 30;
+//            NumberOfPresets = 5;
+//            // Analog
+//        }
+
+//        public override void OffsetJoinNumbers(uint joinStart)
+//        {
+//            var joinOffset = joinStart - 1;
+
+//            IsOnline = IsOnline + joinOffset;
+//            PowerOff = PowerOff + joinOffset;
+//            PowerOn = PowerOn + joinOffset;
+//            Up = Up + joinOffset;
+//            Down = Down + joinOffset;
+//            Left = Left + joinOffset;
+//            Right = Right + joinOffset;
+//            ZoomIn = ZoomIn + joinOffset;
+//            ZoomOut = ZoomOut + joinOffset;
+//            PresetRecallOffset = PresetRecallOffset + joinOffset;
+//            PresetSaveOffset = PresetSaveOffset + joinOffset;
+//        }
+//    }
+//}

PepperDashEssentials/Bridges/DigitalLoggerBridge.cs

@@ -0,0 +1,77 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.Devices.Common;
+
+//namespace PepperDash.Essentials.Bridges
+//{
+//    public static class DigitalLoggerApiExtensions
+//    {
+//        public static void LinkToApi(this DigitalLogger DigitalLogger, BasicTriList trilist, uint joinStart, string joinMapKey)
+//        {
+//            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DigitalLoggerJoinMap;
+
+//            if (joinMap == null)
+//                joinMap = new DigitalLoggerJoinMap();
+
+//            joinMap.OffsetJoinNumbers(joinStart);
+//            Debug.Console(1, DigitalLogger, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+//            for (uint i = 1; i <= DigitalLogger.CircuitCount; i++)
+//            {
+//                var circuit = i;
+//                DigitalLogger.CircuitNameFeedbacks[circuit - 1].LinkInputSig(trilist.StringInput[joinMap.CircuitNames + circuit]);
+//                DigitalLogger.CircuitIsCritical[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitIsCritical + circuit]);
+//                DigitalLogger.CircuitState[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitState + circuit]);
+//                trilist.SetSigTrueAction(joinMap.CircuitCycle + circuit, () => DigitalLogger.CycleCircuit(circuit - 1));
+//                trilist.SetSigTrueAction(joinMap.CircuitOnCmd + circuit, () => DigitalLogger.TurnOnCircuit(circuit - 1));
+//                trilist.SetSigTrueAction(joinMap.CircuitOffCmd + circuit, () => DigitalLogger.TurnOffCircuit(circuit - 1));
+
+//            }
+//        }
+//    }
+//    public class DigitalLoggerJoinMap : JoinMapBase
+//    {
+//        public uint IsOnline { get; set; }
+//        public uint CircuitNames { get; set; }
+//        public uint CircuitState { get; set; }
+//        public uint CircuitCycle { get; set; }
+//        public uint CircuitIsCritical { get; set; }
+//        public uint CircuitOnCmd { get; set; }
+//        public uint CircuitOffCmd { get; set; }
+//        public DigitalLoggerJoinMap()
+//        {
+//            // Digital
+//            IsOnline = 9;
+//            CircuitState = 0;
+//            CircuitCycle = 0;
+//            CircuitIsCritical = 10;
+//            CircuitOnCmd = 10;
+//            CircuitOffCmd = 20;
+//            // Serial
+//            CircuitNames = 0;
+//            // Analog
+//        }
+
+//        public override void OffsetJoinNumbers(uint joinStart)
+//        {
+//            var joinOffset = joinStart - 1;
+
+//            IsOnline = IsOnline + joinOffset;
+//            CircuitNames = CircuitNames + joinOffset;
+//            CircuitState = CircuitState + joinOffset;
+//            CircuitCycle = CircuitCycle + joinOffset;
+//            CircuitIsCritical = CircuitIsCritical + joinOffset;
+//            CircuitOnCmd = CircuitOnCmd + joinOffset;
+//            CircuitOffCmd = CircuitOffCmd + joinOffset;
+
+
+
+//        }
+//    }
+
+//}

PepperDashEssentials/Bridges/DisplayControllerBridge.cs

@@ -0,0 +1,171 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.Devices.Common;
+
+//namespace PepperDash.Essentials.Bridges
+//{
+//    public static class DisplayControllerApiExtensions
+//    {
+
+//        public static BasicTriList _TriList;
+//        public static DisplayControllerJoinMap JoinMap;
+//        public static int InputNumber;
+//        public static IntFeedback InputNumberFeedback;
+//        public static List<string> InputKeys = new List<string>();
+//        public static void LinkToApi(this PepperDash.Essentials.Core.TwoWayDisplayBase displayDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+//        {
+//            JoinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DisplayControllerJoinMap;
+//            _TriList = trilist;
+
+//            if (JoinMap == null)
+//            {
+//                JoinMap = new DisplayControllerJoinMap();
+//            }
+			
+//            JoinMap.OffsetJoinNumbers(joinStart);
+//            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+//            Debug.Console(0, "Linking to Bridge Type {0}", displayDevice.GetType().Name.ToString());
+
+//            trilist.StringInput[JoinMap.Name].StringValue = displayDevice.GetType().Name.ToString();
+
+//            InputNumberFeedback = new IntFeedback(() => { return InputNumber;});
+//            InputNumberFeedback.LinkInputSig(trilist.UShortInput[JoinMap.InputSelect]);
+//            var commMonitor = displayDevice as ICommunicationMonitor;
+//            commMonitor.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[JoinMap.IsOnline]);
+			
+//            // Poewer Off
+//            trilist.SetSigTrueAction(JoinMap.PowerOff, () => 
+//                {
+//                    InputNumber = 102;
+//                    InputNumberFeedback.FireUpdate();
+//                    displayDevice.PowerOff();
+//                });
+
+//            displayDevice.PowerIsOnFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(PowerIsOnFeedback_OutputChange);
+//            displayDevice.PowerIsOnFeedback.LinkComplementInputSig(trilist.BooleanInput[JoinMap.PowerOff]);
+
+//            // Poewer On
+//            trilist.SetSigTrueAction(JoinMap.PowerOn, () => 
+//                {
+//                    InputNumber = 0;
+//                    InputNumberFeedback.FireUpdate();
+//                    displayDevice.PowerOn();
+//                }); 
+
+
+//            displayDevice.PowerIsOnFeedback.LinkInputSig(trilist.BooleanInput[JoinMap.PowerOn]);
+			
+//            int count = 1;
+//            foreach (var input in displayDevice.InputPorts)
+//            {
+//                InputKeys.Add(input.Key.ToString());
+//                var tempKey = InputKeys.ElementAt(count - 1);
+//                trilist.SetSigTrueAction((ushort)(JoinMap.InputSelectOffset + count), () => { displayDevice.ExecuteSwitch(displayDevice.InputPorts[tempKey].Selector); }); 
+//                trilist.StringInput[(ushort)(JoinMap.InputNamesOffset + count)].StringValue = input.Key.ToString();
+//                count++;
+//            }
+
+//            displayDevice.CurrentInputFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(CurrentInputFeedback_OutputChange);
+//            trilist.SetUShortSigAction(JoinMap.InputSelect, (a) =>
+//            {
+//                if (a == 0)
+//                {
+//                    displayDevice.PowerOff();
+//                    InputNumber = 0;
+//                }
+//                else if (a > 0 && a < displayDevice.InputPorts.Count && a != InputNumber)
+//                {
+//                    displayDevice.ExecuteSwitch(displayDevice.InputPorts.ElementAt(a - 1).Selector);
+//                    InputNumber = a;
+//                }
+//                else if (a == 102)
+//                {
+//                    displayDevice.PowerToggle();
+					
+//                }
+//                InputNumberFeedback.FireUpdate();
+//            });
+	
+//        }
+
+//        static void CurrentInputFeedback_OutputChange(object sender, FeedbackEventArgs e)
+//        {
+
+//            Debug.Console(0, "CurrentInputFeedback_OutputChange {0}", e.StringValue);
+
+//        }
+
+//        static void PowerIsOnFeedback_OutputChange(object sender, FeedbackEventArgs e)
+//        {
+
+//            // Debug.Console(0, "PowerIsOnFeedback_OutputChange {0}",  e.BoolValue);
+//            if (!e.BoolValue)
+//            {
+//                InputNumber = 102;
+//                InputNumberFeedback.FireUpdate();
+
+//            }
+//            else
+//            {
+//                InputNumber = 0;
+//                InputNumberFeedback.FireUpdate();
+//            }
+//        }
+
+
+
+
+//    }
+//    public class DisplayControllerJoinMap : JoinMapBase
+//    {
+//        public uint Name { get; set; }
+//        public uint InputNamesOffset { get; set; }
+//        public uint InputSelectOffset { get; set; } 
+//        public uint IsOnline { get; set; }
+//        public uint PowerOff { get; set; }
+//        public uint InputSelect { get; set; }
+//        public uint PowerOn { get; set; }
+//        public uint SelectScene { get; set; }
+//        public uint LightingSceneOffset { get; set; }
+//        public uint ButtonVisibilityOffset { get; set; }
+//        public uint IntegrationIdSet { get; set; }
+
+//        public DisplayControllerJoinMap()
+//        {
+//            // Digital
+//            IsOnline = 50;
+//            PowerOff = 1;
+//            PowerOn = 2;
+//            InputSelect = 4;
+//            IntegrationIdSet = 1;
+//            LightingSceneOffset = 10;
+//            ButtonVisibilityOffset = 40;
+//            Name = 1;
+//            InputNamesOffset = 10;
+//            InputSelectOffset = 4;
+//            // Analog
+//        }
+
+//        public override void OffsetJoinNumbers(uint joinStart)
+//        {
+//            var joinOffset = joinStart - 1;
+
+//            IsOnline = IsOnline + joinOffset;
+//            PowerOff = PowerOff + joinOffset;
+//            PowerOn = PowerOn + joinOffset;
+//            SelectScene = SelectScene + joinOffset;
+//            LightingSceneOffset = LightingSceneOffset + joinOffset;
+//            ButtonVisibilityOffset = ButtonVisibilityOffset + joinOffset;
+//            Name = Name + joinOffset;
+//            InputNamesOffset = InputNamesOffset + joinOffset;
+//            InputSelectOffset = InputSelectOffset + joinOffset;
+
+//        }
+//    }
+//}

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmChassisControllerApiExtentions 
+    {
+        public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmChassisControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmChassisControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+            // Link up outputs
+            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs - 1; i++)
+            {
+                var ioSlot = i;
+
+                // Control
+                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
+                trilist.SetUShortSigAction(joinMap.OutputAudio + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Audio)));
+				if (dmChassis.TxDictionary.ContainsKey(ioSlot))
+				{
+					Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
+					var TxKey = dmChassis.TxDictionary[ioSlot];
+					var TxDevice = DeviceManager.GetDeviceForKey(TxKey) as DmTxControllerBase;
+					TxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+					// TxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+					// trilist.SetUShortSigAction((ApiMap.HdcpSupport[ioSlot]), u => TxDevice.SetHdcpSupportAll((ePdtHdcpSupport)(u)));
+					// TxDevice.HdcpSupportAllFeedback.LinkInputSig(trilist.UShortInput[joinMap. + ioSlot]);
+					// trilist.UShortInput[ApiMap.HdcpSupportCapability[ioSlot]].UShortValue = TxDevice.HdcpSupportCapability;
+				}
+				else
+				{
+					// dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[ApiMap.TxVideoSyncStatus[ioSlot]]);
+				}
+				if (dmChassis.RxDictionary.ContainsKey(ioSlot))
+				{
+					Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
+					var RxKey = dmChassis.RxDictionary[ioSlot];
+					var RxDevice = DeviceManager.GetDeviceForKey(RxKey) as DmRmcControllerBase;
+					RxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+				}
+                // Feedback
+                dmChassis.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + ioSlot]);
+                dmChassis.AudioOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputAudio + ioSlot]);
+
+                 dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                dmChassis.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
+                dmChassis.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
+                dmChassis.OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames + ioSlot]);
+                dmChassis.OutputAudioRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentAudioInputNames + ioSlot]);
+              //  dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+               // dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+            }
+        }
+
+
+        public class DmChassisControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint OutputVideo { get; set; }
+            public uint OutputAudio { get; set; }
+            public uint VideoSyncStatus { get; set; }
+            public uint InputNames { get; set; }
+            public uint OutputNames { get; set; }
+            public uint OutputCurrentVideoInputNames { get; set; }
+            public uint OutputCurrentAudioInputNames { get; set; }
+            public uint InputCurrentResolution { get; set; }
+            public uint InputEndpointOnline { get; set; }
+            public uint OutputEndpointOnline { get; set; }
+            //public uint HdcpSupport { get; set; }
+            //public uint HdcpSupportCapability { get; set; }
+
+
+            public DmChassisControllerJoinMap()
+            {
+                IsOnline = 11;
+                OutputVideo = 100; //101-299
+                OutputAudio = 300; //301-499
+                VideoSyncStatus = 100; //101-299
+                InputNames = 100; //101-299
+                OutputNames = 300; //301-499
+                OutputCurrentVideoInputNames = 2000; //2001-2199
+                OutputCurrentAudioInputNames = 2200; //2201-2399
+                InputCurrentResolution = 2400; // 2401-2599
+                InputEndpointOnline = 500;
+                OutputEndpointOnline = 700;
+                //HdcpSupport = 1000; //1001-1199
+               //HdcpSupportCapability = 1200; //1201-1399
+
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                OutputVideo = OutputVideo + joinOffset;
+                OutputAudio = OutputAudio + joinOffset;
+                VideoSyncStatus = VideoSyncStatus + joinOffset;
+                InputNames = InputNames + joinOffset;
+                OutputNames = OutputNames + joinOffset;
+                OutputCurrentVideoInputNames = OutputCurrentVideoInputNames + joinOffset;
+                OutputCurrentAudioInputNames = OutputCurrentAudioInputNames + joinOffset;
+                InputCurrentResolution = InputCurrentResolution + joinOffset;
+                InputEndpointOnline = InputEndpointOnline + joinOffset;
+                OutputEndpointOnline = OutputEndpointOnline + joinOffset;
+                //HdcpSupport = HdcpSupport + joinOffset;
+                //HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DmRmcControllerBridge.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmRmcControllerApiExtensions
+    {
+        public static void LinkToApi(this DmRmcControllerBase rmc, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmRmcControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmRmcControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, rmc, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            rmc.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            if(rmc.VideoOutputResolutionFeedback != null)
+                rmc.VideoOutputResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentOutputResolution]);
+            if(rmc.EdidManufacturerFeedback != null)
+                rmc.EdidManufacturerFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidManufacturer]);
+            if(rmc.EdidNameFeedback != null)
+                rmc.EdidNameFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidName]);
+            if(rmc.EdidPreferredTimingFeedback != null)
+                rmc.EdidPreferredTimingFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidPrefferedTiming]);
+            if(rmc.EdidSerialNumberFeedback != null)
+                rmc.EdidSerialNumberFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidSerialNumber]);
+        }
+
+        public class DmRmcControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint CurrentOutputResolution { get; set; }
+            public uint EdidManufacturer { get; set; }
+            public uint EdidName { get; set; }
+            public uint EdidPrefferedTiming { get; set; }
+            public uint EdidSerialNumber { get; set; }
+
+            public DmRmcControllerJoinMap()
+            {
+                // Digital
+                IsOnline = 1;
+
+                // Serial
+                CurrentOutputResolution = 1;
+                EdidManufacturer = 2;
+                EdidName = 3;
+                EdidPrefferedTiming = 4;
+                EdidSerialNumber = 5;
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                CurrentOutputResolution = CurrentOutputResolution + joinOffset;
+                EdidManufacturer = EdidManufacturer + joinOffset;
+                EdidName = EdidName + joinOffset;
+                EdidPrefferedTiming = EdidPrefferedTiming + joinOffset;
+                EdidSerialNumber = EdidSerialNumber + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DmTxControllerBridge.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmTxControllerApiExtensions
+    {
+        public static void LinkToApi(this DmTxControllerBase tx, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmTxControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmTxControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, tx, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            tx.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            tx.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus]);
+            tx.AnyVideoInput.VideoStatus.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution]);
+            //tx.HdcpSupportAllFeedback.LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportCapability]);
+
+            bool hdcpTypeSimple;
+
+            if (tx.Hardware is DmTx4kX02CBase || tx.Hardware is DmTx4kzX02CBase)
+                hdcpTypeSimple = false;
+            else
+                hdcpTypeSimple = true;
+
+            if (tx is ITxRouting)
+            {
+                var txR = tx as ITxRouting;
+
+                trilist.SetUShortSigAction(joinMap.VideoInput,
+                    new Action<ushort>(i => txR.ExecuteNumericSwitch(i, 0, eRoutingSignalType.Video)));
+                trilist.SetUShortSigAction(joinMap.AudioInput,
+                    new Action<ushort>(i => txR.ExecuteNumericSwitch(i, 0, eRoutingSignalType.Audio)));
+
+                txR.VideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoInput]);
+                txR.AudioSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioInput]);
+
+                trilist.UShortInput[joinMap.HdcpSupportCapability].UShortValue = (ushort)tx.HdcpSupportCapability;
+
+                if(txR.InputPorts[DmPortName.HdmiIn] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn];
+
+                    if (tx.Feedbacks["HdmiInHdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiInHdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port1HdcpState, trilist);
+                    }
+                }
+                
+                if (txR.InputPorts[DmPortName.HdmiIn1] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn1];
+
+                    if (tx.Feedbacks["HdmiIn1HdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiIn1HdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port1HdcpState, trilist);
+                    }
+                }
+
+                if (txR.InputPorts[DmPortName.HdmiIn2] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn2];
+
+                    if (tx.Feedbacks["HdmiIn2HdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiIn2HdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port2HdcpState, trilist);
+                    }
+                }
+
+            }
+        }
+
+        static void SetHdcpCapabilityAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist)
+        {
+            if (hdcpTypeSimple)
+            {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s =>
+                    {
+                        if (s == 0)
+                        {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0)
+                        {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else
+            {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(s =>
+                        {
+                            port.HdcpCapability = (eHdcpCapabilityType)s;
+                        }));
+            }
+        }
+
+        public class DmTxControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint VideoSyncStatus { get; set; }
+            public uint CurrentInputResolution { get; set; }
+            public uint HdcpSupportCapability { get; set; }
+            public uint VideoInput { get; set; }
+            public uint AudioInput { get; set; }
+            public uint Port1HdcpState { get; set; }
+            public uint Port2HdcpState { get; set; }
+
+
+            public DmTxControllerJoinMap()
+            {
+                // Digital
+                IsOnline = 1;
+                VideoSyncStatus = 2;
+                // Serial
+                CurrentInputResolution = 1;
+                // Analog
+                VideoInput = 1;
+                AudioInput = 2;
+                HdcpSupportCapability = 3;
+                Port1HdcpState = 4;
+                Port2HdcpState = 5;
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                VideoSyncStatus = VideoSyncStatus + joinOffset;
+                CurrentInputResolution = CurrentInputResolution + joinOffset;
+                VideoInput = VideoInput + joinOffset;
+                AudioInput = AudioInput + joinOffset;
+                HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+                Port1HdcpState = Port1HdcpState + joinOffset;
+                Port2HdcpState = Port2HdcpState + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DspControllerBridge.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Devices.Common;
+
+namespace PepperDash.Essentials.Bridges
+{
+	public static class SamsungDisplayControllerApiExtensions
+	{
+		public static void LinkToApi(this PepperDash.Essentials.Core.TwoWayDisplayBase displayDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+		{
+			var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DisplayControllerJoinMap;
+
+			if (joinMap == null)
+			{
+				joinMap = new DisplayControllerJoinMap();
+			}
+
+			joinMap.OffsetJoinNumbers(joinStart);
+			Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+			Debug.Console(0, "Linking to lighting Type {0}", displayDevice.GetType().Name.ToString());
+
+			var commMonitor = displayDevice as ICommunicationMonitor;
+			commMonitor.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+			
+
+			// Poewer Off
+			trilist.SetSigTrueAction(joinMap.PowerOff, () => displayDevice.PowerOff());
+			displayDevice.PowerIsOnFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.PowerOff]);
+
+			// Poewer On
+			trilist.SetSigTrueAction(joinMap.PowerOn, () => displayDevice.PowerOn());
+			displayDevice.PowerIsOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PowerOn]);
+			
+			// GenericLighitng Actions & FeedBack
+
+			// int sceneIndex = 1;
+			/*
+			foreach (var scene in displayDevice.LightingScenes)
+			{
+				var tempIndex = sceneIndex - 1;
+				//trilist.SetSigTrueAction((uint)(joinMap.LightingSceneOffset + sceneIndex), () => displayDevice.SelectScene(displayDevice.LightingScenes[tempIndex]));
+				scene.IsActiveFeedback.LinkInputSig(trilist.BooleanInput[(uint)(joinMap.LightingSceneOffset + sceneIndex)]);
+				trilist.StringInput[(uint)(joinMap.LightingSceneOffset + sceneIndex)].StringValue = scene.Name;
+				trilist.BooleanInput[(uint)(joinMap.ButtonVisibilityOffset + sceneIndex)].BoolValue = true;
+				sceneIndex++;
+			}
+
+			if (displayDevice.GetType().Name.ToString() == "LutronQuantumArea")
+			{
+				var lutronDevice = displayDevice as PepperDash.Essentials.Devices.Common.Environment.Lutron.LutronQuantumArea;
+				lutronDevice.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+				trilist.SetStringSigAction(joinMap.IntegrationIdSet, s => lutronDevice.IntegrationId = s);
+			}
+			*/ 
+			//ApiEisc.Eisc.SetStringSigAction(ApiMap.integrationID, (s) => { lutronLights.IntegrationId = s; });
+
+
+			/*
+			var lutronLights = displayDevice as PepperDash.Essentials.Devices.Common.Environment.Lutron.LutronQuantumArea;
+
+			
+			for (uint i = 1; i <= lightingBase.CircuitCount; i++)
+            {
+                var circuit = i;
+				lightingBase.CircuitNameFeedbacks[circuit - 1].LinkInputSig(trilist.StringInput[joinMap.CircuitNames + circuit]);
+				lightingBase.CircuitIsCritical[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitIsCritical + circuit]);
+				lightingBase.CircuitState[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitState + circuit]);
+				trilist.SetSigTrueAction(joinMap.CircuitCycle + circuit, () => lightingBase.CycleCircuit(circuit - 1));
+				trilist.SetSigTrueAction(joinMap.CircuitOnCmd + circuit, () => lightingBase.TurnOnCircuit(circuit - 1));
+				trilist.SetSigTrueAction(joinMap.CircuitOffCmd + circuit, () => lightingBase.TurnOffCircuit(circuit - 1));
+
+			}
+			 */ 
+		}
+	}
+	public class DisplayControllerJoinMap : JoinMapBase
+	{
+		public uint IsOnline { get; set; }
+		public uint PowerOff { get; set; }
+		public uint PowerOn { get; set; }
+		public uint SelectScene { get; set; }
+		public uint LightingSceneOffset { get; set; }
+		public uint ButtonVisibilityOffset { get; set; }
+		public uint IntegrationIdSet { get; set; }
+
+		public DisplayControllerJoinMap()
+		{
+			// Digital
+			IsOnline = 1;
+			PowerOff = 1;
+			PowerOn = 2;
+			SelectScene = 1;
+			IntegrationIdSet = 1;
+			LightingSceneOffset = 10;
+			ButtonVisibilityOffset = 40;
+			// Analog
+		}
+
+		public override void OffsetJoinNumbers(uint joinStart)
+		{
+			var joinOffset = joinStart - 1;
+
+			IsOnline = IsOnline + joinOffset;
+			PowerOff = PowerOff + joinOffset;
+			PowerOn = PowerOn + joinOffset;
+			SelectScene = SelectScene + joinOffset;
+			LightingSceneOffset = LightingSceneOffset + joinOffset;
+			ButtonVisibilityOffset = ButtonVisibilityOffset + joinOffset;
+			
+
+
+		}
+	}
+}

PepperDashEssentials/Bridges/EssentialComms.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+using Crestron.SimplSharpPro.CrestronThread;
+
+namespace PepperDash.Essentials {
+	public class EssentialCommConfig {
+		public string[] EiscApiIpids;
+		public EssentialCommCommConnectionConfigs[] CommConnections;
+		}
+	public class EssentialCommCommConnectionConfigs {
+		public uint joinNumber {get; set; }
+		public EssentialsControlPropertiesConfig control { get; set; }
+		}
+
+	public class EssentialCommsPort {
+		public IBasicCommunication Comm;
+		public IntFeedback StatusFeedback;
+		public BoolFeedback ConnectedFeedback;
+		public List<EssentialComApiMap> Outputs = new List<EssentialComApiMap>();
+		public String RxBuffer;
+		public EssentialCommsPort(EssentialsControlPropertiesConfig config, string keyPrefix) {
+			Comm = CommFactory.CreateCommForConfig(config, keyPrefix);
+			// var PortGather = new CommunicationGather(Comm, config.EndOfLineChar);
+			Comm.TextReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(Communication_TextReceived);
+
+			var socket = Comm as ISocketStatus;
+			StatusFeedback = new IntFeedback(() => { return (int)socket.ClientStatus; });
+			ConnectedFeedback = new BoolFeedback(() => { return Comm.IsConnected; });
+
+			if (socket != null) {
+				socket.ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(socket_ConnectionChange);
+				} else {
+				}
+
+			}
+		void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e) {
+			StatusFeedback.FireUpdate();
+			ConnectedFeedback.FireUpdate();
+			if (e.Client.IsConnected) {
+				// Tasks on connect
+				} else {
+				// Cleanup items from this session
+				}
+			}
+		void Communication_TextReceived(object sender, GenericCommMethodReceiveTextArgs args) {
+			try {
+				foreach (var Output in Outputs) {
+					Output.Api.Eisc.StringInput[Output.Join].StringValue = args.Text;
+					}
+
+				}
+			catch (Exception) {
+				throw new FormatException(string.Format("ERROR:{0}"));
+				}
+			}
+		}
+		
+	public class EssentialComm : Device {
+		public EssentialCommConfig Properties;
+		
+		public CommunicationGather PortGather { get; private set; }
+		public List<BridgeApiEisc> Apis {get; set;}
+		public Dictionary<string, StringFeedback> CommFeedbacks {get; private set; }
+		public StatusMonitorBase CommunicationMonitor { get; private set; }
+		public Dictionary<uint, EssentialCommsPort> CommDictionary { get; private set; }
+
+		public EssentialComm(string key, string name, JToken properties) : base(key, name) {
+			Properties = JsonConvert.DeserializeObject<EssentialCommConfig>(properties.ToString());
+			CommFeedbacks = new Dictionary<string, StringFeedback>();
+			CommDictionary = new Dictionary<uint, EssentialCommsPort>();
+			Apis = new List<BridgeApiEisc>();
+							int commNumber = 1;
+				foreach (var commConfig in Properties.CommConnections) {
+					var commPort = new EssentialCommsPort(commConfig.control, string.Format("{0}-{1}", this.Key, commConfig.joinNumber));
+					CommDictionary.Add(commConfig.joinNumber, commPort);
+
+					commNumber++;
+					}
+
+				foreach (var Ipid in Properties.EiscApiIpids) {
+					var ApiEisc = new BridgeApiEisc(Ipid);
+					Apis.Add(ApiEisc);
+					foreach (var commConnection in CommDictionary) {
+						Debug.Console(2, "Joining Api{0} to comm {1}", Ipid, commConnection.Key);
+						var tempComm = commConnection.Value;
+						var tempJoin = (uint)commConnection.Key;
+						EssentialComApiMap ApiMap = new EssentialComApiMap(ApiEisc, (uint)tempJoin);
+
+						tempComm.Outputs.Add(ApiMap);
+						// Check for ApiMap Overide Values here
+
+						ApiEisc.Eisc.SetBoolSigAction(tempJoin, b => {if (b) { tempComm.Comm.Connect(); } else { tempComm.Comm.Disconnect(); }});
+						ApiEisc.Eisc.SetStringSigAction(tempJoin, s => tempComm.Comm.SendText(s));
+
+						tempComm.StatusFeedback.LinkInputSig(ApiEisc.Eisc.UShortInput[tempJoin]);
+						tempComm.ConnectedFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[tempJoin]);
+
+
+
+						}
+					ApiEisc.Eisc.Register();
+					}
+		    }
+
+
+
+        public override bool CustomActivate()
+        {
+			try {
+
+
+					
+				Debug.Console(2, "Name {0} Activated", this.Name);
+				return true;
+				}
+			catch (Exception e) {
+				Debug.Console(0, "Bridge {0}", e);
+				return false;
+				}
+        }
+
+
+		}
+	public class EssentialComApiMap {
+		public uint Join;
+		public BridgeApiEisc Api;
+		public uint connectJoin; 
+		public  EssentialComApiMap(BridgeApiEisc api, uint join) {
+			Join = join;
+			Api = api;
+			}
+		}
+	}

PepperDashEssentials/Bridges/EssentialDM.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.DM;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+using Crestron.SimplSharpPro.DM;
+
+namespace PepperDash.Essentials {
+	public class EssentialDM : PepperDash.Core.Device {
+		public EssentialDMProperties Properties;
+		public List<BridgeApiEisc> BridgeApiEiscs;
+		private PepperDash.Essentials.DM.DmChassisController DmSwitch;
+		private EssentialDMApiMap ApiMap = new EssentialDMApiMap();
+		public EssentialDM(string key, string name, JToken properties)
+			: base(key, name) {
+			Properties = JsonConvert.DeserializeObject<EssentialDMProperties>(properties.ToString());
+
+
+			}
+		public override bool CustomActivate() {
+			// Create EiscApis 
+			try {
+				foreach (var device in DeviceManager.AllDevices) {
+					if (device.Key == this.Properties.connectionDeviceKey) {
+						Debug.Console(2, "deviceKey {0} Matches", device.Key);
+						DmSwitch = DeviceManager.GetDeviceForKey(device.Key) as PepperDash.Essentials.DM.DmChassisController;
+
+						} 
+					
+
+					else 	{
+						Debug.Console(2, "deviceKey {0} doesn't match", device.Key);
+						}
+					}
+				if (Properties.EiscApiIpids != null) {
+
+					
+					foreach (string Ipid in Properties.EiscApiIpids) {
+						var ApiEisc = new BridgeApiEisc(Ipid);
+						for (uint x = 1; x <= DmSwitch.Chassis.NumberOfInputs;x++ ) {
+							uint tempX = x;
+							Debug.Console(2, "Creating EiscActions {0}", tempX);
+
+
+							ApiEisc.Eisc.SetUShortSigAction(ApiMap.OutputVideoRoutes[tempX], u => DmSwitch.ExecuteSwitch(u, tempX, eRoutingSignalType.Video));
+							ApiEisc.Eisc.SetUShortSigAction(ApiMap.OutputAudioRoutes[tempX], u => DmSwitch.ExecuteSwitch(u, tempX, eRoutingSignalType.Audio));
+
+
+                            if (DmSwitch.TxDictionary.ContainsKey(tempX)) {
+								Debug.Console(2, "Creating Tx Feedbacks {0}", tempX);
+								var TxKey = DmSwitch.TxDictionary[tempX];
+								var TxDevice = DeviceManager.GetDeviceForKey(TxKey) as DmTxControllerBase;
+								TxDevice.IsOnline.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.TxOnlineStatus[tempX]]);
+								TxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.TxVideoSyncStatus[tempX]]);
+								ApiEisc.Eisc.SetUShortSigAction((ApiMap.HdcpSupport[tempX]), u => TxDevice.SetHdcpSupportAll((ePdtHdcpSupport)(u)));
+								TxDevice.HdcpSupportAllFeedback.LinkInputSig(ApiEisc.Eisc.UShortInput[ApiMap.HdcpSupport[tempX]]);
+								ApiEisc.Eisc.UShortInput[ApiMap.HdcpSupportCapability[tempX]].UShortValue = TxDevice.HdcpSupportCapability;
+								} 
+							else {
+								DmSwitch.VideoInputSyncFeedbacks[tempX].LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.TxVideoSyncStatus[tempX]]);
+								}
+							if (DmSwitch.RxDictionary.ContainsKey(tempX)) {
+								Debug.Console(2, "Creating Rx Feedbacks {0}", tempX);
+								var RxKey = DmSwitch.RxDictionary[tempX];
+								var RxDevice = DeviceManager.GetDeviceForKey(RxKey) as DmRmcControllerBase;
+								RxDevice.IsOnline.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.RxOnlineStatus[tempX]]);
+								}
+							// DmSwitch.InputEndpointOnlineFeedbacks[(ushort)tempOutputNum].LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.OutputVideoRoutes[tempOutputNum]]);
+							DmSwitch.VideoOutputFeedbacks[(ushort)tempX].LinkInputSig(ApiEisc.Eisc.UShortInput[ApiMap.OutputVideoRoutes[tempX]]);
+							DmSwitch.AudioOutputFeedbacks[(ushort)tempX].LinkInputSig(ApiEisc.Eisc.UShortInput[ApiMap.OutputAudioRoutes[tempX]]);
+							DmSwitch.InputNameFeedbacks[(ushort)tempX].LinkInputSig(ApiEisc.Eisc.StringInput[ApiMap.InputNames[tempX]]);
+							DmSwitch.OutputNameFeedbacks[(ushort)tempX].LinkInputSig(ApiEisc.Eisc.StringInput[ApiMap.OutputNames[tempX]]);
+							DmSwitch.OutputRouteNameFeedbacks[(ushort)tempX].LinkInputSig(ApiEisc.Eisc.StringInput[ApiMap.OutputRouteNames[tempX]]);
+							}
+						DmSwitch.IsOnline.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.ChassisOnline]);
+						ApiEisc.Eisc.Register();
+						}
+					}
+
+
+
+				Debug.Console(2, "Name {0} Activated", this.Name);
+				return true;
+				}
+			catch (Exception e) {
+				Debug.Console(2, "BRidge {0}", e);
+				return false;
+				}
+			}
+		}
+	public class EssentialDMProperties {
+		public string connectionDeviceKey;
+		public string[] EiscApiIpids;
+
+
+		}
+
+
+	public class EssentialDMApiMap {
+		public ushort ChassisOnline = 11;
+		public Dictionary<uint, ushort> OutputVideoRoutes;
+		public Dictionary<uint, ushort> OutputAudioRoutes;
+		public Dictionary<uint, ushort> TxOnlineStatus;
+		public Dictionary<uint, ushort> RxOnlineStatus;
+		public Dictionary<uint, ushort> TxVideoSyncStatus;
+		public Dictionary<uint, ushort> InputNames;
+		public Dictionary<uint, ushort> OutputNames;
+		public Dictionary<uint, ushort> OutputRouteNames;
+		public Dictionary<uint, ushort> HdcpSupport;
+		public Dictionary<uint, ushort> HdcpSupportCapability;
+
+		public EssentialDMApiMap() {
+			OutputVideoRoutes = new Dictionary<uint, ushort>();
+			OutputAudioRoutes = new Dictionary<uint, ushort>();
+			TxOnlineStatus = new Dictionary<uint, ushort>();
+			RxOnlineStatus = new Dictionary<uint, ushort>();
+			TxVideoSyncStatus = new Dictionary<uint, ushort>();
+			InputNames = new Dictionary<uint, ushort>();
+			OutputNames = new Dictionary<uint, ushort>();
+			OutputRouteNames = new Dictionary<uint, ushort>();
+			HdcpSupport = new Dictionary<uint, ushort>();
+			HdcpSupportCapability = new Dictionary<uint, ushort>();
+
+			for (uint x = 1; x <= 200; x++) {
+				// Debug.Console(0, "Init Value {0}", x);
+				uint tempNum = x;
+				HdcpSupportCapability[tempNum] = (ushort)(tempNum + 1200);
+				HdcpSupport[tempNum] = (ushort)(tempNum + 1000);
+				OutputVideoRoutes[tempNum] = (ushort)(tempNum + 100);
+				OutputAudioRoutes[tempNum] = (ushort)(tempNum + 300);
+				TxOnlineStatus[tempNum] = (ushort)(tempNum + 500);
+				RxOnlineStatus[tempNum] = (ushort)(tempNum + 700);
+				TxVideoSyncStatus[tempNum] = (ushort)(tempNum + 100);
+				InputNames[tempNum] = (ushort)(tempNum + 100);
+				OutputNames[tempNum] = (ushort)(tempNum + 300);
+				OutputRouteNames[tempNum] = (ushort)(tempNum + 2000);
+				}
+			}
+		}
+	}
+	

PepperDashEssentials/Bridges/EssentialDsp.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.DM;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+using Crestron.SimplSharpPro.DM;
+
+namespace PepperDash.Essentials {
+	public class EssentialDsp : PepperDash.Core.Device {
+		public EssentialDspProperties Properties;
+		public List<BridgeApiEisc> BridgeApiEiscs;
+		private PepperDash.Essentials.Devices.Common.DSP.QscDsp Dsp;
+		private EssentialDspApiMap ApiMap = new EssentialDspApiMap();
+		public EssentialDsp(string key, string name, JToken properties)
+			: base(key, name) {
+			Properties = JsonConvert.DeserializeObject<EssentialDspProperties>(properties.ToString());
+
+
+			}
+		public override bool CustomActivate() {
+			// Create EiscApis 
+
+			try
+			{
+				ICommunicationMonitor comm = null;
+				foreach (var device in DeviceManager.AllDevices) 
+				{
+					if (device.Key == this.Properties.connectionDeviceKey) 
+					{
+						if (!(device is ICommunicationMonitor))
+						{
+							comm = device as ICommunicationMonitor;
+						}
+						Debug.Console(2, "deviceKey {0} Matches", device.Key);
+						Dsp = DeviceManager.GetDeviceForKey(device.Key) as PepperDash.Essentials.Devices.Common.DSP.QscDsp;
+						break;
+					} 
+					else 	
+					{
+						Debug.Console(2, "deviceKey {0} doesn't match", device.Key);
+						
+					}
+				}
+				if (Properties.EiscApiIpids != null && Dsp != null)
+				{
+					foreach (string Ipid in Properties.EiscApiIpids)
+					{
+						var ApiEisc = new BridgeApiEisc(Ipid);
+						Debug.Console(2, "Connecting EiscApi {0} to {1}", ApiEisc.Ipid, Dsp.Name);
+						ushort x = 1;
+						if (comm != null)
+						{
+							comm.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.Online]);
+						}
+						foreach (var channel in Dsp.LevelControlPoints)
+						{
+							//var QscChannel = channel.Value as PepperDash.Essentials.Devices.Common.DSP.QscDspLevelControl;
+							Debug.Console(2, "QscChannel {0} connect", x);
+								
+							var genericChannel = channel.Value as IBasicVolumeWithFeedback;
+							if (channel.Value.Enabled)
+							{
+								ApiEisc.Eisc.StringInput[ApiMap.channelName[x]].StringValue = channel.Value.LevelCustomName;
+								ApiEisc.Eisc.UShortInput[ApiMap.channelType[x]].UShortValue = (ushort)channel.Value.Type;
+
+								genericChannel.MuteFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.channelMuteToggle[x]]);
+								genericChannel.VolumeLevelFeedback.LinkInputSig(ApiEisc.Eisc.UShortInput[ApiMap.channelVolume[x]]);
+
+								ApiEisc.Eisc.SetSigTrueAction(ApiMap.channelMuteToggle[x], () => genericChannel.MuteToggle());
+								ApiEisc.Eisc.SetSigTrueAction(ApiMap.channelMuteOn[x], () => genericChannel.MuteOn());
+								ApiEisc.Eisc.SetSigTrueAction(ApiMap.channelMuteOff[x], () => genericChannel.MuteOff());
+
+								ApiEisc.Eisc.SetBoolSigAction(ApiMap.channelVolumeUp[x], b => genericChannel.VolumeUp(b));
+								ApiEisc.Eisc.SetBoolSigAction(ApiMap.channelVolumeDown[x], b => genericChannel.VolumeDown(b));
+
+								ApiEisc.Eisc.SetUShortSigAction(ApiMap.channelVolume[x], u => genericChannel.SetVolume(u));
+								ApiEisc.Eisc.SetStringSigAction(ApiMap.presetString, s => Dsp.RunPreset(s));
+							}
+							x++;
+
+						}
+						x = 1;
+						foreach (var preset in Dsp.PresetList)
+						{
+							ApiEisc.Eisc.StringInput[ApiMap.presets[x]].StringValue = preset.label;
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.presets[x], () => Dsp.RunPresetNumber(x));
+							x++;
+						}
+						foreach (var dialer in Dsp.Dialers)
+						{
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad0, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num0));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad1, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num1));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad2, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num2));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad3, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num3));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad4, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num4));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad5, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num5));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad6, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num6));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad7, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num7));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad8, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num8));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Keypad9, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Num9));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.KeypadStar, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Star));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.KeypadPound, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Pound));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.KeypadClear, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Clear));
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.KeypadBackspace, () => dialer.Value.SendKeypad(PepperDash.Essentials.Devices.Common.DSP.QscDspDialer.eKeypadKeys.Backspace));
+
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.Dial, () => dialer.Value.Dial());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.DoNotDisturbToggle, () => dialer.Value.DoNotDisturbToggle());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.DoNotDisturbOn, () => dialer.Value.DoNotDisturbOn());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.DoNotDisturbOff, () => dialer.Value.DoNotDisturbOff());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.AutoAnswerToggle, () => dialer.Value.AutoAnswerToggle());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.AutoAnswerOn, () => dialer.Value.AutoAnswerOn());
+							ApiEisc.Eisc.SetSigTrueAction(ApiMap.AutoAnswerOff, () => dialer.Value.AutoAnswerOff());
+
+							dialer.Value.DoNotDisturbFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.DoNotDisturbToggle]);
+							dialer.Value.DoNotDisturbFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.DoNotDisturbOn]);
+							dialer.Value.DoNotDisturbFeedback.LinkComplementInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.DoNotDisturbOff]);
+
+							dialer.Value.AutoAnswerFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.AutoAnswerToggle]);
+							dialer.Value.AutoAnswerFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.AutoAnswerOn]);
+							dialer.Value.AutoAnswerFeedback.LinkComplementInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.AutoAnswerOff]);
+
+							dialer.Value.OffHookFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.Dial]);
+							dialer.Value.DialStringFeedback.LinkInputSig(ApiEisc.Eisc.StringInput[ApiMap.DialString]);
+						}
+					}
+				}
+
+				
+
+
+				Debug.Console(2, "Name {0} Activated", this.Name);
+				return true;
+				}
+			catch (Exception e) {
+				Debug.Console(0, "Bridge {0}", e);
+				return false;
+				}
+			}
+		}
+	public class EssentialDspProperties {
+		public string connectionDeviceKey;
+		public string[] EiscApiIpids;
+
+
+		}
+
+
+	public class EssentialDspApiMap {
+		public ushort Online = 1;
+		public ushort presetString = 2000;
+		public Dictionary<uint, ushort> channelMuteToggle;
+		public Dictionary<uint, ushort> channelMuteOn;
+		public Dictionary<uint, ushort> channelMuteOff;
+		public Dictionary<uint, ushort> channelVolume;
+		public Dictionary<uint, ushort> channelType;
+		public Dictionary<uint, ushort> channelName;
+		public Dictionary<uint, ushort> channelVolumeUp;
+		public Dictionary<uint, ushort> channelVolumeDown;
+		public Dictionary<uint, ushort> presets;
+		public ushort DialString = 3100;
+		public ushort Keypad0 = 3110;
+		public ushort Keypad1 = 3111;
+		public ushort Keypad2 = 3112;
+		public ushort Keypad3 = 3113;
+		public ushort Keypad4 = 3114;
+		public ushort Keypad5 = 3115;
+		public ushort Keypad6 = 3116;
+		public ushort Keypad7 = 3117;
+		public ushort Keypad8 = 3118;
+		public ushort Keypad9 = 3119;
+		public ushort KeypadStar = 3120;
+		public ushort KeypadPound = 3121;
+		public ushort KeypadClear = 3122;
+		public ushort KeypadBackspace = 3123;
+		public ushort Dial = 3124;
+		public ushort DoNotDisturbToggle = 3132;
+		public ushort DoNotDisturbOn = 3133;
+		public ushort DoNotDisturbOff = 3134;
+		public ushort AutoAnswerToggle = 3127;
+		public ushort AutoAnswerOn = 3125;
+		public ushort AutoAnswerOff = 3126;
+
+		public EssentialDspApiMap() {
+			channelMuteToggle = new Dictionary<uint, ushort>();
+			channelMuteOn = new Dictionary<uint, ushort>();
+			channelMuteOff = new Dictionary<uint, ushort>();
+			channelVolume = new Dictionary<uint, ushort>();
+			channelName = new Dictionary<uint, ushort>();
+			channelType = new Dictionary<uint, ushort>();
+			presets = new Dictionary<uint, ushort>();
+			channelVolumeUp = new Dictionary<uint, ushort>();
+			channelVolumeDown = new Dictionary<uint, ushort>();
+			for (uint x = 1; x <= 100; x++) {
+				uint tempNum = x;
+				presets[tempNum] = (ushort)(tempNum + 100);
+				channelMuteToggle[tempNum] = (ushort)(tempNum + 400);
+				channelMuteOn[tempNum] = (ushort)(tempNum + 600);
+				channelMuteOff[tempNum] = (ushort)(tempNum + 800);
+				channelVolume[tempNum] = (ushort)(tempNum + 200);
+				channelName[tempNum] = (ushort)(tempNum + 200);
+				channelType[tempNum] = (ushort)(tempNum + 400);
+				channelVolumeUp[tempNum] = (ushort)(tempNum + 1000);
+				channelVolumeDown[tempNum] = (ushort)(tempNum + 1200);
+				}
+			}
+		}
+	}
+	

PepperDashEssentials/Bridges/EssentialTVOne.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.DM;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+using Crestron.SimplSharpPro.DM;
+
+namespace PepperDash.Essentials
+{
+	public class EssentialsTVOne : PepperDash.Core.Device
+	{
+		public EssentialTVOneProperties Properties;
+		public List<BridgeApiEisc> BridgeApiEiscs;
+		private PepperDash.Essentials.Devices.Common.TVOneCorio TVOneCorio;
+		private EssentialsTVOneApiMap ApiMap = new EssentialsTVOneApiMap();
+		public EssentialsTVOne(string key, string name, JToken properties)
+			: base(key, name)
+		{
+			Properties = JsonConvert.DeserializeObject<EssentialTVOneProperties>(properties.ToString());
+
+
+		}
+		public override bool CustomActivate() {
+			// Create EiscApis 
+			try
+			{
+				foreach (var device in DeviceManager.AllDevices) 
+				{
+					if (device.Key == this.Properties.connectionDeviceKey) 
+					{
+						Debug.Console(2, "deviceKey {0} Matches", device.Key);
+						TVOneCorio = DeviceManager.GetDeviceForKey(device.Key) as PepperDash.Essentials.Devices.Common.TVOneCorio;
+						break;
+					}	
+					else 	
+					{
+						Debug.Console(2, "deviceKey {0} doesn't match", device.Key);
+						
+					}
+				}
+				if (Properties.EiscApiIpids != null && TVOneCorio != null)
+				{
+					foreach (string Ipid in Properties.EiscApiIpids)
+					{
+						var ApiEisc = new BridgeApiEisc(Ipid);
+						Debug.Console(2, "Connecting EiscApi {0} to {1}", ApiEisc.Ipid, TVOneCorio.Name);
+						ushort x = 1;
+						TVOneCorio.OnlineFeedback.LinkInputSig(ApiEisc.Eisc.BooleanInput[ApiMap.Online]);
+						ApiEisc.Eisc.SetUShortSigAction(ApiMap.CallPreset, u => TVOneCorio.CallPreset(u));
+						TVOneCorio.PresetFeedback.LinkInputSig(ApiEisc.Eisc.UShortInput[ApiMap.PresetFeedback]);
+
+					}
+				}
+
+				
+
+
+				Debug.Console(2, "Name {0} Activated", this.Name);
+				return true;
+				}
+			catch (Exception e) {
+				Debug.Console(0, "Bridge {0}", e);
+				return false;
+				}
+			}
+	}
+	public class EssentialTVOneProperties
+	{
+		public string connectionDeviceKey;
+		public string[] EiscApiIpids;
+
+
+	}
+
+
+	public class EssentialsTVOneApiMap
+	{
+		public ushort CallPreset = 1;
+		public ushort PresetFeedback = 1;
+		public ushort Online = 1;
+
+		public EssentialsTVOneApiMap()
+		{
+
+
+		}
+
+	}
+}

PepperDashEssentials/Bridges/GenericLightingBridge.cs

@@ -0,0 +1,103 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.Devices.Common;
+
+//namespace PepperDash.Essentials.Bridges
+//{
+//    public static class GenericLightingApiExtensions
+//    {
+//        public static void LinkToApi(this PepperDash.Essentials.Core.Lighting.LightingBase lightingDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+//        {
+//            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as GenericLightingJoinMap;
+
+//            if (joinMap == null)
+//                joinMap = new GenericLightingJoinMap();
+
+//            joinMap.OffsetJoinNumbers(joinStart);
+//            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			
+
+//            Debug.Console(0, "Linking to lighting Type {0}", lightingDevice.GetType().Name.ToString());
+			
+//            // GenericLighitng Actions & FeedBack
+//            trilist.SetUShortSigAction(joinMap.SelectScene, u => lightingDevice.SelectScene(lightingDevice.LightingScenes[u]));
+			
+//            int sceneIndex = 1;
+//            foreach (var scene in lightingDevice.LightingScenes)
+//            {
+//                var tempIndex = sceneIndex - 1;
+//                trilist.SetSigTrueAction((uint)(joinMap.LightingSceneOffset + sceneIndex), () => lightingDevice.SelectScene(lightingDevice.LightingScenes[tempIndex]));
+//                scene.IsActiveFeedback.LinkInputSig(trilist.BooleanInput[(uint)(joinMap.LightingSceneOffset + sceneIndex)]);
+//                trilist.StringInput[(uint)(joinMap.LightingSceneOffset + sceneIndex)].StringValue = scene.Name;
+//                trilist.BooleanInput[(uint)(joinMap.ButtonVisibilityOffset + sceneIndex)].BoolValue = true;
+//                sceneIndex++;
+//            }
+
+//            if (lightingDevice.GetType().Name.ToString() == "LutronQuantumArea")
+//            {
+//                var lutronDevice = lightingDevice as PepperDash.Essentials.Devices.Common.Environment.Lutron.LutronQuantumArea;
+//                lutronDevice.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+//                trilist.SetStringSigAction(joinMap.IntegrationIdSet, s => lutronDevice.IntegrationId = s);
+//            }
+
+//            //ApiEisc.Eisc.SetStringSigAction(ApiMap.integrationID, (s) => { lutronLights.IntegrationId = s; });
+
+
+//            /*
+//            var lutronLights = lightingDevice as PepperDash.Essentials.Devices.Common.Environment.Lutron.LutronQuantumArea;
+
+			
+//            for (uint i = 1; i <= lightingBase.CircuitCount; i++)
+//            {
+//                var circuit = i;
+//                lightingBase.CircuitNameFeedbacks[circuit - 1].LinkInputSig(trilist.StringInput[joinMap.CircuitNames + circuit]);
+//                lightingBase.CircuitIsCritical[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitIsCritical + circuit]);
+//                lightingBase.CircuitState[circuit - 1].LinkInputSig(trilist.BooleanInput[joinMap.CircuitState + circuit]);
+//                trilist.SetSigTrueAction(joinMap.CircuitCycle + circuit, () => lightingBase.CycleCircuit(circuit - 1));
+//                trilist.SetSigTrueAction(joinMap.CircuitOnCmd + circuit, () => lightingBase.TurnOnCircuit(circuit - 1));
+//                trilist.SetSigTrueAction(joinMap.CircuitOffCmd + circuit, () => lightingBase.TurnOffCircuit(circuit - 1));
+
+//            }
+//             */ 
+//        }
+//    }
+//    public class GenericLightingJoinMap : JoinMapBase
+//    {
+//        public uint IsOnline { get; set; }
+//        public uint SelectScene { get; set; }
+//        public uint LightingSceneOffset { get; set; }
+//        public uint ButtonVisibilityOffset { get; set; }
+//        public uint IntegrationIdSet { get; set; }
+
+//        public GenericLightingJoinMap()
+//        {
+//            // Digital
+//            IsOnline = 1;
+//            SelectScene = 1;
+//            IntegrationIdSet = 1;
+//            LightingSceneOffset = 10;
+//            ButtonVisibilityOffset = 40;
+//            // Analog
+//        }
+
+//        public override void OffsetJoinNumbers(uint joinStart)
+//        {
+//            var joinOffset = joinStart - 1;
+
+//            IsOnline = IsOnline + joinOffset;
+//            SelectScene = SelectScene + joinOffset;
+//            LightingSceneOffset = LightingSceneOffset + joinOffset;
+//            ButtonVisibilityOffset = ButtonVisibilityOffset + joinOffset;
+			
+
+
+//        }
+//    }
+//}

PepperDashEssentials/Bridges/GenericRelayDeviceBridge.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.CrestronIO;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class GenericRelayDeviceApiExtensions
+    {
+        public static void LinkToApi(this GenericRelayDevice relay, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as GenericRelayControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new GenericRelayControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            if (relay.RelayOutput == null)
+            {
+                Debug.Console(1, relay, "Unable to link device '{0}'.  Relay is null", relay.Key);
+                return;
+            }
+
+            Debug.Console(1, relay, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            trilist.SetBoolSigAction(joinMap.Relay, new Action<bool>(b =>
+                {
+                    if (b)
+                        relay.CloseRelay();
+                    else
+                        relay.OpenRelay();
+                }));
+
+            // feedback for relay state
+
+            relay.OutputIsOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Relay]);
+        }
+
+    }
+
+    public class GenericRelayControllerJoinMap : JoinMapBase
+    {
+        //Digital
+        public uint Relay { get; set; }
+
+        public GenericRelayControllerJoinMap()
+        {
+            Relay = 1;
+        }
+
+        public override void  OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            Relay = Relay + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/IBasicCommunicationBridge.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IBasicCommunicationApiExtensions
+    {
+        public static void LinkToApi(this GenericComm comm, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as IBasicCommunicationJoinMap;
+
+            if (joinMap == null)
+                joinMap = new IBasicCommunicationJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            if (comm.CommPort == null)
+            {
+                Debug.Console(1, comm, "Unable to link device '{0}'.  CommPort is null", comm.Key);
+                return;
+            }
+
+            Debug.Console(1, comm, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            // this is a permanent event handler. This cannot be -= from event
+			comm.CommPort.TextReceived += (s, a) =>
+			{
+				Debug.Console(2, comm, "RX: {0}", a.Text);
+				trilist.SetString(joinMap.TextReceived, a.Text);
+			};
+            trilist.SetStringSigAction(joinMap.SendText, new Action<string>(s => comm.CommPort.SendText(s)));
+            trilist.SetStringSigAction(joinMap.SetPortConfig + 1, new Action<string>(s => comm.SetPortConfig(s)));
+        
+
+            var sComm = comm.CommPort as ISocketStatus;
+            if (sComm != null)
+            {
+                sComm.ConnectionChange += (s, a) =>
+                {
+                    trilist.SetUshort(joinMap.Status, (ushort)(a.Client.ClientStatus));
+                    trilist.SetBool(joinMap.Connected, a.Client.ClientStatus ==
+                        Crestron.SimplSharp.CrestronSockets.SocketStatus.SOCKET_STATUS_CONNECTED);
+                };
+
+                trilist.SetBoolSigAction(joinMap.Connect, new Action<bool>(b =>
+                {
+                    if (b)
+                    {
+                        sComm.Connect();
+                    }
+                    else
+                    {
+                        sComm.Disconnect();
+                    }
+                }));
+            }
+        }
+
+
+
+        public class IBasicCommunicationJoinMap : JoinMapBase
+        {
+            //Digital
+            public uint Connect { get; set; }
+            public uint Connected { get; set; }
+
+            //Analog
+            public uint Status { get; set; }
+
+            // Serial
+            public uint TextReceived { get; set; }
+            public uint SendText { get; set; }
+            public uint SetPortConfig { get; set; }
+
+
+            public IBasicCommunicationJoinMap()
+            {
+                TextReceived = 1;
+                SendText = 1;
+                SetPortConfig = 2;
+                Connect = 1;
+                Connected = 1;
+                Status = 1;
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                TextReceived = TextReceived + joinOffset;
+                SendText = SendText + joinOffset;
+                SetPortConfig = SetPortConfig + joinOffset;
+                Connect = Connect + joinOffset;
+                Connected = Connected + joinOffset;
+                Status = Status + joinOffset;
+            }
+        }
+    }
+
+}

PepperDashEssentials/Bridges/IDigitalInputBridge.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.CrestronIO;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IDigitalInputApiExtenstions
+    {
+        public static void LinkToApi(this IDigitalInput input, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as IDigitalInputApiJoinMap;
+
+            if (joinMap == null)
+                joinMap = new IDigitalInputApiJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            try
+            {
+                Debug.Console(1, input as Device, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                input.InputStateFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputState]);
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, input as Device, "Unable to link device '{0}'.  Input is null", (input as Device).Key);
+                Debug.Console(1, input as Device, "Error: {0}", e);
+                return;
+            }
+        }
+
+        
+    }
+
+    public class IDigitalInputApiJoinMap : JoinMapBase
+    {
+        //Digital
+        public uint InputState { get; set; }
+
+        public IDigitalInputApiJoinMap()
+        {
+            InputState = 1;
+        }
+
+        public override void  OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            InputState = InputState + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMapBase.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class JoinMapHelper
+    {
+        /// <summary>
+        /// Attempts to get the join map from config
+        /// </summary>
+        /// <param name="joinMapKey"></param>
+        /// <returns></returns>
+        public static JoinMapBase GetJoinMapForDevice(string joinMapKey)
+        {
+            if (!string.IsNullOrEmpty(joinMapKey))
+                return null;
+
+            // FUTURE TODO: Get the join map from the ConfigReader.ConfigObject 
+
+            return null;
+        }
+    }
+
+
+    public abstract class JoinMapBase
+    {
+        /// <summary>
+        /// Modifies all the join numbers by adding the offset.  This should never be called twice
+        /// </summary>
+        /// <param name="joinStart"></param>
+        public abstract void OffsetJoinNumbers(uint joinStart);
+
+
+    }
+
+
+}

PepperDashEssentials/Bridges/SystemMonitorBridge.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.Diagnostics;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Monitoring;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class SystemMonitorBridge
+    {
+        public static void LinkToApi(this SystemMonitorController systemMonitorController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as SystemMonitorJoinMap;
+
+            if (joinMap == null)
+                joinMap = new SystemMonitorJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            //Debug.Console(1, systemMonitorController, "Linking API starting at join: {0}", joinStart);
+
+            systemMonitorController.TimeZoneFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeZone]);
+            //trilist.SetUShortSigAction(joinMap.TimeZone, new Action<ushort>(u => systemMonitorController.SetTimeZone(u)));
+            systemMonitorController.TimeZoneTextFeedback.LinkInputSig(trilist.StringInput[joinMap.TimeZoneName]);
+
+            systemMonitorController.IOControllerVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.IOControllerVersion]);
+            systemMonitorController.SnmpVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.SnmpAppVersion]);
+            systemMonitorController.BACnetAppVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.BACnetAppVersion]);
+            systemMonitorController.ControllerVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.ControllerVersion]);
+
+
+            // iterate the program status feedback collection and map all the joins
+            var programSlotJoinStart = joinMap.ProgramStartJoin;
+
+            foreach (var p in systemMonitorController.ProgramStatusFeedbackCollection)
+            {
+
+                // TODO: link feedbacks for each program slot
+                var programNumber = p.Value.Program.Number;
+
+                //Debug.Console(1, systemMonitorController, "Linking API for Program Slot: {0} starting at join: {1}", programNumber, programSlotJoinStart);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramStart, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].OperatingState = eProgramOperatingState.Start));
+                p.Value.ProgramStartedFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramStart]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramStop, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].OperatingState = eProgramOperatingState.Stop));
+                p.Value.ProgramStoppedFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramStop]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramRegister, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Register));
+                p.Value.ProgramRegisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramRegister]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramUnregister, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Unregister));
+                p.Value.ProgramUnregisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramUnregister]);
+
+                programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin;
+            }
+
+        }
+
+
+    }
+
+    public class SystemMonitorJoinMap : JoinMapBase
+    {
+        /// <summary>
+        /// Offset to indicate where the range of iterated program joins will start
+        /// </summary>
+        public uint ProgramStartJoin { get; set; }
+
+        /// <summary>
+        /// Offset between each program join set
+        /// </summary>
+        public uint ProgramOffsetJoin { get; set; }
+
+        //Digital
+        public uint ProgramStart { get; set; }
+        public uint ProgramStop { get; set; }
+        public uint ProgramRegister { get; set; }
+        public uint ProgramUnregister { get; set; }
+
+        //Analog
+        public uint TimeZone { get; set; }
+
+        //Serial
+        public uint TimeZoneName { get; set; }
+        public uint IOControllerVersion { get; set; }
+        public uint SnmpAppVersion { get; set; }
+        public uint BACnetAppVersion { get; set; }
+        public uint ControllerVersion { get; set; }
+
+        public uint ProgramName { get; set; }
+        public uint ProgramCompiledTime { get; set; }
+        public uint ProgramCrestronDatabaseVersion { get; set; }
+        public uint ProgramEnvironmentVersion { get; set; }
+        public uint AggregatedProgramInfo { get; set; }
+
+        public SystemMonitorJoinMap()
+        {
+            TimeZone = 1;
+
+            TimeZoneName = 1;
+            IOControllerVersion = 2;
+            SnmpAppVersion = 3;
+            BACnetAppVersion = 4;
+            ControllerVersion = 5;
+
+            
+            ProgramStartJoin = 10;
+            
+            ProgramOffsetJoin = 5;
+
+            // Offset in groups of 5 joins
+            ProgramStart = 1;
+            ProgramStop = 2;
+            ProgramRegister = 3;
+            ProgramUnregister = 4;
+
+            ProgramName = 1;
+            ProgramCompiledTime = 2;
+            ProgramCrestronDatabaseVersion = 3;
+            ProgramEnvironmentVersion = 4;
+            AggregatedProgramInfo = 5;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            TimeZone = TimeZone + joinOffset;
+
+            TimeZoneName = TimeZoneName + joinOffset;
+            IOControllerVersion = IOControllerVersion + joinOffset;
+            SnmpAppVersion = SnmpAppVersion + joinOffset;
+            BACnetAppVersion = BACnetAppVersion + joinOffset;
+            ControllerVersion = ControllerVersion + joinOffset;
+
+            // Sets the initial join value where the iterated program joins will begin
+            ProgramStartJoin = ProgramStartJoin + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Config/ConfigReader.cs

@@ -1,188 +0,0 @@
-using System;
-using System.Linq;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
-
-namespace PepperDash.Essentials
-{
-	/// <summary>
-	/// Loads the ConfigObject from the file
-	/// </summary>
-	public class ConfigReader
-	{
-		public static EssentialsConfig ConfigObject { get; private set; }
-
-		public static bool LoadConfig2()
-		{
-			Debug.Console(0, Debug.ErrorLogLevel.Notice, "Loading unmerged system/template portal configuration file.");
-			try
-			{
-                var filePath = Global.FilePathPrefix + "configurationFile.json";
-
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to load config file: '{0}'", filePath);
-
-                if (!File.Exists(filePath))
-				{
-                        Debug.Console(0, Debug.ErrorLogLevel.Error, 
-                            "ERROR: Configuration file not present. Please load file to {0} and reset program", filePath);
-                        return false;
-				}
-
-				using (StreamReader fs = new StreamReader(filePath))
-				{
-					var doubleObj = JObject.Parse(fs.ReadToEnd());
-					ConfigObject = MergeConfigs(doubleObj).ToObject<EssentialsConfig>();
-
-                    // Extract SystemUrl and TemplateUrl into final config output
-
-                    if (doubleObj["system_url"] != null)
-                    {
-                        ConfigObject.SystemUrl = doubleObj["system_url"].Value<string>();
-                    }
-
-                    if (doubleObj["template_url"] != null)
-                    {
-                        ConfigObject.TemplateUrl= doubleObj["template_url"].Value<string>();
-                    }
-				}
-
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Successfully Loaded Merged Config");
-
-				return true;
-			}
-			catch (Exception e)
-			{
-                Debug.Console(0, Debug.ErrorLogLevel.Error, "ERROR: Config load failed: \r{0}", e);
-				return false;
-			}
-		}
-
-
-		static JObject MergeConfigs(JObject doubleConfig)
-		{
-			var system = JObject.FromObject(doubleConfig["system"]);
-			var template = JObject.FromObject(doubleConfig["template"]);
-			var merged = new JObject();
-
-			// Put together top-level objects
-			// skip any objects that don't have template objects
-
-			if (system["info"] != null)
-				merged.Add("info", Merge(template["info"], system["info"]));
-			else
-				merged.Add("info", template["info"]);
-
-			merged.Add("devices", MergeArraysOnTopLevelProperty(template["devices"] as JArray, 
-                system["devices"] as JArray, "uid"));
-
-			if (template["rooms"] != null)
-			{
-				if (system["rooms"] == null)
-					merged.Add("rooms", template["rooms"]);
-				else
-					merged.Add("rooms", MergeArraysOnTopLevelProperty(template["rooms"] as JArray,
-						system["rooms"] as JArray, "key"));
-			}
-
-			if (template["sourceLists"] != null)
-			{
-				if (system["sourceLists"] == null)
-					merged.Add("sourceLists", template["sourceLists"]);
-				else
-					merged.Add("sourceLists", Merge(template["sourceLists"], system["sourceLists"]));
-			}
-
-            // Template tie lines take precdence.  Config tool doesn't do them at system
-            // level anyway...
-			if (template["tieLines"] != null)
-				merged.Add("tieLines", template["tieLines"]);
-			//else if (system["tieLines"] != null)
-			//    merged.Add("tieLines", system["tieLines"]);
-			//else
-			//    merged.Add("tieLines", new JArray());
-
-			Debug.Console(2, "MERGED CONFIG RESULT: \x0d\x0a{0}", merged);
-			return merged;
-		}
-
-		/// <summary>
-		/// Merges the contents of a base and a delta array, matching the entries on a top-level property
-		/// given by propertyName.  Returns a merge of them. Items in the delta array that do not have
-		/// a matched item in base array will not be merged. 
-		/// </summary>
-		static JArray MergeArraysOnTopLevelProperty(JArray a1, JArray a2, string propertyName)
-		{
-			var result = new JArray();
-			if (a2 == null)
-				result = a1;
-			else if (a1 != null)
-			{
-				for (int i = 0; i < a1.Count(); i++)
-				{
-					var a1Dev = a1[i];
-					// Try to get a system device and if found, merge it onto template
-					var a2Match = a2.FirstOrDefault(t => t[propertyName].Equals(a1Dev[propertyName]));// t.Value<int>("uid") == tmplDev.Value<int>("uid"));
-					if (a2Match != null)
-					{
-						var mergedItem = Merge(a1Dev, a2Match);// Merge(JObject.FromObject(a1Dev), JObject.FromObject(a2Match));
-						result.Add(mergedItem);
-					}
-					else
-						result.Add(a1Dev);
-				}
-			}
-			return result;
-		}
-
-
-		/// <summary>
-		/// Helper for using with JTokens.  Converts to JObject 
-		/// </summary>
-		static JObject Merge(JToken t1, JToken t2)
-		{
-			return Merge(JObject.FromObject(t1), JObject.FromObject(t2));
-		}
-
-		/// <summary>
-		/// Merge b ONTO a
-		/// </summary>
-		/// <param name="a"></param>
-		/// <param name="b"></param>
-		static JObject Merge(JObject o1, JObject o2)
-		{
-			foreach (var o2Prop in o2)
-			{
-				var o1Value = o1[o2Prop.Key];
-				if (o1Value == null)
-					o1.Add(o2Prop.Key, o2Prop.Value);
-				else
-				{
-					JToken replacement = null;
-					if (o2Prop.Value.HasValues && o1Value.HasValues) // Drill down
-						replacement = Merge(JObject.FromObject(o1Value), JObject.FromObject(o2Prop.Value));
-					else
-						replacement = o2Prop.Value;
-					o1[o2Prop.Key].Replace(replacement);
-				}
-			}
-			return o1;
-		}
-
-		/// <summary>
-		/// Returns the group for a given device key in config
-		/// </summary>
-		/// <param name="key"></param>
-		/// <returns></returns>
-        public static string GetGroupForDeviceKey(string key)
-        {
-            var dev = ConfigObject.Devices.FirstOrDefault(d => d.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
-            return dev == null ? null : dev.Group;
-        }
-
-	}
-}

PepperDashEssentials/Config/EssentialsConfig.cs

@@ -1,69 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text.RegularExpressions;
-
-using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Room.Config;
-
-namespace PepperDash.Essentials
-{
-	/// <summary>
-	/// Loads the ConfigObject from the file
-	/// </summary>
-	public class EssentialsConfig : BasicConfig
-	{
-		[JsonProperty("system_url")]
-        public string SystemUrl { get; set; }
-
-		[JsonProperty("template_url")]
-        public string TemplateUrl { get; set; }
-
-
-		//public CotijaConfig Cotija { get; private set; }
-
-		[JsonProperty("systemUuid")]
-		public string SystemUuid
-        {
-            get
-            {
-				if (string.IsNullOrEmpty(SystemUrl))
-					return "missing url";
-
-                var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
-            }
-        }
-
-		[JsonProperty("templateUuid")]
-		public string TemplateUuid
-        {
-            get
-            {
-				if (string.IsNullOrEmpty(TemplateUrl))
-					return "missing template url";
-       
-				var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
-            }
-        }
-
-		[JsonProperty("rooms")]
-		public List<EssentialsRoomConfig> Rooms { get; set; }
-	}
-		
-	/// <summary>
-	/// 
-	/// </summary>
-	public class SystemTemplateConfigs
-	{
-		public EssentialsConfig System { get; set; }
-
-		public EssentialsConfig Template { get; set; }
-	}
-}

PepperDashEssentials/Configuration Original/Factories/DmFactory.cs

@@ -80,6 +80,16 @@ namespace PepperDash.Essentials
 					var dm = new DmMd8x8(ipId, Global.ControlSystem);
 					//dev = new DmChassisController(devKey, devName, dm);
 				}
+				else if (devType.Equals("dmmd16x16", StringComparison.OrdinalIgnoreCase))
+				{
+					var dm = new DmMd16x16(ipId, Global.ControlSystem);
+					//dev = new DmChassisController(devKey, devName, dm);
+				}
+				else if (devType.Equals("dmmd32x32", StringComparison.OrdinalIgnoreCase))
+				{
+					var dm = new DmMd32x32(ipId, Global.ControlSystem);
+					//dev = new DmChassisController(devKey, devName, dm);
+				}
 			}
 			catch (Exception e)
 			{

PepperDashEssentials/ControlSystem.cs

@@ -4,11 +4,15 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.CrestronThread;
+using Crestron.SimplSharpPro.Diagnostics;
+
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.DM;
 using PepperDash.Essentials.Fusion;
+using PepperDash.Essentials.Room.Config;
 using PepperDash.Essentials.Room.Cotija;
 
 namespace PepperDash.Essentials
@@ -35,6 +39,7 @@ namespace PepperDash.Essentials
             //CrestronConsole.AddNewConsoleCommand(s => GoWithLoad(), "go", "Loads configuration file",
             //    ConsoleAccessLevelEnum.AccessOperator);
 
+           // CrestronConsole.AddNewConsoleCommand(S => { ConfigWriter.WriteConfigFile(null); }, "writeconfig", "writes the current config to a file", ConsoleAccessLevelEnum.AccessOperator);
 			CrestronConsole.AddNewConsoleCommand(s =>
 			{
 				Debug.Console(0, Debug.ErrorLogLevel.Notice, "CONSOLE MESSAGE: {0}", s);
@@ -86,20 +91,40 @@ namespace PepperDash.Essentials
 
             directoryPrefix = Crestron.SimplSharp.CrestronIO.Directory.GetApplicationRootDirectory();
 
-            //directoryPrefix = "";
+            if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)   // Handles 3-series running Windows OS
-
-            if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)
             {
-                filePathPrefix = directoryPrefix + dirSeparator + "NVRAM" 
-                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
-
                 Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", versionString);
-            }
-            else
-            {
-                filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
 
+                // Check if User/ProgramX exists
+                if(Directory.Exists(directoryPrefix + dirSeparator + "User" 
+                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber)))
+                {
+                    Debug.Console(0, @"User/program{0} directory found", InitialParametersClass.ApplicationNumber);
+                    filePathPrefix = directoryPrefix + dirSeparator + "User" 
+                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
+                }
+                // Check if Nvram/Programx exists
+                else if (Directory.Exists(directoryPrefix + dirSeparator + "Nvram"
+                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber)))
+                {
+                    Debug.Console(0, @"Nvram/program{0} directory found", InitialParametersClass.ApplicationNumber);
+                    filePathPrefix = directoryPrefix + dirSeparator + "Nvram"
+                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
+                }
+                // If neither exists, set path to User/ProgramX
+                else
+                {
+                    Debug.Console(0, @"No previous directory found.  Using User/program{0}", InitialParametersClass.ApplicationNumber);
+                    filePathPrefix = directoryPrefix + dirSeparator + "User"
+                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
+                }
+            }
+            else   // Handles Linux OS (Virtual Control)
+            {
                 Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", versionString);
+
+                // Set path to User/
+                filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
             }
 
             Global.SetFilePathPrefix(filePathPrefix);
@@ -142,16 +167,22 @@ namespace PepperDash.Essentials
 						"------------------------------------------------\r" +
 						"------------------------------------------------");
 				}
+
             }
 			catch (Exception e)
 			{
 				Debug.Console(0, "FATAL INITIALIZE ERROR. System is in an inconsistent state:\r{0}", e);
+
+
 			}
 
+            // Notify the 
+            SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
+
 		}
 
 		/// <summary>
-		/// Verifies filesystem is set up. IR, SGD, and program1 folders
+		/// Verifies filesystem is set up. IR, SGD, and programX folders
 		/// </summary>
 		bool SetupFilesystem()
 		{
@@ -204,16 +235,39 @@ namespace PepperDash.Essentials
 			LoadLogoServer();
 
 			DeviceManager.ActivateAll();
+
+            LinkSystemMonitorToAppServer();
 		}
 
+        void LinkSystemMonitorToAppServer()
+        {
+            var sysMon = DeviceManager.GetDeviceForKey("systemMonitor") as PepperDash.Essentials.Core.Monitoring.SystemMonitorController;
+
+            var appServer = DeviceManager.GetDeviceForKey("appServer") as CotijaSystemController;
+
+
+            if (sysMon != null && appServer != null)
+            {
+                var key = sysMon.Key + "-" + appServer.Key;
+                var messenger = new PepperDash.Essentials.AppServer.Messengers.SystemMonitorMessenger
+                    (key, sysMon, "/device/systemMonitor");
+
+                messenger.RegisterWithAppServer(appServer);
+
+                DeviceManager.AddDevice(messenger);                  
+            }
+        }
 
 		/// <summary>
 		/// Reads all devices from config and adds them to DeviceManager
 		/// </summary>
 		public void LoadDevices()
 		{
-            // Build the processor wrapper class
+			// Build the processor wrapper class
-            DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
+			DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
+
+            // Add global System Monitor device
+            DeviceManager.AddDevice(new PepperDash.Essentials.Core.Monitoring.SystemMonitorController("systemMonitor"));
 
 			foreach (var devConf in ConfigReader.ConfigObject.Devices)
 			{
@@ -232,17 +286,23 @@ namespace PepperDash.Essentials
                         continue;
                     }
 
-					// Try local factory first
+					// Try local factories first
 					var newDev = DeviceFactory.GetDevice(devConf);
 
+                    if (newDev == null)
+                        newDev = BridgeFactory.GetDevice(devConf);
+
 					// Then associated library factories
+                    if (newDev == null)
+                        newDev = PepperDash.Essentials.Core.DeviceFactory.GetDevice(devConf);
 					if (newDev == null)
 						newDev = PepperDash.Essentials.Devices.Common.DeviceFactory.GetDevice(devConf);
 					if (newDev == null)
 						newDev = PepperDash.Essentials.DM.DeviceFactory.GetDevice(devConf);
 					if (newDev == null)
 						newDev = PepperDash.Essentials.Devices.Displays.DisplayDeviceFactory.GetDevice(devConf);
-
+					if (newDev == null)
+						newDev = PepperDash.Essentials.BridgeFactory.GetDevice(devConf);
 					if (newDev != null)
 						DeviceManager.AddDevice(newDev);
 					else
@@ -257,6 +317,7 @@ namespace PepperDash.Essentials
 
 		}
 
+
 		/// <summary>
 		/// Helper method to load tie lines.  This should run after devices have loaded
 		/// </summary>
@@ -296,7 +357,7 @@ namespace PepperDash.Essentials
 
 			foreach (var roomConfig in ConfigReader.ConfigObject.Rooms)
 			{
-				var room = roomConfig.GetRoomObject() as EssentialsRoomBase;
+                var room = EssentialsRoomConfigHelper.GetRoomObject(roomConfig) as EssentialsRoomBase;
 				if (room != null)
 				{
                     if (room is EssentialsHuddleSpaceRoom)

PepperDashEssentials/ControlSystem.cs.orig

@@ -1,367 +0,0 @@
-using System;
-using System.Linq;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.CrestronThread;
-using PepperDash.Core;
-using PepperDash.Core.PortalSync;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Devices.Common;
-using PepperDash.Essentials.DM;
-using PepperDash.Essentials.Fusion;
-using PepperDash.Essentials.Room.Cotija;
-
-namespace PepperDash.Essentials
-{
-	public class ControlSystem : CrestronControlSystem
-	{
-		PepperDashPortalSyncClient PortalSync;
-        HttpLogoServer LogoServer;
-
-		public ControlSystem()
-			: base()
-		{
-			Thread.MaxNumberOfUserThreads = 400;
-			Global.ControlSystem = this;
-			DeviceManager.Initialize(this);        
-		}
-
-		/// <summary>
-		/// Git 'er goin'
-		/// </summary>
-		public override void InitializeSystem()
-		{
-<<<<<<< HEAD
-            DeterminePlatform();
-
-            //CrestronConsole.AddNewConsoleCommand(s => GoWithLoad(), "go", "Loads configuration file",
-            //    ConsoleAccessLevelEnum.AccessOperator);
-=======
-            CrestronConsole.AddNewConsoleCommand(s => GoWithLoad(), "go", "Loads configuration file",
-                ConsoleAccessLevelEnum.AccessOperator);
->>>>>>> 600b9f11ff1bbc186f7c2a2945955731b3523b3c
-
-            CrestronConsole.AddNewConsoleCommand(s =>
-            {
-                foreach (var tl in TieLineCollection.Default)
-                    CrestronConsole.ConsoleCommandResponse("  {0}\r", tl);
-            },
-            "listtielines", "Prints out all tie lines", ConsoleAccessLevelEnum.AccessOperator);
-
-			CrestronConsole.AddNewConsoleCommand(s =>
-			{
-				CrestronConsole.ConsoleCommandResponse
-					("Current running configuration. This is the merged system and template configuration");
-				CrestronConsole.ConsoleCommandResponse(Newtonsoft.Json.JsonConvert.SerializeObject
-					(ConfigReader.ConfigObject, Newtonsoft.Json.Formatting.Indented));
-			}, "showconfig", "Shows the current running merged config", ConsoleAccessLevelEnum.AccessOperator);
-
-			CrestronConsole.AddNewConsoleCommand(s =>
-				{
-					CrestronConsole.ConsoleCommandResponse("This system can be found at the following URLs:\r" +
-						"System URL:   {0}\r" +
-						"Template URL: {1}", ConfigReader.ConfigObject.SystemUrl, ConfigReader.ConfigObject.TemplateUrl);
-				}, "portalinfo", "Shows portal URLS from configuration", ConsoleAccessLevelEnum.AccessOperator);
-
-            //GoWithLoad();
-		}
-
-        /// <summary>
-        /// Determines if the program is running on a processor (appliance) or server (XiO Edge).
-        /// 
-        /// Sets Global.FilePathPrefix based on platform
-        /// </summary>
-        public void DeterminePlatform()
-        {
-            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Determining Platform....");
-
-            string filePathPrefix;
-
-            var dirSeparator = Global.DirectorySeparator;
-
-            var version = Crestron.SimplSharp.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
-
-            var versionString = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
-
-            string directoryPrefix;
-
-            //directoryPrefix = Crestron.SimplSharp.CrestronIO.Directory.GetApplicationRootDirectory();
-#warning ^ For use with beta Include4.dat for XiO Edge
-            directoryPrefix = "";
-
-            if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)
-            {
-                filePathPrefix = directoryPrefix + dirSeparator + "NVRAM" 
-                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
-
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", versionString);
-            }
-            else
-            {
-                filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
-
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on XiO Edge Server", versionString);
-            }
-
-            Global.SetFilePathPrefix(filePathPrefix);
-        }
-
-		/// <summary>
-		/// Do it, yo
-		/// </summary>
-		public void GoWithLoad()
-		{
-			try
-			{
-                CrestronConsole.AddNewConsoleCommand(EnablePortalSync, "portalsync", "Loads Portal Sync",
-                    ConsoleAccessLevelEnum.AccessOperator);
-
-                //PortalSync = new PepperDashPortalSyncClient();
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials load from configuration");
-
-				var filesReady = SetupFilesystem();
-				if (filesReady)
-				{
-                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Folder structure verified. Loading config...");
-					if (!ConfigReader.LoadConfig2())
-						return;
-
-					Load();
-                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Essentials load complete\r" +
-						"-------------------------------------------------------------");
-				}
-				else
-				{
-					Debug.Console(0,
-						"------------------------------------------------\r" +
-						"------------------------------------------------\r" +
-						"------------------------------------------------\r" +
-						"Essentials file structure setup completed.\r" +
-						"Please load config, sgd and ir files and\r" +
-						"restart program.\r" +
-						"------------------------------------------------\r" +
-						"------------------------------------------------\r" +
-						"------------------------------------------------");
-				}
-            }
-			catch (Exception e)
-			{
-				Debug.Console(0, "FATAL INITIALIZE ERROR. System is in an inconsistent state:\r{0}", e);
-			}
-
-		}
-
-		/// <summary>
-		/// Verifies filesystem is set up. IR, SGD, and program1 folders
-		/// </summary>
-		bool SetupFilesystem()
-		{
-			Debug.Console(0, "Verifying and/or creating folder structure");
-			var configDir = Global.FilePathPrefix;
-			var configExists = Directory.Exists(configDir);
-			if (!configExists)
-				Directory.Create(configDir);
-
-			var irDir = Global.FilePathPrefix + "ir";
-			if (!Directory.Exists(irDir))
-				Directory.Create(irDir);
-
-            var sgdDir = Global.FilePathPrefix + "sgd";
-			if (!Directory.Exists(sgdDir))
-				Directory.Create(sgdDir);
-
-			return configExists;
-		}
-
-        public void EnablePortalSync(string s)
-        {
-            if (s.ToLower() == "enable")
-            {
-                CrestronConsole.ConsoleCommandResponse("Portal Sync features enabled");
-                PortalSync = new PepperDashPortalSyncClient();
-            }
-        }
-
-		public void TearDown()
-		{
-			Debug.Console(0, "Tearing down existing system");
-			DeviceManager.DeactivateAll();
-
-			TieLineCollection.Default.Clear();
-
-			foreach (var key in DeviceManager.GetDevices())
-				DeviceManager.RemoveDevice(key);
-
-			Debug.Console(0, "Tear down COMPLETE");
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		void Load()
-		{
-			LoadDevices();
-			LoadTieLines();
-			LoadRooms();
-			LoadLogoServer();
-
-			DeviceManager.ActivateAll();
-		}
-
-
-		/// <summary>
-		/// Reads all devices from config and adds them to DeviceManager
-		/// </summary>
-		public void LoadDevices()
-		{
-			foreach (var devConf in ConfigReader.ConfigObject.Devices)
-			{
-
-				try
-				{
-                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Creating device '{0}'", devConf.Key);
-					// Skip this to prevent unnecessary warnings
-					if (devConf.Key == "processor")
-						continue;
-
-					// Try local factory first
-					var newDev = DeviceFactory.GetDevice(devConf);
-
-					// Then associated library factories
-					if (newDev == null)
-						newDev = PepperDash.Essentials.Devices.Common.DeviceFactory.GetDevice(devConf);
-					if (newDev == null)
-						newDev = PepperDash.Essentials.DM.DeviceFactory.GetDevice(devConf);
-					if (newDev == null)
-						newDev = PepperDash.Essentials.Devices.Displays.DisplayDeviceFactory.GetDevice(devConf);
-
-					if (newDev != null)
-						DeviceManager.AddDevice(newDev);
-					else
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "ERROR: Cannot load unknown device type '{0}', key '{1}'.", devConf.Type, devConf.Key);
-				}
-				catch (Exception e)
-				{
-                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "ERROR: Creating device {0}. Skipping device. \r{1}", devConf.Key, e);
-				} 
-			}
-            Debug.Console(0, Debug.ErrorLogLevel.Notice, "All Devices Loaded.");
-
-		}
-
-		/// <summary>
-		/// Helper method to load tie lines.  This should run after devices have loaded
-		/// </summary>
-		public void LoadTieLines()
-		{
-			// In the future, we can't necessarily just clear here because devices
-			// might be making their own internal sources/tie lines
-
-			var tlc = TieLineCollection.Default;
-			//tlc.Clear();
-			if (ConfigReader.ConfigObject.TieLines == null)
-			{
-				return;
-			}
-
-			foreach (var tieLineConfig in ConfigReader.ConfigObject.TieLines)
-			{
-				var newTL = tieLineConfig.GetTieLine();
-				if (newTL != null)
-					tlc.Add(newTL);
-			}
-
-            Debug.Console(0, Debug.ErrorLogLevel.Notice, "All Tie Lines Loaded.");
-
-		}
-
-		/// <summary>
-		/// Reads all rooms from config and adds them to DeviceManager
-		/// </summary>
-		public void LoadRooms()
-		{
-			if (ConfigReader.ConfigObject.Rooms == null)
-			{
-				Debug.Console(0, Debug.ErrorLogLevel.Warning, "WARNING: Configuration contains no rooms");
-				return;
-			}
-
-			foreach (var roomConfig in ConfigReader.ConfigObject.Rooms)
-			{
-				var room = roomConfig.GetRoomObject();
-				if (room != null)
-				{
-                    if (room is EssentialsHuddleSpaceRoom)
-                    {
-                        DeviceManager.AddDevice(room);
-
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleSpaceRoom, attempting to add to DeviceManager with Fusion");
-                        DeviceManager.AddDevice(new EssentialsHuddleSpaceFusionSystemControllerBase((EssentialsHuddleSpaceRoom)room, 0xf1));
-
-
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Cotija Bridge...");
-						// Cotija bridge
-						var bridge = new CotijaEssentialsHuddleSpaceRoomBridge(room as EssentialsHuddleSpaceRoom);
-						AddBridgePostActivationHelper(bridge); // Lets things happen later when all devices are present
-						DeviceManager.AddDevice(bridge);
-
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Cotija Bridge Added...");
-                    }
-                    else if (room is EssentialsHuddleVtc1Room)
-                    {
-                        DeviceManager.AddDevice(room);
-
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion");
-                        DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((EssentialsHuddleVtc1Room)room, 0xf1));
-                    }					
-                    else
-                    {
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is NOT EssentialsHuddleSpaceRoom, attempting to add to DeviceManager w/o Fusion");
-                        DeviceManager.AddDevice(room);
-                    }
-
-				}
-				else
-                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "WARNING: Cannot create room from config, key '{0}'", roomConfig.Key);
-			}
-
-            Debug.Console(0, Debug.ErrorLogLevel.Notice, "All Rooms Loaded.");
-
-		}
-
-		/// <summary>
-		/// Helps add the post activation steps that link bridges to main controller
-		/// </summary>
-		/// <param name="bridge"></param>
-		void AddBridgePostActivationHelper(CotijaBridgeBase bridge)
-		{
-			bridge.AddPostActivationAction(() =>
-			{
-				var parent = DeviceManager.AllDevices.FirstOrDefault(d => d.Key == "appServer") as CotijaSystemController;
-				if (parent == null)
-				{
-					Debug.Console(0, bridge, "ERROR: Cannot connect bridge. System controller not present");
-				}
-				Debug.Console(0, bridge, "Linking to parent controller");
-				bridge.AddParent(parent);
-				parent.AddBridge(bridge);
-			});
-		}
-
-		/// <summary>
-		/// Fires up a logo server if not already running
-		/// </summary>
-		void LoadLogoServer()
-		{
-			try
-			{
-                LogoServer = new HttpLogoServer(8080, Global.FilePathPrefix + "html" + Global.DirectorySeparator + "logo");
-            }
-			catch (Exception)
-			{
-				Debug.Console(0, Debug.ErrorLogLevel.Notice, "NOTICE: Logo server cannot be started. Likely already running in another program");
-			}
-		}
-	}
-}

PepperDashEssentials/FOR REFERENCE UI/OTHER/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -31,6 +31,10 @@ namespace PepperDash.Essentials.Fusion
         //public event EventHandler<MeetingChangeEventArgs> MeetingEndWarning;
         //public event EventHandler<MeetingChangeEventArgs> NextMeetingBeginWarning;
 
+        public event EventHandler<EventArgs> RoomInfoChange;
+
+        public FusionCustomPropertiesBridge CustomPropertiesBridge = new FusionCustomPropertiesBridge();
+
 		protected FusionRoom FusionRoom;
 		protected EssentialsRoomBase Room;
 		Dictionary<Device, BoolInputSig> SourceToFeedbackSigs = 
@@ -425,6 +429,16 @@ namespace PepperDash.Essentials.Fusion
             
         }
 
+        protected void GetCustomProperties()
+        {
+            if (FusionRoom.IsOnline)
+            {
+                string fusionRoomCustomPropertiesRequest = @"<RequestRoomConfiguration><RequestID>RoomConfigurationRequest</RequestID><CustomProperties><Property></Property></CustomProperties></RequestRoomConfiguration>";
+
+                FusionRoom.ExtenderFusionRoomDataReservedSigs.RoomConfigQuery.StringValue = fusionRoomCustomPropertiesRequest;
+            }
+        }
+
         void GetTouchpanelInfo()
         {
             // TODO Get IP and Project Name from TP
@@ -470,6 +484,7 @@ namespace PepperDash.Essentials.Fusion
 
                 FusionRoom.ExtenderFusionRoomDataReservedSigs.ActionQuery.StringValue = actionRequest;
 
+                GetCustomProperties();
 
                 // Request current Fusion Server Time
                 RequestLocalDateTime(null);
@@ -753,6 +768,82 @@ namespace PepperDash.Essentials.Fusion
                     Debug.Console(1, this, "Error parsing LocalDateTimeQueryResponse: {0}", e);
                 }
             }
+            else if (args.Sig == FusionRoom.ExtenderFusionRoomDataReservedSigs.RoomConfigResponse)
+            {
+                // Room info response with custom properties
+
+                string roomConfigResponseArgs = args.Sig.StringValue.Replace("&", "and");
+
+                Debug.Console(2, this, "Fusion Response: \n {0}", roomConfigResponseArgs);
+
+                try
+                {
+                    XmlDocument roomConfigResponse = new XmlDocument();
+
+                    roomConfigResponse.LoadXml(roomConfigResponseArgs);
+
+                    var requestRoomConfiguration = roomConfigResponse["RoomConfigurationResponse"];
+
+                    if (requestRoomConfiguration != null)
+                    {
+                        RoomInformation roomInformation = new RoomInformation();
+
+                        foreach (XmlElement e in roomConfigResponse.FirstChild.ChildNodes)
+                        {
+                            if (e.Name == "RoomInformation")
+                            {
+                                XmlReader roomInfo = new XmlReader(e.OuterXml);
+
+                                roomInformation = CrestronXMLSerialization.DeSerializeObject<RoomInformation>(roomInfo);
+                            }
+                            else if (e.Name == "CustomFields")
+                            {
+                                foreach (XmlElement el in e)
+                                {
+                                    FusionCustomProperty customProperty = new FusionCustomProperty();
+
+                                    if (el.Name == "CustomField")
+                                    {
+                                        customProperty.ID = el.Attributes["ID"].Value;
+                                    }
+
+                                    foreach (XmlElement elm in el)
+                                    {
+                                        if (elm.Name == "CustomFieldName")
+                                        {
+                                            customProperty.CustomFieldName = elm.InnerText;
+                                        }
+                                        if (elm.Name == "CustomFieldType")
+                                        {
+                                            customProperty.CustomFieldType = elm.InnerText;
+                                        }
+                                        if (elm.Name == "CustomFieldValue")
+                                        {
+                                            customProperty.CustomFieldValue = elm.InnerText;
+                                        }
+                                    }
+
+                                    roomInformation.FusionCustomProperties.Add(customProperty);
+                                }
+                            }
+                        }
+
+                        var handler = RoomInfoChange;
+                        if (handler != null)
+                            handler(this, new EventArgs());
+
+                        CustomPropertiesBridge.EvaluateRoomInfo(Room.Key, roomInformation);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(1, this, "Error parsing Custom Properties response: {0}", e);
+                }
+                //PrintRoomInfo();
+                //getRoomInfoBusy = false;
+                //_DynFusion.API.EISC.BooleanInput[Constants.GetRoomInfo].BoolValue = getRoomInfoBusy;
+            }
+            
         }
 
         /// <summary>
@@ -1466,5 +1557,39 @@ namespace PepperDash.Essentials.Fusion
 		}
 	}
 
-   
+    public class RoomInformation
+    {
+        public string ID { get; set; }
+        public string Name { get; set; }
+        public string Location { get; set; }
+        public string Description { get; set; }
+        public string TimeZone { get; set; }
+        public string WebcamURL { get; set; }
+        public string BacklogMsg { get; set; }
+        public string SubErrorMsg { get; set; }
+        public string EmailInfo { get; set; }
+        public List<FusionCustomProperty> FusionCustomProperties { get; set; }
+
+        public RoomInformation()
+        {
+            FusionCustomProperties = new List<FusionCustomProperty>();
+        }
+    }
+    public class FusionCustomProperty
+    {
+        public string ID { get; set; }
+        public string CustomFieldName { get; set; }
+        public string CustomFieldType { get; set; }
+        public string CustomFieldValue { get; set; }
+
+        public FusionCustomProperty()
+        {
+
+        }
+
+        public FusionCustomProperty(string id)
+        {
+            ID = id;
+        }
+    }
 }

PepperDashEssentials/FOR REFERENCE UI/OTHER/Fusion/EssentialsHuddleVtc1FusionController.cs

@@ -13,6 +13,7 @@ using Crestron.SimplSharpPro.Fusion;
 using PepperDash.Core;
 using PepperDash.Essentials;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.Devices.Common.Occupancy;
 
@@ -186,16 +187,7 @@ namespace PepperDash.Essentials.Fusion
             FusionRoom.SystemPowerOn.OutputSig.SetSigFalseAction((Room as EssentialsHuddleVtc1Room).PowerOnToDefaultOrLastSource);
             FusionRoom.SystemPowerOff.OutputSig.SetSigFalseAction(() => (Room as EssentialsHuddleVtc1Room).RunRouteAction("roomOff"));
             // NO!! room.RoomIsOn.LinkComplementInputSig(FusionRoom.SystemPowerOff.InputSig);
-            FusionRoom.ErrorMessage.InputSig.StringValue =
+ 
-                "3: 7 Errors: This is a really long error message;This is a really long error message;This is a really long error message;This is a really long error message;This is a really long error message;This is a really long error message;This is a really long error message;";
-
-			SetUpEthernetValues();
-			
-			GetProcessorEthernetValues();
-
-            GetSystemInfo();
-
-            GetProcessorInfo();
 
             CrestronEnvironment.EthernetEventHandler += CrestronEnvironment_EthernetEventHandler;
         }

PepperDashEssentials/FOR REFERENCE UI/OTHER/Fusion/FusionCustomPropertiesBridge.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Devices;
+using PepperDash.Essentials.Room.Behaviours;
+
+namespace PepperDash.Essentials.Fusion
+{
+    /// <summary>
+    /// Handles mapping Fusion Custom Property values to system properties
+    /// </summary>
+    public class FusionCustomPropertiesBridge
+    {
+
+        /// <summary>
+        /// Evaluates the room info and custom properties from Fusion and updates the system properties aa needed
+        /// </summary>
+        /// <param name="roomInfo"></param>
+        public void EvaluateRoomInfo(string roomKey, RoomInformation roomInfo)
+        {
+            try
+            {
+                var reconfigurableDevices = DeviceManager.AllDevices.Where(d => d is ReconfigurableDevice);
+
+                foreach (var device in reconfigurableDevices)
+                {
+                    // Get the current device config so new values can be overwritten over existing
+                    var deviceConfig = (device as ReconfigurableDevice).Config;
+
+                    if (device is RoomOnToDefaultSourceWhenOccupied)
+                    {
+                        Debug.Console(1, "Mapping Room on via Occupancy values from Fusion");
+
+                        var devProps = JsonConvert.DeserializeObject<RoomOnToDefaultSourceWhenOccupiedConfig>(deviceConfig.Properties.ToString());
+
+                        var enableFeature = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupied"));
+                        if (enableFeature != null)
+                            devProps.EnableRoomOnWhenOccupied = bool.Parse(enableFeature.CustomFieldValue);
+
+                        var enableTime = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("RoomOnWhenOccupiedStartTime"));
+                        if (enableTime != null)
+                            devProps.OccupancyStartTime = enableTime.CustomFieldValue;
+
+                        var disableTime = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("RoomOnWhenOccupiedEndTime"));
+                        if (disableTime != null)
+                            devProps.OccupancyEndTime = disableTime.CustomFieldValue;
+
+                        var enableSunday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedSun"));
+                        if (enableSunday != null)
+                            devProps.EnableSunday = bool.Parse(enableSunday.CustomFieldValue);
+
+                        var enableMonday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedMon"));
+                        if (enableMonday != null)
+                            devProps.EnableMonday = bool.Parse(enableMonday.CustomFieldValue);
+
+                        var enableTuesday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedTue"));
+                        if (enableTuesday != null)
+                            devProps.EnableTuesday = bool.Parse(enableTuesday.CustomFieldValue);
+
+                        var enableWednesday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedWed"));
+                        if (enableWednesday != null)
+                            devProps.EnableWednesday = bool.Parse(enableWednesday.CustomFieldValue);
+
+                        var enableThursday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedThu"));
+                        if (enableThursday != null)
+                            devProps.EnableThursday = bool.Parse(enableThursday.CustomFieldValue);
+
+                        var enableFriday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedFri"));
+                        if (enableFriday != null)
+                            devProps.EnableFriday = bool.Parse(enableFriday.CustomFieldValue);
+
+                        var enableSaturday = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("EnRoomOnWhenOccupiedSat"));
+                        if (enableSaturday != null)
+                            devProps.EnableSaturday = bool.Parse(enableSaturday.CustomFieldValue);
+
+                        deviceConfig.Properties = JToken.FromObject(devProps);
+                    }
+                    else if (device is EssentialsRoomBase)
+                    {
+                        // Set the room name
+                        if (!string.IsNullOrEmpty(roomInfo.Name))
+                        {
+                            Debug.Console(1, "Current Room Name: {0}. New Room Name: {1}", deviceConfig.Name, roomInfo.Name);
+                            // Set the name in config
+                            deviceConfig.Name = roomInfo.Name;
+
+                            Debug.Console(1, "Room Name Successfully Changed.");
+                        }
+
+                        // Set the help message
+                        var helpMessage = roomInfo.FusionCustomProperties.FirstOrDefault(p => p.ID.Equals("RoomHelpMessage"));
+                        if (helpMessage != null)
+                        {
+                            //Debug.Console(1, "Current Help Message: {0}. New Help Message: {1}", deviceConfig.Properties["help"]["message"].Value<string>(ToString()), helpMessage.CustomFieldValue);
+                            deviceConfig.Properties["helpMessage"] = (string)helpMessage.CustomFieldValue;
+                        }
+                    }
+
+                    // Set the config on the device
+                    (device as ReconfigurableDevice).SetConfig(deviceConfig);
+                }
+
+
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, "FusionCustomPropetiesBridge: Error mapping properties: {0}", e);
+            }
+        }
+    }
+}

PepperDashEssentials/Factory/DeviceFactory.cs

@@ -1,92 +1,97 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro;
-
+
-using Newtonsoft.Json;
+using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
-using PepperDash.Core;
+using PepperDash.Core;
-using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Config;
-
+
-namespace PepperDash.Essentials
+namespace PepperDash.Essentials
-{
+{
-	public class DeviceFactory
+	public class DeviceFactory
-	{
+	{
-		public static IKeyed GetDevice(DeviceConfig dc)
+		public static IKeyed GetDevice(DeviceConfig dc)
-		{
+		{
-			var key = dc.Key;
+			var key = dc.Key;
-			var name = dc.Name;
+			var name = dc.Name;
-			var type = dc.Type;
+			var type = dc.Type;
-			var properties = dc.Properties;
+			var properties = dc.Properties;
-
+
-			var typeName = dc.Type.ToLower();
+			var typeName = dc.Type.ToLower();
-
+
-            if (typeName == "amplifier")
+            if (typeName == "amplifier")
-            {
+            {
-                return new Amplifier(dc.Key, dc.Name);
+                return new Amplifier(dc.Key, dc.Name);
-            } 
+            } 
-            else if (dc.Group.ToLower() == "touchpanel") //  typeName.StartsWith("tsw"))
+            else if (dc.Group.ToLower() == "touchpanel") //  typeName.StartsWith("tsw"))
-            {
+            {
-                return UiDeviceFactory.GetUiDevice(dc);
+                return UiDeviceFactory.GetUiDevice(dc);
-            }
+            }
-
+
-            else if (typeName == "mockdisplay")
+            else if (typeName == "mockdisplay")
-            {
+            {
-                return new MockDisplay(key, name);
+                return new MockDisplay(key, name);
-            }
+            }
-
+
-            else if (typeName == "generic")
+            else if (typeName == "generic")
-            {
+            {
-                return new Device(key, name);
+                return new Device(key, name);
-            }
+            }
-
+
-            // MOVE into something else???
+            // MOVE into something else???
-            else if (typeName == "basicirdisplay")
+            else if (typeName == "basicirdisplay")
-            {
+            {
-                var ir = IRPortHelper.GetIrPort(properties);
+                var ir = IRPortHelper.GetIrPort(properties);
-                if (ir != null)
+                if (ir != null)
-                    return new BasicIrDisplay(key, name, ir.Port, ir.FileName);
+                    return new BasicIrDisplay(key, name, ir.Port, ir.FileName);
-            }
+            }
-
+
-            else if (typeName == "commmock")
+            else if (typeName == "commmock")
-            {
+            {
-                var comm = CommFactory.CreateCommForDevice(dc);
+                var comm = CommFactory.CreateCommForDevice(dc);
-                var props = JsonConvert.DeserializeObject<ConsoleCommMockDevicePropertiesConfig>(
+                var props = JsonConvert.DeserializeObject<ConsoleCommMockDevicePropertiesConfig>(
-                    properties.ToString());
+                    properties.ToString());
-                return new ConsoleCommMockDevice(key, name, props, comm);
+                return new ConsoleCommMockDevice(key, name, props, comm);
-            }
+            }
-
+
-            else if (typeName == "appserver")
+            else if (typeName == "appserver")
-            {
+            {
-                var props = JsonConvert.DeserializeObject<CotijaConfig>(properties.ToString());
+                var props = JsonConvert.DeserializeObject<CotijaConfig>(properties.ToString());
-                return new CotijaSystemController(key, name, props);
+                return new CotijaSystemController(key, name, props);
-            }
+            }
-
+
-			else if (typeName == "mobilecontrolbridge-ddvc01")
+			else if (typeName == "mobilecontrolbridge-ddvc01")
-			{
+			{
-				var comm = CommFactory.GetControlPropertiesConfig(dc);
+				var comm = CommFactory.GetControlPropertiesConfig(dc);
-
+
-				var bridge = new PepperDash.Essentials.Room.Cotija.CotijaDdvc01RoomBridge(key, name, comm.IpIdInt);
+				var bridge = new PepperDash.Essentials.Room.Cotija.CotijaDdvc01RoomBridge(key, name, comm.IpIdInt);
-				bridge.AddPreActivationAction(() =>
+				bridge.AddPreActivationAction(() =>
-				{
+				{
-					var parent = DeviceManager.AllDevices.FirstOrDefault(d => d.Key == "appServer") as CotijaSystemController;
+					var parent = DeviceManager.AllDevices.FirstOrDefault(d => d.Key == "appServer") as CotijaSystemController;
-					if (parent == null)
+					if (parent == null)
-					{
+					{
-						Debug.Console(0, bridge, "ERROR: Cannot connect bridge. System controller not present");
+						Debug.Console(0, bridge, "ERROR: Cannot connect bridge. System controller not present");
-					}
+					}
-					Debug.Console(0, bridge, "Linking to parent controller");
+					Debug.Console(0, bridge, "Linking to parent controller");
-					bridge.AddParent(parent);
+					bridge.AddParent(parent);
-					parent.AddBridge(bridge);
+					parent.AddBridge(bridge);
-				});
+				});
-
+
-				return bridge;
+				return bridge;
-			}
+			}
-
+
-			return null;
+            else if (typeName == "roomonwhenoccupancydetectedfeature")
-		}
+            {
-	}
+                return new Room.Behaviours.RoomOnToDefaultSourceWhenOccupied(dc);
-
+            }
-}
+
+			return null;
+		}
+	}
+
+}

PepperDashEssentials/Factory/UiDeviceFactory.cs

@@ -49,12 +49,12 @@ namespace PepperDash.Essentials
                         avDriver.CurrentRoom = room as EssentialsHuddleSpaceRoom;
                         
                         // Environment Driver
-                        if (avDriver.CurrentRoom.Config.Environment != null && avDriver.CurrentRoom.Config.Environment.DeviceKeys.Count > 0)
+                        if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
                         {
                             Debug.Console(0, panelController, "Adding environment driver");
                             mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
 
-                            mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.Config.Environment);
+                            mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
                         }
 
                         mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
@@ -118,12 +118,12 @@ namespace PepperDash.Essentials
                         avDriver.CurrentRoom = room as EssentialsHuddleVtc1Room;
 
                         // Environment Driver
-                        if (avDriver.CurrentRoom.Config.Environment != null && avDriver.CurrentRoom.Config.Environment.DeviceKeys.Count > 0)
+                        if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
                         {
                             Debug.Console(0, panelController, "Adding environment driver");
                             mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
 
-                            mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.Config.Environment);
+                            mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
                         }
 
                         mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);

PepperDashEssentials/PepperDashEssentials.csproj

@@ -99,17 +99,36 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpReflectionInterface.dll</HintPath>
     </Reference>
+    <Reference Include="SimplSharpTimerEventInterface, Version=1.0.6197.20052, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpTimerEventInterface.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AppServer\Messengers\AtcDdvc01Messenger.cs" />
+    <Compile Include="AppServer\Messengers\Ddvc01AtcMessenger.cs" />
+    <Compile Include="AppServer\Messengers\AudioCodecBaseMessenger.cs" />
+    <Compile Include="AppServer\Messengers\Ddvc01VtcMessenger.cs" />
     <Compile Include="AppServer\Messengers\MessengerBase.cs" />
+    <Compile Include="AppServer\Messengers\SystemMonitorMessenger.cs" />
     <Compile Include="AppServer\Messengers\VideoCodecBaseMessenger.cs" />
     <Compile Include="Audio\EssentialsVolumeLevelConfig.cs" />
     <Compile Include="Bridges\BridgeBase.cs" />
     <Compile Include="Bridges\BridgeFactory.cs" />
+    <Compile Include="Bridges\CameraControllerBridge.cs" />
+    <Compile Include="Bridges\DisplayControllerBridge.cs" />
+    <Compile Include="Bridges\DigitalLoggerBridge.cs" />
+    <Compile Include="Bridges\DmChassisControllerBridge.cs" />
+    <Compile Include="Bridges\DmTxControllerBridge.cs" />
+    <Compile Include="Bridges\GenericLightingBridge.cs" />
+    <Compile Include="Bridges\GenericRelayDeviceBridge.cs" />
+    <Compile Include="Bridges\IBasicCommunicationBridge.cs" />
+    <Compile Include="Bridges\DmRmcControllerBridge.cs" />
+    <Compile Include="Bridges\IDigitalInputBridge.cs" />
+    <Compile Include="Bridges\JoinMapBase.cs" />
+    <Compile Include="Bridges\SystemMonitorBridge.cs" />
     <Compile Include="Configuration ORIGINAL\Builders\TPConfig.cs" />
     <Compile Include="Configuration ORIGINAL\Configuration.cs" />
     <Compile Include="Configuration ORIGINAL\ConfigurationHelpers.cs" />
@@ -124,22 +143,22 @@
     <Compile Include="Configuration ORIGINAL\Factories\MAYBE SetTopBoxFactory.cs" />
     <Compile Include="Configuration ORIGINAL\Factories\DisplayFactory.cs" />
     <Compile Include="Configuration ORIGINAL\Factories\FactoryHelper.cs" />
-    <Compile Include="Config\ConfigReader.cs" />
-    <Compile Include="Config\EssentialsConfig.cs" />
     <Compile Include="Factory\DeviceFactory.cs" />
     <Compile Include="Devices\Amplifier.cs" />
     <Compile Include="Devices\DiscPlayer\OppoExtendedBdp.cs" />
     <Compile Include="Devices\NUMERIC AppleTV.cs" />
     <Compile Include="ControlSystem.cs" />
     <Compile Include="Factory\UiDeviceFactory.cs" />
-    <Compile Include="OTHER\Fusion\EssentialsHuddleVtc1FusionController.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\EssentialsHuddleVtc1FusionController.cs" />
-    <Compile Include="OTHER\Fusion\FusionEventHandlers.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\FusionCustomPropertiesBridge.cs" />
-    <Compile Include="OTHER\Fusion\FusionProcessorQueries.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\FusionEventHandlers.cs" />
-    <Compile Include="OTHER\Fusion\FusionRviDataClasses.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\FusionProcessorQueries.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\FusionRviDataClasses.cs" />
     <Compile Include="REMOVE EssentialsApp.cs" />
-    <Compile Include="OTHER\Fusion\EssentialsHuddleSpaceFusionSystemControllerBase.cs" />
+    <Compile Include="FOR REFERENCE UI\OTHER\Fusion\EssentialsHuddleSpaceFusionSystemControllerBase.cs" />
     <Compile Include="HttpApiHandler.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Room\Behaviours\RoomOnToDefaultSourceWhenOccupied.cs" />
     <Compile Include="Room\Config\DDVC01RoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsPresentationPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsHuddleRoomPropertiesConfig.cs" />

PepperDashEssentials/Properties/AssemblyInfo.cs

@@ -4,5 +4,5 @@
 [assembly: AssemblyCompany("PepperDash Technology Corp")]
 [assembly: AssemblyProduct("PepperDashEssentials")]
 [assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2018")]
-[assembly: AssemblyVersion("1.2.11.*")]
+[assembly: AssemblyVersion("1.3.2.*")]
 

PepperDashEssentials/Properties/ControlSystem.cfg

@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
-<ControlSystem>
+<ControlSystem>
-  <Name>Test RMC3</Name>
+  <Name>192.168.10.1</Name>
-  <Address>auto 192.168.1.40</Address>
+  <Address>auto 192.168.10.1</Address>
-  <ProgramSlot>Program01</ProgramSlot>
+  <ProgramSlot>Program01</ProgramSlot>
-  <Storage>Internal Flash</Storage>
+  <Storage>Internal Flash</Storage>
 </ControlSystem>

PepperDashEssentials/Room/Behaviours/RoomOnToDefaultSourceWhenOccupied.cs

@@ -0,0 +1,526 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.Scheduler;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Devices;
+using PepperDash.Essentials.Devices.Common.Occupancy;
+
+namespace PepperDash.Essentials.Room.Behaviours
+{
+    /// <summary>
+    /// A device that when linked to a room can power the room on when enabled during scheduled hours.
+    /// </summary>
+    public class RoomOnToDefaultSourceWhenOccupied : ReconfigurableDevice
+    {
+        RoomOnToDefaultSourceWhenOccupiedConfig PropertiesConfig;
+
+        public bool FeatureEnabled { get; private set; }
+
+        public DateTime FeatureEnabledTime { get; private set; }
+
+        ScheduledEvent FeatureEnableEvent;
+
+        const string FeatureEnableEventName = "EnableRoomOnToDefaultSourceWhenOccupied";
+
+        public DateTime FeatureDisabledTime { get; private set; }
+
+        ScheduledEvent FeatureDisableEvent;
+
+        const string FeatureDisableEventName = "DisableRoomOnToDefaultSourceWhenOccupied";
+
+        ScheduledEventGroup FeatureEventGroup;
+
+        public EssentialsRoomBase Room { get; private set; }
+
+        private Fusion.EssentialsHuddleSpaceFusionSystemControllerBase FusionRoom;
+
+        public RoomOnToDefaultSourceWhenOccupied(DeviceConfig config) :
+            base (config)
+        {
+            PropertiesConfig = JsonConvert.DeserializeObject<RoomOnToDefaultSourceWhenOccupiedConfig>(config.Properties.ToString());
+
+            FeatureEventGroup = new ScheduledEventGroup(this.Key);
+
+            FeatureEventGroup.RetrieveAllEvents();
+
+            // Add to the global class for tracking
+            Scheduler.AddEventGroup(FeatureEventGroup);
+
+            AddPostActivationAction(() =>
+            {
+                // Subscribe to room event to know when RoomOccupancy is set and ready to be subscribed to
+                if (Room != null)
+                    Room.RoomOccupancyIsSet += new EventHandler<EventArgs>(RoomOccupancyIsSet);
+
+                else
+                    Debug.Console(1, this, "Room has no RoomOccupancy object set");
+
+                var fusionRoomKey = PropertiesConfig.RoomKey + "-fusion";
+
+                FusionRoom = DeviceManager.GetDeviceForKey(fusionRoomKey) as Fusion.EssentialsHuddleSpaceFusionSystemControllerBase;
+
+                if (FusionRoom == null)
+                    Debug.Console(1, this, "Unable to get Fusion Room from Device Manager with key: {0}", fusionRoomKey);
+            });
+        }
+
+        public override bool CustomActivate()
+        {
+            SetUpDevice();
+
+            return base.CustomActivate();
+        }
+
+        /// <summary>
+        /// Sets up device based on config values
+        /// </summary>
+        void SetUpDevice()
+        {
+            Room = DeviceManager.GetDeviceForKey(PropertiesConfig.RoomKey) as EssentialsRoomBase;
+
+            if (Room != null)
+            {
+                try
+                {
+                    FeatureEnabledTime = DateTime.Parse(PropertiesConfig.OccupancyStartTime);
+
+                    if (FeatureEnabledTime != null)
+                    {
+                        Debug.Console(1, this, "Enabled Time: {0}", FeatureEnabledTime.ToString());
+                    }
+                    else
+                        Debug.Console(1, this, "Unable to parse {0} to DateTime", PropertiesConfig.OccupancyStartTime);
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(1, this, "Unable to parse OccupancyStartTime property: {0} \n Error: {1}", PropertiesConfig.OccupancyStartTime, e);
+                }
+
+                try
+                {
+                    FeatureDisabledTime = DateTime.Parse(PropertiesConfig.OccupancyEndTime);
+
+                    if (FeatureDisabledTime != null)
+                    {
+                        Debug.Console(1, this, "Disabled Time: {0}", FeatureDisabledTime.ToString());
+                    }
+                    else
+                        Debug.Console(1, this, "Unable to parse {0} to DateTime", PropertiesConfig.OccupancyEndTime);
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(1, this, "Unable to parse a DateTime config value \n Error: {1}", e);
+                }
+
+                if (!PropertiesConfig.EnableRoomOnWhenOccupied)
+                    FeatureEventGroup.ClearAllEvents();
+                else
+                {
+                    AddEnableEventToGroup();
+
+                    AddDisableEventToGroup();
+
+                    FeatureEventGroup.UserGroupCallBack += new ScheduledEventGroup.UserEventGroupCallBack(FeatureEventGroup_UserGroupCallBack);
+
+                    FeatureEventGroup.EnableAllEvents();
+                }
+
+                FeatureEnabled = CheckIfFeatureShouldBeEnabled();
+            }
+            else
+                Debug.Console(1, this, "Unable to get room from Device Manager with key: {0}", PropertiesConfig.RoomKey);
+        }
+
+
+        protected override void CustomSetConfig(DeviceConfig config)
+        {
+            var newPropertiesConfig = JsonConvert.DeserializeObject<RoomOnToDefaultSourceWhenOccupiedConfig>(config.Properties.ToString());
+
+            if(newPropertiesConfig != null)
+                PropertiesConfig = newPropertiesConfig;
+
+            ConfigWriter.UpdateDeviceConfig(config);
+
+            SetUpDevice();
+        }
+
+        /// <summary>
+        /// Subscribe to feedback from RoomIsOccupiedFeedback on Room
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void RoomOccupancyIsSet(object sender, EventArgs e)
+        {
+            if (Room.RoomOccupancy != null)
+            {
+                Room.RoomOccupancy.RoomIsOccupiedFeedback.OutputChange -= RoomIsOccupiedFeedback_OutputChange;
+                Room.RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(RoomIsOccupiedFeedback_OutputChange);
+                Debug.Console(1, this, "Subscribed to RoomOccupancy status from: '{0}'", Room.Key);
+            }
+        }
+
+        void FeatureEventGroup_UserGroupCallBack(ScheduledEvent SchEvent, ScheduledEventCommon.eCallbackReason type)
+        {
+            if (type == ScheduledEventCommon.eCallbackReason.NormalExpiration)
+            {
+                if (SchEvent.Name == FeatureEnableEventName)
+                {
+                    if (PropertiesConfig.EnableRoomOnWhenOccupied)
+                        FeatureEnabled = true;
+
+                    Debug.Console(1, this, "*****Feature Enabled by event.*****");
+                }
+                else if (SchEvent.Name == FeatureDisableEventName)
+                {
+                    FeatureEnabled = false;
+
+                    Debug.Console(1, this, "*****Feature Disabled by event.*****");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks if the feature should be currently enabled.  Used on startup if processor starts after start time but before end time
+        /// </summary>
+        /// <returns></returns>
+        bool CheckIfFeatureShouldBeEnabled()
+        {
+            bool enabled = false;
+
+            if(PropertiesConfig.EnableRoomOnWhenOccupied)
+            {
+                Debug.Console(1, this, "Current Time: {0} \n FeatureEnabledTime: {1} \n FeatureDisabledTime: {2}", DateTime.Now, FeatureEnabledTime, FeatureDisabledTime);
+
+                if (DateTime.Now.TimeOfDay.CompareTo(FeatureEnabledTime.TimeOfDay) >= 0 && FeatureDisabledTime.TimeOfDay.CompareTo(DateTime.Now.TimeOfDay) > 0)
+                {
+                    if (SchedulerUtilities.CheckIfDayOfWeekMatchesRecurrenceDays(DateTime.Now, CalculateDaysOfWeekRecurrence()))
+                    {
+                        enabled = true;
+                    }
+                }
+            }
+
+            if(enabled)
+                Debug.Console(1, this, "*****Feature Enabled*****");
+            else
+                Debug.Console(1, this, "*****Feature Disabled*****");
+
+            return enabled;
+        }
+
+        /// <summary>
+        /// Respond to Occupancy status event
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void RoomIsOccupiedFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        {
+            Debug.Console(1, this, "RoomIsOccupiedFeeback.OutputChange event fired. e.BoolValue: {0}", e.BoolValue);
+            if(e.BoolValue)
+            {
+                // Occupancy detected
+
+                if (FeatureEnabled)
+                {
+                    // Check room power state first
+                    if (!Room.OnFeedback.BoolValue)
+                    {
+                        Debug.Console(1, this, "Powering Room on to default source");
+                        Room.RunDefaultPresentRoute();
+                    }
+                }
+            }
+        }
+
+        void CreateEvent(ScheduledEvent schEvent, string name)
+        {
+            Debug.Console(1, this, "Adding Event: '{0}'", name);
+            // Create the event
+            if (schEvent == null)
+                schEvent = new ScheduledEvent(name, FeatureEventGroup);
+
+            // Set up its initial properties
+
+            if(!schEvent.Acknowledgeable)
+                schEvent.Acknowledgeable = true;
+
+            if(!schEvent.Persistent)
+                schEvent.Persistent = true;
+
+            schEvent.DateAndTime.SetFirstDayOfWeek(ScheduledEventCommon.eFirstDayOfWeek.Sunday);
+
+            // Set config driven properties
+
+            if (schEvent.Name == FeatureEnableEventName)
+            {
+                schEvent.Description = "Enables the RoomOnToDefaultSourceWhenOccupiedFeature";
+
+                var eventRecurrennce = CalculateDaysOfWeekRecurrence();
+
+                var eventTime = new DateTime();
+
+                // Check to make sure the date for this event is in the future
+                if (DateTime.Now.CompareTo(FeatureEnabledTime) > 0)
+                    eventTime = FeatureEnabledTime.AddDays(1);
+                else
+                    eventTime = FeatureEnabledTime;
+
+                Debug.Console(1, this, "eventTime (before recurrence check): {0}", eventTime);
+
+                // Check day of week against recurrence days and move date ahead as necessary to avoid throwing an exception by trying to set the event
+                // start date on a day of the week that doesn't match teh recurrence values
+                while(!SchedulerUtilities.CheckIfDayOfWeekMatchesRecurrenceDays(eventTime, eventRecurrennce))
+                {
+                    eventTime = eventTime.AddDays(1);
+                    Debug.Console(1, this, "eventTime does not fall on a recurrence weekday.  eventTime: {0}", eventTime);
+                }
+
+                schEvent.DateAndTime.SetAbsoluteEventTime(eventTime);
+
+                Debug.Console(1, this, "Event '{0}' Absolute time set to {1}", schEvent.Name, schEvent.DateAndTime.ToString());
+
+                CalculateAndSetAcknowledgeExpirationTimeout(schEvent, FeatureEnabledTime, FeatureDisabledTime);
+
+                schEvent.Recurrence.Weekly(eventRecurrennce);
+
+            }
+            else if (schEvent.Name == FeatureDisableEventName)
+            {
+                schEvent.Description = "Disables the RoomOnToDefaultSourceWhenOccupiedFeature";
+
+                // Check to make sure the date for this event is in the future
+                if (DateTime.Now.CompareTo(FeatureDisabledTime) > 0)
+                    schEvent.DateAndTime.SetAbsoluteEventTime(FeatureDisabledTime.AddDays(1));
+                else
+                    schEvent.DateAndTime.SetAbsoluteEventTime(FeatureDisabledTime);
+
+                Debug.Console(1, this, "Event '{0}' Absolute time set to {1}", schEvent.Name, schEvent.DateAndTime.ToString());
+
+                CalculateAndSetAcknowledgeExpirationTimeout(schEvent, FeatureDisabledTime, FeatureEnabledTime);
+
+                schEvent.Recurrence.Daily();
+            }
+        }
+
+        void CalculateAndSetAcknowledgeExpirationTimeout(ScheduledEvent schEvent, DateTime time1, DateTime time2)
+        {
+            Debug.Console(1, this, "time1.Hour = {0}", time1.Hour);
+            Debug.Console(1, this, "time2.Hour = {0}", time2.Hour);
+            Debug.Console(1, this, "time1.Minute = {0}", time1.Minute);
+            Debug.Console(1, this, "time2.Minute = {0}", time2.Minute);
+
+            // Calculate the Acknowledge Expiration timer to be the time between the enable and dispable events, less one minute
+            var ackHours = time2.Hour - time1.Hour;
+            if(ackHours < 0)
+                ackHours = ackHours + 24;
+            var ackMinutes = time2.Minute - time1.Minute;
+
+            Debug.Console(1, this, "ackHours = {0}, ackMinutes = {1}", ackHours, ackMinutes);
+
+            var ackTotalMinutes = ((ackHours * 60) + ackMinutes) - 1;
+
+            var ackExpHour = ackTotalMinutes / 60;
+            var ackExpMinutes = ackTotalMinutes % 60;
+
+            Debug.Console(1, this, "Acknowledge Expiration Timeout: {0} hours, {1} minutes", ackExpHour, ackExpMinutes);
+
+            schEvent.AcknowledgeExpirationTimeout.Hour = (ushort)(ackHours);
+            schEvent.AcknowledgeExpirationTimeout.Minute = (ushort)(ackExpMinutes);
+        }
+
+        /// <summary>
+        /// Checks existing event to see if it matches the execution time
+        /// </summary>
+        /// <param name="existingEvent"></param>
+        /// <returns></returns>
+        bool CheckExistingEventTimeForMatch(ScheduledEvent existingEvent, DateTime newTime)
+        {
+            bool isMatch = true;
+
+            // Check to see if hour and minute match
+            if (existingEvent.DateAndTime.Hour != newTime.Hour || existingEvent.DateAndTime.Minute != newTime.Minute)
+                return false;
+
+
+            return isMatch;
+        }
+
+        /// <summary>
+        /// Checks existing event to see if it matches the recurrence days
+        /// </summary>
+        /// <param name="existingEvent"></param>
+        /// <param name="eWeekdays"></param>
+        /// <returns></returns>
+        bool CheckExistingEventRecurrenceForMatch(ScheduledEvent existingEvent, ScheduledEventCommon.eWeekDays eWeekdays)
+        {
+            bool isMatch = true;
+
+            // Check to see if recurrence matches
+            if (eWeekdays != existingEvent.Recurrence.RecurrenceDays)
+                return false;
+
+            return isMatch;
+        }
+
+        /// <summary>
+        /// Adds the Enable event to the local event group and sets its properties based on config
+        /// </summary>
+        void AddEnableEventToGroup()
+        {
+            if (!FeatureEventGroup.ScheduledEvents.ContainsKey(FeatureEnableEventName))
+            {
+                CreateEvent(FeatureEnableEvent, FeatureEnableEventName);
+            }
+            else
+            {
+                // Check if existing event has same time and recurrence as config values
+
+                FeatureEnableEvent = FeatureEventGroup.ScheduledEvents[FeatureEnableEventName];
+                Debug.Console(1, this, "Enable event already found in group");
+
+                // Check config times and days against DateAndTime of existing event.  If different, delete existing event and create new event
+                if(!CheckExistingEventTimeForMatch(FeatureEnableEvent, FeatureEnabledTime) || !CheckExistingEventRecurrenceForMatch(FeatureEnableEvent, CalculateDaysOfWeekRecurrence()))
+                {
+                    Debug.Console(1, this, "Existing event does not match new config properties. Deleting exisiting event: '{0}'", FeatureEnableEvent.Name);
+                    FeatureEventGroup.DeleteEvent(FeatureEnableEvent);
+
+                    FeatureEnableEvent = null;
+
+                    CreateEvent(FeatureEnableEvent, FeatureEnableEventName);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Adds the Enable event to the local event group and sets its properties based on config
+        /// </summary>
+        void AddDisableEventToGroup()
+        {
+            if (!FeatureEventGroup.ScheduledEvents.ContainsKey(FeatureDisableEventName))
+            {
+                CreateEvent(FeatureDisableEvent, FeatureDisableEventName);
+            }
+            else
+            {
+                FeatureDisableEvent = FeatureEventGroup.ScheduledEvents[FeatureDisableEventName];
+                Debug.Console(1, this, "Disable event already found in group");
+
+                // Check config times against DateAndTime of existing event.  If different, delete existing event and create new event
+                if(!CheckExistingEventTimeForMatch(FeatureDisableEvent, FeatureDisabledTime))
+                {
+                    Debug.Console(1, this, "Existing event does not match new config properties. Deleting exisiting event: '{0}'", FeatureDisableEvent.Name);
+
+                    FeatureEventGroup.DeleteEvent(FeatureDisableEvent);
+
+                    FeatureDisableEvent = null;
+
+                    CreateEvent(FeatureDisableEvent, FeatureDisableEventName);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Calculates the correct bitfield enum value for the event recurrence based on the config values
+        /// </summary>
+        /// <returns></returns>
+        ScheduledEventCommon.eWeekDays CalculateDaysOfWeekRecurrence()
+        {
+            ScheduledEventCommon.eWeekDays value = new ScheduledEventCommon.eWeekDays();
+
+            if (PropertiesConfig.EnableSunday)
+                value = value | ScheduledEventCommon.eWeekDays.Sunday;
+            if (PropertiesConfig.EnableMonday)
+                value = value | ScheduledEventCommon.eWeekDays.Monday;
+            if (PropertiesConfig.EnableTuesday)
+                value = value | ScheduledEventCommon.eWeekDays.Tuesday;
+            if (PropertiesConfig.EnableWednesday)
+                value = value | ScheduledEventCommon.eWeekDays.Wednesday;
+            if (PropertiesConfig.EnableThursday)
+                value = value | ScheduledEventCommon.eWeekDays.Thursday;
+            if (PropertiesConfig.EnableFriday)
+                value = value | ScheduledEventCommon.eWeekDays.Friday;
+            if (PropertiesConfig.EnableSaturday)
+                value = value | ScheduledEventCommon.eWeekDays.Saturday;
+
+            return value;
+        }
+
+        /// <summary>
+        /// Callback for event that enables feature.  Enables feature if config property is true
+        /// </summary>
+        /// <param name="SchEvent"></param>
+        /// <param name="type"></param>
+        void FeatureEnableEvent_UserCallBack(ScheduledEvent SchEvent, ScheduledEventCommon.eCallbackReason type)
+        {
+            if (type == ScheduledEventCommon.eCallbackReason.NormalExpiration)
+            {
+                if(PropertiesConfig.EnableRoomOnWhenOccupied)
+                    FeatureEnabled = true;
+
+                Debug.Console(1, this, "RoomOnToDefaultSourceWhenOccupied Feature Enabled.");
+            }
+        }
+
+        /// <summary>
+        /// Callback for event that enables feature.  Disables feature
+        /// </summary>
+        /// <param name="SchEvent"></param>
+        /// <param name="type"></param>
+        void FeatureDisableEvent_UserCallBack(ScheduledEvent SchEvent, ScheduledEventCommon.eCallbackReason type)
+        {
+            if (type == ScheduledEventCommon.eCallbackReason.NormalExpiration)
+            {
+                FeatureEnabled = false;
+
+                Debug.Console(1, this, "RoomOnToDefaultSourceWhenOccupied Feature Disabled.");
+            }
+        }
+    }
+
+    public class RoomOnToDefaultSourceWhenOccupiedConfig
+    {
+        [JsonProperty("roomKey")]
+        public string RoomKey { get; set; }
+
+        [JsonProperty("enableRoomOnWhenOccupied")]
+        public bool EnableRoomOnWhenOccupied { get; set; }
+
+        [JsonProperty("occupancyStartTime")]
+        public string OccupancyStartTime { get; set; }
+
+        [JsonProperty("occupancyEndTime")]
+        public string OccupancyEndTime { get; set; }
+
+        [JsonProperty("enableSunday")]
+        public bool EnableSunday { get; set; }
+
+        [JsonProperty("enableMonday")]
+        public bool EnableMonday { get; set; }
+
+        [JsonProperty("enableTuesday")]
+        public bool EnableTuesday { get; set; }
+
+        [JsonProperty("enableWednesday")]
+        public bool EnableWednesday { get; set; }
+
+        [JsonProperty("enableThursday")]
+        public bool EnableThursday { get; set; }
+
+        [JsonProperty("enableFriday")]
+        public bool EnableFriday { get; set; }
+
+        [JsonProperty("enableSaturday")]
+        public bool EnableSaturday { get; set; }
+    }
+}

PepperDashEssentials/Room/Config/EssentialsRoomConfig.cs

@@ -1,334 +1,284 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
-using System.Text;
+using System.Text;
-
+
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
-
+
-using PepperDash.Core;
+using PepperDash.Core;
-using PepperDash.Essentials;
+using PepperDash.Essentials;
-using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Config;
-
+
-namespace PepperDash.Essentials.Room.Config
+namespace PepperDash.Essentials.Room.Config
-{
+{
-	public class EssentialsRoomConfig : DeviceConfig
+	public class EssentialsRoomConfigHelper
-	{
+	{
-		/// <summary>
+		/// <summary>
-		/// Returns a room object from this config data
+		/// Returns a room object from this config data
-		/// </summary>
+		/// </summary>
-		/// <returns></returns>
+		/// <returns></returns>
-		public Device GetRoomObject()
+		public static Device GetRoomObject(DeviceConfig roomConfig)
-		{
+		{
-			var typeName = Type.ToLower();
+			var typeName = roomConfig.Type.ToLower();
-			if (typeName == "huddle")
+			if (typeName == "huddle")
-			{
+			{
-                var props = JsonConvert.DeserializeObject<EssentialsHuddleRoomPropertiesConfig>
+                var huddle = new EssentialsHuddleSpaceRoom(roomConfig);
-                    (this.Properties.ToString());
+
-				var disp = DeviceManager.GetDeviceForKey(props.DefaultDisplayKey) as IRoutingSinkWithSwitching;
+                return huddle;
-				var audio = DeviceManager.GetDeviceForKey(props.DefaultAudioKey) as IRoutingSinkNoSwitching;
+			}
-				var huddle = new EssentialsHuddleSpaceRoom(Key, Name, disp, audio, props);
+            else if (typeName == "huddlevtc1")
-
+            {
-                if (props.Occupancy != null)
+                var rm = new EssentialsHuddleVtc1Room(roomConfig);
-                    huddle.SetRoomOccupancy(DeviceManager.GetDeviceForKey(props.Occupancy.DeviceKey) as
+                
-                        PepperDash.Essentials.Devices.Common.Occupancy.IOccupancyStatusProvider, props.Occupancy.TimoutMinutes);
+                return rm;
-                huddle.LogoUrl = props.Logo.GetUrl();
+            }
-                huddle.SourceListKey = props.SourceListKey;
+			else if (typeName == "ddvc01Bridge")
-                huddle.DefaultSourceItem = props.DefaultSourceItem;
+			{
-                huddle.DefaultVolume = (ushort)(props.Volumes.Master.Level * 65535 / 100);
+				return new Device(roomConfig.Key, roomConfig.Name); // placeholder device that does nothing.
-                return huddle;
+			}
-			}
+
-			//else if (typeName == "presentation")
+            return null;
-			//{
+		}
-			//    var props = JsonConvert.DeserializeObject<EssentialsPresentationRoomPropertiesConfig>
+
-			//        (this.Properties.ToString());
+        /// <summary>
-			//    var displaysDict = new Dictionary<uint, IRoutingSinkNoSwitching>();
+        /// Gets and operating, standalone emergegncy object that can be plugged into a room.
-			//    uint i = 1;
+        /// Returns null if there is no emergency defined
-			//    foreach (var dispKey in props.DisplayKeys) // read in the ordered displays list
+        /// </summary>
-			//    {
+        public static EssentialsRoomEmergencyBase GetEmergency(EssentialsRoomPropertiesConfig props, EssentialsRoomBase room)
-			//        var disp = DeviceManager.GetDeviceForKey(dispKey) as IRoutingSinkWithSwitching;
+        {
-			//        displaysDict.Add(i++, disp);
+            // This emergency 
-			//    }
+            var emergency = props.Emergency;
-
+            if (emergency != null)
-			//    // Get the master volume control
+            {
-			//    IBasicVolumeWithFeedback masterVolumeControlDev = props.Volumes.Master.GetDevice();
+                //switch on emergency type here.  Right now only contact and shutdown
-
+                var e = new EssentialsRoomEmergencyContactClosure(room.Key + "-emergency", props.Emergency, room);
-                
+                DeviceManager.AddDevice(e);
-			//    var presRoom = new EssentialsPresentationRoom(Key, Name, displaysDict, masterVolumeControlDev, props);
+            }
-			//    return presRoom;
+            return null;
-			//}
+        }
-            else if (typeName == "huddlevtc1")
+
-            {
+		/// <summary>
-                var props = JsonConvert.DeserializeObject<EssentialsHuddleVtc1PropertiesConfig>
+		/// 
-                    (this.Properties.ToString());
+		/// </summary>
-                var disp = DeviceManager.GetDeviceForKey(props.DefaultDisplayKey) as IRoutingSinkWithSwitching;
+		/// <param name="props"></param>
-
+		/// <param name="room"></param>
-                var codec = DeviceManager.GetDeviceForKey(props.VideoCodecKey) as
+		/// <returns></returns>
-                    PepperDash.Essentials.Devices.Common.VideoCodec.VideoCodecBase;
+		public static PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController GetMicrophonePrivacy(
-
+			EssentialsRoomPropertiesConfig props, EssentialsHuddleVtc1Room room)
-                var rm = new EssentialsHuddleVtc1Room(Key, Name, disp, codec, codec, props);
+		{
-                // Add Occupancy object from config
+			var microphonePrivacy = props.MicrophonePrivacy;
-
+			if (microphonePrivacy == null)
-                if (props.Occupancy != null)
+			{
-                    rm.SetRoomOccupancy(DeviceManager.GetDeviceForKey(props.Occupancy.DeviceKey) as
+				Debug.Console(0, "ERROR: Cannot create microphone privacy with null properties");
-                        PepperDash.Essentials.Devices.Common.Occupancy.IOccupancyStatusProvider, props.Occupancy.TimoutMinutes);
+				return null;
-                rm.LogoUrl = props.Logo.GetUrl();
+			}
-                rm.SourceListKey = props.SourceListKey;
+			// Get the MicrophonePrivacy device from the device manager
-                rm.DefaultSourceItem = props.DefaultSourceItem;
+			var mP = (DeviceManager.GetDeviceForKey(props.MicrophonePrivacy.DeviceKey) as
-                rm.DefaultVolume = (ushort)(props.Volumes.Master.Level * 65535 / 100);
+				PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController);
-
+			// Set this room as the IPrivacy device
-                rm.MicrophonePrivacy = GetMicrophonePrivacy(props, rm); // Get Microphone Privacy object, if any
+			if (mP == null)
-
+			{
-                rm.Emergency = GetEmergency(props, rm); // Get emergency object, if any
+				Debug.Console(0, "ERROR: Selected device {0} is not MicrophonePrivacyController", props.MicrophonePrivacy.DeviceKey);
-
+				return null;
-                return rm;
+			}
-            }
+			mP.SetPrivacyDevice(room);
-			else if (typeName == "ddvc01Bridge")
+
-			{
+			var behaviour = props.MicrophonePrivacy.Behaviour.ToLower();
-				return new Device(Key, Name); // placeholder device that does nothing.
+
-			}
+			if (behaviour == null)
-
+			{
-            return null;
+				Debug.Console(0, "WARNING: No behaviour defined for MicrophonePrivacyController");
-		}
+				return null;
-
+			}
-        /// <summary>
+			if (behaviour == "trackroomstate")
-        /// Gets and operating, standalone emergegncy object that can be plugged into a room.
+			{
-        /// Returns null if there is no emergency defined
+				// Tie LED enable to room power state
-        /// </summary>
+				room.OnFeedback.OutputChange += (o, a) =>
-        EssentialsRoomEmergencyBase GetEmergency(EssentialsRoomPropertiesConfig props, EssentialsRoomBase room)
+				{
-        {
+					if (room.OnFeedback.BoolValue)
-            // This emergency 
+						mP.EnableLeds = true;
-            var emergency = props.Emergency;
+					else
-            if (emergency != null)
+						mP.EnableLeds = false;
-            {
+				};
-                //switch on emergency type here.  Right now only contact and shutdown
+
-                var e = new EssentialsRoomEmergencyContactClosure(room.Key + "-emergency", props.Emergency, room);
+				mP.EnableLeds = room.OnFeedback.BoolValue;
-                DeviceManager.AddDevice(e);
+			}
-            }
+			else if (behaviour == "trackcallstate")
-            return null;
+			{
-        }
+				// Tie LED enable to room power state
-
+				room.InCallFeedback.OutputChange += (o, a) =>
-		/// <summary>
+				{
-		/// 
+					if (room.InCallFeedback.BoolValue)
-		/// </summary>
+						mP.EnableLeds = true;
-		/// <param name="props"></param>
+					else
-		/// <param name="room"></param>
+						mP.EnableLeds = false;
-		/// <returns></returns>
+				};
-		PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController GetMicrophonePrivacy(
+
-			EssentialsRoomPropertiesConfig props, EssentialsHuddleVtc1Room room)
+				mP.EnableLeds = room.InCallFeedback.BoolValue;
-		{
+			}
-			var microphonePrivacy = props.MicrophonePrivacy;
+
-			if (microphonePrivacy == null)
+			return mP;
-			{
+		}
-				Debug.Console(0, "ERROR: Cannot create microphone privacy with null properties");
+	
-				return null;
+	}
-			}
+
-			// Get the MicrophonePrivacy device from the device manager
+    /// <summary>
-			var mP = (DeviceManager.GetDeviceForKey(props.MicrophonePrivacy.DeviceKey) as
+    /// 
-				PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController);
+    /// </summary>
-			// Set this room as the IPrivacy device
+	public class EssentialsRoomPropertiesConfig
-			if (mP == null)
+	{
-			{
+		[JsonProperty("addresses")]
-				Debug.Console(0, "ERROR: Selected device {0} is not MicrophonePrivacyController", props.MicrophonePrivacy.DeviceKey);
+		public EssentialsRoomAddressPropertiesConfig Addresses { get; set; }
-				return null;
+
-			}
+		[JsonProperty("description")]
-			mP.SetPrivacyDevice(room);
+		public string Description { get; set; }
-
+
-			var behaviour = props.MicrophonePrivacy.Behaviour.ToLower();
+		[JsonProperty("emergency")]
-
+		public EssentialsRoomEmergencyConfig Emergency { get; set; }
-			if (behaviour == null)
+
-			{
+		[JsonProperty("help")]
-				Debug.Console(0, "WARNING: No behaviour defined for MicrophonePrivacyController");
+		public EssentialsHelpPropertiesConfig Help { get; set; }
-				return null;
+
-			}
+		[JsonProperty("helpMessage")]
-			if (behaviour == "trackroomstate")
+		public string HelpMessage { get; set; }
-			{
+
-				// Tie LED enable to room power state
+		[JsonProperty("environment")]
-				room.OnFeedback.OutputChange += (o, a) =>
+		public EssentialsEnvironmentPropertiesConfig Environment { get; set; }
-				{
+
-					if (room.OnFeedback.BoolValue)
+		[JsonProperty("logo")]
-						mP.EnableLeds = true;
+		public EssentialsLogoPropertiesConfig Logo { get; set; }
-					else
+	
-						mP.EnableLeds = false;
+		[JsonProperty("microphonePrivacy")]
-				};
+		public EssentialsRoomMicrophonePrivacyConfig MicrophonePrivacy { get; set; }
-
+
-				mP.EnableLeds = room.OnFeedback.BoolValue;
+		[JsonProperty("occupancy")]
-			}
+		public EssentialsRoomOccSensorConfig Occupancy { get; set; }
-			else if (behaviour == "trackcallstate")
+
-			{
+		[JsonProperty("oneButtonMeeting")]
-				// Tie LED enable to room power state
+		public EssentialsOneButtonMeetingPropertiesConfig OneButtonMeeting { get; set; }
-				room.InCallFeedback.OutputChange += (o, a) =>
+
-				{
+		[JsonProperty("shutdownVacancySeconds")]
-					if (room.InCallFeedback.BoolValue)
+		public int ShutdownVacancySeconds { get; set; }
-						mP.EnableLeds = true;
+
-					else
+		[JsonProperty("shutdownPromptSeconds")]
-						mP.EnableLeds = false;
+		public int ShutdownPromptSeconds { get; set; }
-				};
+
-
+		[JsonProperty("tech")]
-				mP.EnableLeds = room.InCallFeedback.BoolValue;
+		public EssentialsRoomTechConfig Tech { get; set; }
-			}
+
-
+		[JsonProperty("volumes")]
-			return mP;
+		public EssentialsRoomVolumesConfig Volumes { get; set; }
-		}
+
-	
+		[JsonProperty("zeroVolumeWhenSwtichingVolumeDevices")]
-	}
+		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; set; }
-
+	}
-    /// <summary>
+
-    /// 
+	public class EssentialsEnvironmentPropertiesConfig
-    /// </summary>
+	{
-	public class EssentialsRoomPropertiesConfig
+		public bool Enabled { get; set; }
-	{
+
-		[JsonProperty("addresses")]
+        [JsonProperty("deviceKeys")]
-		public EssentialsRoomAddressPropertiesConfig Addresses { get; set; }
+        public List<string> DeviceKeys { get; set; }
-
+
-		[JsonProperty("description")]
+        public EssentialsEnvironmentPropertiesConfig()
-		public string Description { get; set; }
+        {
-
+            DeviceKeys = new List<string>();
-		[JsonProperty("emergency")]
+        }
-		public EssentialsRoomEmergencyConfig Emergency { get; set; }
+
-
+	}
-		[JsonProperty("help")]
+
-		public EssentialsHelpPropertiesConfig Help { get; set; }
+    public class EssentialsRoomMicrophonePrivacyConfig
-
+    {
-		[JsonProperty("helpMessage")]
+		[JsonProperty("deviceKey")]
-		public string HelpMessage { get; set; }
+		public string DeviceKey { get; set; }
-
+
-		[JsonProperty("environment")]
+		[JsonProperty("behaviour")]
-		public EssentialsEnvironmentPropertiesConfig Environment { get; set; }
+		public string Behaviour { get; set; }
-
+    }
-		[JsonProperty("logo")]
+
-		public EssentialsLogoPropertiesConfig Logo { get; set; }
+    /// <summary>
-	
+    /// Properties for the help text box
-		[JsonProperty("microphonePrivacy")]
+    /// </summary>
-		public EssentialsRoomMicrophonePrivacyConfig MicrophonePrivacy { get; set; }
+    public class EssentialsHelpPropertiesConfig
-
+    {
-		[JsonProperty("occupancy")]
+		[JsonProperty("message")]
-		public EssentialsRoomOccSensorConfig Occupancy { get; set; }
+		public string Message { get; set; }
-
+
-		[JsonProperty("oneButtonMeeting")]
+		[JsonProperty("showCallButton")]
-		public EssentialsOneButtonMeetingPropertiesConfig OneButtonMeeting { get; set; }
+		public bool ShowCallButton { get; set; }
-
+        
-		[JsonProperty("shutdownVacancySeconds")]
+		/// <summary>
-		public int ShutdownVacancySeconds { get; set; }
+        /// Defaults to "Call Help Desk"
-
+        /// </summary>
-		[JsonProperty("shutdownPromptSeconds")]
+		[JsonProperty("callButtonText")]
-		public int ShutdownPromptSeconds { get; set; }
+		public string CallButtonText { get; set; }
-
+
-		[JsonProperty("tech")]
+        public EssentialsHelpPropertiesConfig()
-		public EssentialsRoomTechConfig Tech { get; set; }
+        {
-
+            CallButtonText = "Call Help Desk";
-		[JsonProperty("volumes")]
+        }
-		public EssentialsRoomVolumesConfig Volumes { get; set; }
+    }
-
+
-		[JsonProperty("zeroVolumeWhenSwtichingVolumeDevices")]
+    /// <summary>
-		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; set; }
+    /// 
-	}
+    /// </summary>
-
+    public class EssentialsOneButtonMeetingPropertiesConfig
-	public class EssentialsEnvironmentPropertiesConfig
+    {
-	{
+		[JsonProperty("enable")]
-		public bool Enabled { get; set; }
+		public bool Enable { get; set; }
-
+    }
-        [JsonProperty("deviceKeys")]
+
-        public List<string> DeviceKeys { get; set; }
+    public class EssentialsRoomAddressPropertiesConfig
-
+    {
-        public EssentialsEnvironmentPropertiesConfig()
+		[JsonProperty("phoneNumber")]
-        {
+		public string PhoneNumber { get; set; }
-            DeviceKeys = new List<string>();
+
-        }
+		[JsonProperty("sipAddress")]
-
+		public string SipAddress { get; set; }
-	}
+    }
-
+
-    public class EssentialsRoomMicrophonePrivacyConfig
+
-    {
+    /// <summary>
-		[JsonProperty("deviceKey")]
+    /// Properties for the room's logo on panels
-		public string DeviceKey { get; set; }
+    /// </summary>
-
+    public class EssentialsLogoPropertiesConfig
-		[JsonProperty("behaviour")]
+    {
-		public string Behaviour { get; set; }
+		[JsonProperty("type")]
-    }
+		public string Type { get; set; }
-
+
-    /// <summary>
+		[JsonProperty("url")]
-    /// Properties for the help text box
+		public string Url { get; set; }
-    /// </summary>
+        /// <summary>
-    public class EssentialsHelpPropertiesConfig
+        /// Gets either the custom URL, a local-to-processor URL, or null if it's a default logo
-    {
+        /// </summary>
-		[JsonProperty("message")]
+        public string GetUrl()
-		public string Message { get; set; }
+        {
-
+            if (Type == "url")
-		[JsonProperty("showCallButton")]
+                return Url;
-		public bool ShowCallButton { get; set; }
+            if (Type == "system")
-        
+                return string.Format("http://{0}:8080/logo.png", 
-		/// <summary>
+                    CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0));
-        /// Defaults to "Call Help Desk"
+            return null;
-        /// </summary>
+        }
-		[JsonProperty("callButtonText")]
+    }
-		public string CallButtonText { get; set; }
+
-
+    /// <summary>
-        public EssentialsHelpPropertiesConfig()
+    /// Represents occupancy sensor(s) setup for a room
-        {
+    /// </summary>
-            CallButtonText = "Call Help Desk";
+    public class EssentialsRoomOccSensorConfig
-        }
+    {
-    }
+		[JsonProperty("deviceKey")]
-
+		public string DeviceKey { get; set; }
-    /// <summary>
+
-    /// 
+		[JsonProperty("timeoutMinutes")]
-    /// </summary>
+		public int TimeoutMinutes { get; set; }
-    public class EssentialsOneButtonMeetingPropertiesConfig
+    }
-    {
+
-		[JsonProperty("enable")]
+	public class EssentialsRoomTechConfig
-		public bool Enable { get; set; }
+	{
-    }
+		[JsonProperty("password")]
-
+		public string Password { get; set; }
-    public class EssentialsRoomAddressPropertiesConfig
+	}
-    {
-		[JsonProperty("phoneNumber")]
-		public string PhoneNumber { get; set; }
-
-		[JsonProperty("sipAddress")]
-		public string SipAddress { get; set; }
-    }
-
-
-    /// <summary>
-    /// Properties for the room's logo on panels
-    /// </summary>
-    public class EssentialsLogoPropertiesConfig
-    {
-		[JsonProperty("type")]
-		public string Type { get; set; }
-
-		[JsonProperty("url")]
-		public string Url { get; set; }
-        /// <summary>
-        /// Gets either the custom URL, a local-to-processor URL, or null if it's a default logo
-        /// </summary>
-        public string GetUrl()
-        {
-            if (Type == "url")
-                return Url;
-            if (Type == "system")
-                return string.Format("http://{0}:8080/logo.png", 
-                    CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0));
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// Represents occupancy sensor(s) setup for a room
-    /// </summary>
-    public class EssentialsRoomOccSensorConfig
-    {
-		[JsonProperty("deviceKey")]
-		public string DeviceKey { get; set; }
-
-		[JsonProperty("timoutMinutes")]
-		public int TimoutMinutes { get; set; }
-    }
-
-	public class EssentialsRoomTechConfig
-	{
-		[JsonProperty("password")]
-		public string Password { get; set; }
-	}
 }

PepperDashEssentials/Room/Types/EssentialsHuddleSpaceRoom.cs

@@ -1,465 +1,505 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
-using System.Text;
+using System.Text;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
-
+
-using PepperDash.Core;
+using Newtonsoft.Json;
-using PepperDash.Essentials.Core;
+
-using PepperDash.Essentials.Room.Config;
+using PepperDash.Core;
-
+using PepperDash.Essentials.Core;
-namespace PepperDash.Essentials
+using PepperDash.Essentials.Core.Config;
-{
+using PepperDash.Essentials.Room.Config;
-	public class EssentialsHuddleSpaceRoom : EssentialsRoomBase, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute
+
-	{
+namespace PepperDash.Essentials
-		public event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
+{
-		public event SourceInfoChangeHandler CurrentSingleSourceChange;
+	public class EssentialsHuddleSpaceRoom : EssentialsRoomBase, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute, IHasCurrentVolumeControls
-
+	{
-        protected override Func<bool> OnFeedbackFunc
+		public event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
-        {
+		public event SourceInfoChangeHandler CurrentSingleSourceChange;
-            get
+
-            {
+        protected override Func<bool> OnFeedbackFunc
-                return () =>
+        {
-                {
+            get
-                    var disp = DefaultDisplay as DisplayBase;
+            {
-                    var val = CurrentSourceInfo != null
+                return () =>
-                        && CurrentSourceInfo.Type == eSourceListItemType.Route
+                {
-                        && disp != null;
+                    var disp = DefaultDisplay as DisplayBase;
-                        //&& disp.PowerIsOnFeedback.BoolValue;
+                    var val = CurrentSourceInfo != null
-                    return val;
+                        && CurrentSourceInfo.Type == eSourceListItemType.Route
-                };
+                        && disp != null;
-            }
+                        //&& disp.PowerIsOnFeedback.BoolValue;
-        }
+                    return val;
-        /// <summary>
+                };
-        /// 
+            }
-        /// </summary>
+        }
-        protected override Func<bool> IsWarmingFeedbackFunc
+        /// <summary>
-        {
+        /// 
-            get
+        /// </summary>
-            {
+        protected override Func<bool> IsWarmingFeedbackFunc
-                return () =>
+        {
-                {
+            get
-                    var disp = DefaultDisplay as DisplayBase;
+            {
-                    if (disp != null)
+                return () =>
-                        return disp.IsWarmingUpFeedback.BoolValue;
+                {
-                    else
+                    var disp = DefaultDisplay as DisplayBase;
-                        return false;
+                    if (disp != null)
-                };
+                        return disp.IsWarmingUpFeedback.BoolValue;
-            }
+                    else
-        }
+                        return false;
-        /// <summary>
+                };
-        /// 
+            }
-        /// </summary>
+        }
-        protected override Func<bool> IsCoolingFeedbackFunc
+        /// <summary>
-        {
+        /// 
-            get
+        /// </summary>
-            {
+        protected override Func<bool> IsCoolingFeedbackFunc
-                return () =>
+        {
-                {
+            get
-                    var disp = DefaultDisplay as DisplayBase;
+            {
-                    if (disp != null)
+                return () =>
-                        return disp.IsCoolingDownFeedback.BoolValue;
+                {
-                    else
+                    var disp = DefaultDisplay as DisplayBase;
-                        return false;
+                    if (disp != null)
-                };
+                        return disp.IsCoolingDownFeedback.BoolValue;
-            }
+                    else
-        }
+                        return false;
-
+                };
-		public EssentialsRoomPropertiesConfig Config { get; private set; }
+            }
-
+        }
-		public IRoutingSinkWithSwitching DefaultDisplay { get; private set; }
+
-		public IRoutingSinkNoSwitching DefaultAudioDevice { get; private set; }
+		public EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; private set; }
-		public IBasicVolumeControls DefaultVolumeControls { get; private set; }
+
-
+		public IRoutingSinkWithSwitching DefaultDisplay { get; private set; }
-		public bool ExcludeFromGlobalFunctions { get; set; }
+		public IRoutingSinkNoSwitching DefaultAudioDevice { get; private set; }
-
+		public IBasicVolumeControls DefaultVolumeControls { get; private set; }
-		/// <summary>
+
-		/// The config name of the source list
+		public bool ExcludeFromGlobalFunctions { get; set; }
-		/// </summary>
+
-		public string SourceListKey { get; set; }
+		/// <summary>
-
+		/// The config name of the source list
-        public string DefaultSourceItem { get; set; }
+		/// </summary>
-
+		public string SourceListKey { get; set; }
-        public ushort DefaultVolume { get; set; }
+
-
+        public string DefaultSourceItem { get; set; }
-		/// <summary>
+
-		/// If room is off, enables power on to last source. Default true
+        public ushort DefaultVolume { get; set; }
-		/// </summary>
+
-		public bool EnablePowerOnToLastSource { get; set; }
+		/// <summary>
-		string LastSourceKey;
+		/// If room is off, enables power on to last source. Default true
-
+		/// </summary>
-		/// <summary>
+		public bool EnablePowerOnToLastSource { get; set; }
-		/// 
+		string LastSourceKey;
-		/// </summary>
+
-		public IBasicVolumeControls CurrentVolumeControls 
+		/// <summary>
-		{
+		/// 
-			get { return _CurrentAudioDevice;  }
+		/// </summary>
-			set
+		public IBasicVolumeControls CurrentVolumeControls 
-			{
+		{
-				if (value == _CurrentAudioDevice) return;
+			get { return _CurrentAudioDevice;  }
-
+			set
-				var oldDev = _CurrentAudioDevice;
+			{
-				// derigister this room from the device, if it can
+				if (value == _CurrentAudioDevice) return;
-				if (oldDev is IInUseTracking)
+
-					(oldDev as IInUseTracking).InUseTracker.RemoveUser(this, "audio");
+				var oldDev = _CurrentAudioDevice;
-				var handler = CurrentVolumeDeviceChange;
+				// derigister this room from the device, if it can
-				if (handler != null)
+				if (oldDev is IInUseTracking)
-					CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.WillChange));
+					(oldDev as IInUseTracking).InUseTracker.RemoveUser(this, "audio");
-				_CurrentAudioDevice = value;
+				var handler = CurrentVolumeDeviceChange;
-				if (handler != null)
+				if (handler != null)
-					CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.DidChange));
+					CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.WillChange));
-				// register this room with new device, if it can
+				_CurrentAudioDevice = value;
-				if (_CurrentAudioDevice is IInUseTracking)
+				if (handler != null)
-					(_CurrentAudioDevice as IInUseTracking).InUseTracker.AddUser(this, "audio");
+					CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.DidChange));
-			}
+				// register this room with new device, if it can
-		}
+				if (_CurrentAudioDevice is IInUseTracking)
-		IBasicVolumeControls _CurrentAudioDevice;
+					(_CurrentAudioDevice as IInUseTracking).InUseTracker.AddUser(this, "audio");
-
+			}
-		/// <summary>
+		}
-		/// The SourceListItem last run - containing names and icons 
+		IBasicVolumeControls _CurrentAudioDevice;
-		/// </summary>
+
-		public SourceListItem CurrentSourceInfo
+		/// <summary>
-		{
+		/// The SourceListItem last run - containing names and icons 
-			get { return _CurrentSourceInfo; }
+		/// </summary>
-			private set
+		public SourceListItem CurrentSourceInfo
-			{
+		{
-				if (value == _CurrentSourceInfo) return;
+			get { return _CurrentSourceInfo; }
-
+			private set
-				var handler = CurrentSingleSourceChange;
+			{
-				// remove from in-use tracker, if so equipped
+				if (value == _CurrentSourceInfo) return;
-				if(_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
+
-					(_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.RemoveUser(this, "control");
+				var handler = CurrentSingleSourceChange;
-
+				// remove from in-use tracker, if so equipped
-				if (handler != null)
+				if(_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
-					handler(this, _CurrentSourceInfo, ChangeType.WillChange);
+					(_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.RemoveUser(this, "control");
-
+
-				_CurrentSourceInfo = value;
+				if (handler != null)
-
+					handler(this, _CurrentSourceInfo, ChangeType.WillChange);
-				// add to in-use tracking
+
-				if (_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
+				_CurrentSourceInfo = value;
-					(_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.AddUser(this, "control");
+
-				if (handler != null)
+				// add to in-use tracking
-					handler(this, _CurrentSourceInfo, ChangeType.DidChange);
+				if (_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
-			}
+					(_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.AddUser(this, "control");
-		}
+				if (handler != null)
-		SourceListItem _CurrentSourceInfo;
+					handler(this, _CurrentSourceInfo, ChangeType.DidChange);
-
+			}
-        public string CurrentSourceInfoKey { get; private set; }
+		}
-
+		SourceListItem _CurrentSourceInfo;
-		/// <summary>
+
-		/// 
+        public string CurrentSourceInfoKey { get; private set; }
-		/// </summary>
+
-		/// <param name="key"></param>
+        public EssentialsHuddleSpaceRoom(DeviceConfig config)
-		/// <param name="name"></param>
+            : base(config)
-		public EssentialsHuddleSpaceRoom(string key, string name, IRoutingSinkWithSwitching defaultDisplay, 
+        {
-			IRoutingSinkNoSwitching defaultAudio, EssentialsRoomPropertiesConfig config)
+            try
-			: base(key, name)
+            {
-		{
+                PropertiesConfig = JsonConvert.DeserializeObject<EssentialsHuddleRoomPropertiesConfig>
-			Config = config;
+                    (config.Properties.ToString());
-			DefaultDisplay = defaultDisplay;
+                DefaultDisplay = DeviceManager.GetDeviceForKey(PropertiesConfig.DefaultDisplayKey) as IRoutingSinkWithSwitching;
-			DefaultAudioDevice = defaultAudio;
+
-			if (defaultAudio is IBasicVolumeControls)
+
-				DefaultVolumeControls = defaultAudio as IBasicVolumeControls;
+                DefaultAudioDevice = DeviceManager.GetDeviceForKey(PropertiesConfig.DefaultAudioKey) as IRoutingSinkWithSwitching;
-			else if (defaultAudio is IHasVolumeDevice)
+
-				DefaultVolumeControls = (defaultAudio as IHasVolumeDevice).VolumeDevice;
+                Initialize();
-            CurrentVolumeControls = DefaultVolumeControls;
+            }
-
+            catch (Exception e)
-            var disp = DefaultDisplay as DisplayBase;
+            {
-            if (disp != null)
+                Debug.Console(1, this, "Error building room: \n{0}", e);
-            {
+            }
-                // Link power, warming, cooling to display
+        }
-                disp.PowerIsOnFeedback.OutputChange += (o, a) =>
+
-                    {
+		void Initialize()
-                        if (disp.PowerIsOnFeedback.BoolValue != OnFeedback.BoolValue)
+		{
-                        {
+            if (DefaultAudioDevice is IBasicVolumeControls)
-                            if (!disp.PowerIsOnFeedback.BoolValue)
+                DefaultVolumeControls = DefaultAudioDevice as IBasicVolumeControls;
-                                CurrentSourceInfo = null;
+            else if (DefaultAudioDevice is IHasVolumeDevice)
-                            OnFeedback.FireUpdate();
+                DefaultVolumeControls = (DefaultAudioDevice as IHasVolumeDevice).VolumeDevice;
-                        }
+            CurrentVolumeControls = DefaultVolumeControls;
-                    };
+
-
+            var disp = DefaultDisplay as DisplayBase;
-                disp.IsWarmingUpFeedback.OutputChange += (o, a) => 
+            if (disp != null)
-                { 
+            {
-                    IsWarmingUpFeedback.FireUpdate();
+                // Link power, warming, cooling to display
-                    if (!IsWarmingUpFeedback.BoolValue)
+                disp.PowerIsOnFeedback.OutputChange += (o, a) =>
-                        (DefaultDisplay as IBasicVolumeWithFeedback).SetVolume(DefaultVolume);
+                    {
-                };
+                        if (disp.PowerIsOnFeedback.BoolValue != OnFeedback.BoolValue)
-                disp.IsCoolingDownFeedback.OutputChange += (o, a) => 
+                        {
-                {
+                            if (!disp.PowerIsOnFeedback.BoolValue)
-                    IsCoolingDownFeedback.FireUpdate(); 
+                                CurrentSourceInfo = null;
-                };
+                            OnFeedback.FireUpdate();
-            }
+                        }
-          
+                    };
-			SourceListKey = "default";
+
-			EnablePowerOnToLastSource = true;
+                disp.IsWarmingUpFeedback.OutputChange += (o, a) => 
-   		}
+                { 
-
+                    IsWarmingUpFeedback.FireUpdate();
-
+                    if (!IsWarmingUpFeedback.BoolValue)
-        /// <summary>
+                        (DefaultDisplay as IBasicVolumeWithFeedback).SetVolume(DefaultVolume);
-        /// 
+                };
-        /// </summary>
+                disp.IsCoolingDownFeedback.OutputChange += (o, a) => 
-        protected override void EndShutdown()
+                {
-        {
+                    IsCoolingDownFeedback.FireUpdate(); 
-            SetDefaultLevels();
+                };
-
+            }
-            RunDefaultPresentRoute();
+          
-
+			SourceListKey = "default";
-            CrestronEnvironment.Sleep(1000);
+			EnablePowerOnToLastSource = true;
-
+   		}
-            RunRouteAction("roomOff");
+
-        }
+        protected override void CustomSetConfig(DeviceConfig config)
-
+        {
-        /// <summary>
+            var newPropertiesConfig = JsonConvert.DeserializeObject<EssentialsHuddleRoomPropertiesConfig>(config.Properties.ToString());
-        /// Routes the default source item, if any
+
-        /// </summary>
+            if (newPropertiesConfig != null)
-        public bool RunDefaultPresentRoute()
+                PropertiesConfig = newPropertiesConfig;
-        {
+
-			if(DefaultSourceItem == null)
+            ConfigWriter.UpdateRoomConfig(config);
-				return false;
+        }
-
+
-            RunRouteAction(DefaultSourceItem);
+        /// <summary>
-			return true;
+        /// 
-        }
+        /// </summary>
-
+        protected override void EndShutdown()
-        /// <summary>
+        {
-        /// 
+            SetDefaultLevels();
-        /// </summary>
+
-        /// <param name="routeKey"></param>
+            RunDefaultPresentRoute();
-		public void RunRouteAction(string routeKey)
+
-		{
+            CrestronEnvironment.Sleep(1000);
-			RunRouteAction(routeKey, null);
+
-		}   
+            RunRouteAction("roomOff");
-
+        }
-		/// <summary>
+
-		/// Gets a source from config list SourceListKey and dynamically build and executes the
+        /// <summary>
-		/// route or commands
+        /// Routes the default source item, if any
-		/// </summary>
+        /// </summary>
-		/// <param name="name"></param>
+        public override bool RunDefaultPresentRoute()
-		public void RunRouteAction(string routeKey, Action successCallback)
+        {
-		{
+            if (DefaultSourceItem == null)
-			// Run this on a separate thread
+            {
-			new CTimer(o =>
+                Debug.Console(0, this, "Unable to run default present route, DefaultSourceItem is null.");
-				{
+                return false;
-					Debug.Console(1, this, "Run route action '{0}'", routeKey);
+            }
-					var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
+
-					if(dict == null)
+            RunRouteAction(DefaultSourceItem);
-					{
+			return true;
-						Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
+        }
-						return;
+
-					}
+        public override bool CustomActivate()
-
+        {
-					// Try to get the list item by it's string key
+            // Add Occupancy object from config
-					if (!dict.ContainsKey(routeKey))
+            if (PropertiesConfig.Occupancy != null)
-					{
+                this.SetRoomOccupancy(DeviceManager.GetDeviceForKey(PropertiesConfig.Occupancy.DeviceKey) as
-						Debug.Console(1, this, "WARNING: No item '{0}' found on config list '{1}'", 
+                    PepperDash.Essentials.Devices.Common.Occupancy.IOccupancyStatusProvider, PropertiesConfig.Occupancy.TimeoutMinutes);
-							routeKey, SourceListKey);
+
-						return;
+            this.LogoUrl = PropertiesConfig.Logo.GetUrl();
-					}
+            this.SourceListKey = PropertiesConfig.SourceListKey;
-
+            this.DefaultSourceItem = PropertiesConfig.DefaultSourceItem;
-					var item = dict[routeKey];
+            this.DefaultVolume = (ushort)(PropertiesConfig.Volumes.Master.Level * 65535 / 100);
-                    //Debug.Console(2, this, "Action {0} has {1} steps",
+
-                    //    item.SourceKey, item.RouteList.Count);
+            return base.CustomActivate();
-
+        }
-                    // End usage timer on last source
+
-                    if (!string.IsNullOrEmpty(LastSourceKey))
+        /// <summary>
-                    {
+        /// 
-                        var lastSource = dict[LastSourceKey].SourceDevice;
+        /// </summary>
-
+        /// <param name="routeKey"></param>
-                        try
+		public void RunRouteAction(string routeKey)
-                        {
+		{
-                            if (lastSource != null && lastSource is IUsageTracking)
+			RunRouteAction(routeKey, null);
-                                (lastSource as IUsageTracking).UsageTracker.EndDeviceUsage();
+		}   
-                        }
+
-                        catch (Exception e)
+		/// <summary>
-                        {
+		/// Gets a source from config list SourceListKey and dynamically build and executes the
-                            Debug.Console(1, this, "*#* EXCEPTION in end usage tracking (257):\r{0}", e); 
+		/// route or commands
-                        }
+		/// </summary>
-                    }
+		/// <param name="name"></param>
-
+		public void RunRouteAction(string routeKey, Action successCallback)
-					// Let's run it
+		{
-                    if (routeKey.ToLower() != "roomoff")
+			// Run this on a separate thread
-                    {
+			new CTimer(o =>
-                        LastSourceKey = routeKey;
+				{
-                    }
+					Debug.Console(1, this, "Run route action '{0}'", routeKey);
-                    else
+					var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
-                    {
+					if(dict == null)
-                        CurrentSourceInfoKey = null;
+					{
-                    }
+						Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
-
+						return;
-					foreach (var route in item.RouteList)
+					}
-					{
+
-						// if there is a $defaultAll on route, run two separate
+					// Try to get the list item by it's string key
-						if (route.DestinationKey.Equals("$defaultAll", StringComparison.OrdinalIgnoreCase))
+					if (!dict.ContainsKey(routeKey))
-						{
+					{
-                            // Going to assume a single-path route for now
+						Debug.Console(1, this, "WARNING: No item '{0}' found on config list '{1}'", 
-							var tempVideo = new SourceRouteListItem
+							routeKey, SourceListKey);
-							{
+						return;
-								DestinationKey = "$defaultDisplay",
+					}
-								SourceKey = route.SourceKey,
+
-								Type = eRoutingSignalType.Video
+					var item = dict[routeKey];
-							};
+                    //Debug.Console(2, this, "Action {0} has {1} steps",
-                            DoRoute(tempVideo);
+                    //    item.SourceKey, item.RouteList.Count);
-
+
-                            //var tempAudio = new SourceRouteListItem
+                    // End usage timer on last source
-                            //{
+                    if (!string.IsNullOrEmpty(LastSourceKey))
-                            //    DestinationKey = "$defaultAudio",
+                    {
-                            //    SourceKey = route.SourceKey,
+                        var lastSource = dict[LastSourceKey].SourceDevice;
-                            //    Type = eRoutingSignalType.Audio
+
-                            //};
+                        try
-                            //DoRoute(tempAudio);
+                        {
-                            //continue; -- not sure why this was here
+                            if (lastSource != null && lastSource is IUsageTracking)
-						}
+                                (lastSource as IUsageTracking).UsageTracker.EndDeviceUsage();
-						else
+                        }
-							DoRoute(route);
+                        catch (Exception e)
-					}
+                        {
-
+                            Debug.Console(1, this, "*#* EXCEPTION in end usage tracking (257):\r{0}", e); 
-                    // Start usage timer on routed source
+                        }
-                    if (item.SourceDevice is IUsageTracking)
+                    }
-                    {
+
-                        (item.SourceDevice as IUsageTracking).UsageTracker.StartDeviceUsage();
+					// Let's run it
-                    }
+                    if (routeKey.ToLower() != "roomoff")
-
+                    {
-
+                        LastSourceKey = routeKey;
-
+                    }
-
+                    else
-					// Set volume control, using default if non provided
+                    {
-					IBasicVolumeControls volDev = null;
+                        CurrentSourceInfoKey = null;
-					// Handle special cases for volume control
+                    }
-					if (string.IsNullOrEmpty(item.VolumeControlKey) 
+
-						|| item.VolumeControlKey.Equals("$defaultAudio", StringComparison.OrdinalIgnoreCase))
+					foreach (var route in item.RouteList)
-						volDev = DefaultVolumeControls;
+					{
-					else if (item.VolumeControlKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
+						// if there is a $defaultAll on route, run two separate
-						volDev = DefaultDisplay as IBasicVolumeControls;
+						if (route.DestinationKey.Equals("$defaultAll", StringComparison.OrdinalIgnoreCase))
-					// Or a specific device, probably rarely used.
+						{
-					else
+                            // Going to assume a single-path route for now
-					{
+							var tempVideo = new SourceRouteListItem
-						var dev = DeviceManager.GetDeviceForKey(item.VolumeControlKey);
+							{
-						if (dev is IBasicVolumeControls)
+								DestinationKey = "$defaultDisplay",
-							volDev = dev as IBasicVolumeControls;
+								SourceKey = route.SourceKey,
-						else if (dev is IHasVolumeDevice)
+								Type = eRoutingSignalType.Video
-							volDev = (dev as IHasVolumeDevice).VolumeDevice;
+							};
-					}
+                            DoRoute(tempVideo);
-
+
-					if (volDev != CurrentVolumeControls)
+                            //var tempAudio = new SourceRouteListItem
-					{
+                            //{
-						// zero the volume on the device we are leaving.  
+                            //    DestinationKey = "$defaultAudio",
-						// Set the volume to default on device we are entering
+                            //    SourceKey = route.SourceKey,
-						if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
+                            //    Type = eRoutingSignalType.Audio
-						{
+                            //};
-							var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
+                            //DoRoute(tempAudio);
-							SavedVolumeLevels[vd] = (uint)vd.VolumeLevelFeedback.IntValue;
+                            //continue; -- not sure why this was here
-							vd.SetVolume(0);
+						}
-						}
+						else
-						CurrentVolumeControls = volDev;
+							DoRoute(route);
-						if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
+					}
-						{
+
-							var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
+                    // Start usage timer on routed source
-							ushort vol = (SavedVolumeLevels.ContainsKey(vd) ? (ushort)SavedVolumeLevels[vd] : DefaultVolume);
+                    if (item.SourceDevice is IUsageTracking)
-							vd.SetVolume(vol);
+                    {
-						}
+                        (item.SourceDevice as IUsageTracking).UsageTracker.StartDeviceUsage();
-					}
+                    }
-
+
-
+
-
+
-					// store the name and UI info for routes
+
-                    if (item.SourceKey == "$off")
+					// Set volume control, using default if non provided
-                    {
+					IBasicVolumeControls volDev = null;
-                        CurrentSourceInfoKey = routeKey;
+					// Handle special cases for volume control
-                        CurrentSourceInfo = null;
+					if (string.IsNullOrEmpty(item.VolumeControlKey) 
-                    }
+						|| item.VolumeControlKey.Equals("$defaultAudio", StringComparison.OrdinalIgnoreCase))
-                    else if (item.SourceKey != null)
+						volDev = DefaultVolumeControls;
-                    {
+					else if (item.VolumeControlKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
-                        CurrentSourceInfoKey = routeKey;
+						volDev = DefaultDisplay as IBasicVolumeControls;
-                        CurrentSourceInfo = item;
+					// Or a specific device, probably rarely used.
-                    }
+					else
-					// And finally, set the "control".  This will trigger event
+					{
-					//CurrentControlDevice = DeviceManager.GetDeviceForKey(item.SourceKey) as Device;
+						var dev = DeviceManager.GetDeviceForKey(item.VolumeControlKey);
-
+						if (dev is IBasicVolumeControls)
-					OnFeedback.FireUpdate();
+							volDev = dev as IBasicVolumeControls;
-
+						else if (dev is IHasVolumeDevice)
-					// report back when done
+							volDev = (dev as IHasVolumeDevice).VolumeDevice;
-					if (successCallback != null)
+					}
-						successCallback();
+
-
+					if (volDev != CurrentVolumeControls)
-				}, 0); // end of CTimer
+					{
-		}
+						// zero the volume on the device we are leaving.  
-
+						// Set the volume to default on device we are entering
-		/// <summary>
+						if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
-		/// Will power the room on with the last-used source
+						{
-		/// </summary>
+							var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
-		public void PowerOnToDefaultOrLastSource()
+							SavedVolumeLevels[vd] = (uint)vd.VolumeLevelFeedback.IntValue;
-		{
+							vd.SetVolume(0);
-			if (!EnablePowerOnToLastSource || LastSourceKey == null)
+						}
-				return;
+						CurrentVolumeControls = volDev;
-			RunRouteAction(LastSourceKey);
+						if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
-		}
+						{
-
+							var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
-        /// <summary>
+							ushort vol = (SavedVolumeLevels.ContainsKey(vd) ? (ushort)SavedVolumeLevels[vd] : DefaultVolume);
-        /// Does what it says
+							vd.SetVolume(vol);
-        /// </summary>
+						}
-        public override void SetDefaultLevels()
+					}
-        {
+
-            Debug.Console(1, this, "Restoring default levels");
+
-            var vc = CurrentVolumeControls as IBasicVolumeWithFeedback;
+
-            if (vc != null)
+					// store the name and UI info for routes
-                vc.SetVolume(DefaultVolume);
+                    if (item.SourceKey == "$off")
-        }
+                    {
-
+                        CurrentSourceInfoKey = routeKey;
-		/// <summary>
+                        CurrentSourceInfo = null;
-		/// 
+                    }
-		/// </summary>
+                    else if (item.SourceKey != null)
-		/// <param name="route"></param>
+                    {
-		/// <returns></returns>
+                        CurrentSourceInfoKey = routeKey;
-		bool DoRoute(SourceRouteListItem route)
+                        CurrentSourceInfo = item;
-		{
+                    }
-			IRoutingSinkNoSwitching dest = null;
+					// And finally, set the "control".  This will trigger event
-
+					//CurrentControlDevice = DeviceManager.GetDeviceForKey(item.SourceKey) as Device;
-			if (route.DestinationKey.Equals("$defaultaudio", StringComparison.OrdinalIgnoreCase))
+
-				dest = DefaultAudioDevice;
+					OnFeedback.FireUpdate();
-			else if (route.DestinationKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
+
-				dest = DefaultDisplay;
+					// report back when done
-			else
+					if (successCallback != null)
-				dest = DeviceManager.GetDeviceForKey(route.DestinationKey) as IRoutingSinkNoSwitching;
+						successCallback();
-
+
-			if (dest == null)
+				}, 0); // end of CTimer
-			{
+		}
-				Debug.Console(1, this, "Cannot route, unknown destination '{0}'", route.DestinationKey);
+
-				return false;
+		/// <summary>
-			}
+		/// Will power the room on with the last-used source
-
+		/// </summary>
-			if (route.SourceKey.Equals("$off", StringComparison.OrdinalIgnoreCase))
+		public override void PowerOnToDefaultOrLastSource()
-			{
+		{
-				dest.ReleaseRoute();
+			if (!EnablePowerOnToLastSource || LastSourceKey == null)
-				if (dest is IPower)
+				return;
-					(dest as IPower).PowerOff();
+			RunRouteAction(LastSourceKey);
-			}
+		}
-			else
+
-			{
+        /// <summary>
-				var source = DeviceManager.GetDeviceForKey(route.SourceKey) as IRoutingOutputs;
+        /// Does what it says
-				if (source == null)
+        /// </summary>
-				{
+        public override void SetDefaultLevels()
-					Debug.Console(1, this, "Cannot route unknown source '{0}' to {1}", route.SourceKey, route.DestinationKey);
+        {
-					return false;
+            Debug.Console(1, this, "Restoring default levels");
-				}
+            var vc = CurrentVolumeControls as IBasicVolumeWithFeedback;
-				dest.ReleaseAndMakeRoute(source, route.Type);
+            if (vc != null)
-			}
+                vc.SetVolume(DefaultVolume);
-			return true;
+        }
-		}
+
-
+		/// <summary>
-        public override void RoomVacatedForTimeoutPeriod(object o)
+		/// 
-        {
+		/// </summary>
-            //Implement this
+		/// <param name="route"></param>
-        }
+		/// <returns></returns>
-
+		bool DoRoute(SourceRouteListItem route)
-		/// <summary>
+		{
-		/// Runs "roomOff" action on all rooms not set to ExcludeFromGlobalFunctions
+			IRoutingSinkNoSwitching dest = null;
-		/// </summary>
+
-		public static void AllRoomsOff()
+			if (route.DestinationKey.Equals("$defaultaudio", StringComparison.OrdinalIgnoreCase))
-		{
+				dest = DefaultAudioDevice;
-			var allRooms = DeviceManager.AllDevices.Where(d => 
+			else if (route.DestinationKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
-				d is EssentialsHuddleSpaceRoom && !(d as EssentialsHuddleSpaceRoom).ExcludeFromGlobalFunctions);
+				dest = DefaultDisplay;
-			foreach (var room in allRooms)
+			else
-				(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff");
+				dest = DeviceManager.GetDeviceForKey(route.DestinationKey) as IRoutingSinkNoSwitching;
-		}
+
-	}
+			if (dest == null)
+			{
+				Debug.Console(1, this, "Cannot route, unknown destination '{0}'", route.DestinationKey);
+				return false;
+			}
+
+			if (route.SourceKey.Equals("$off", StringComparison.OrdinalIgnoreCase))
+			{
+				dest.ReleaseRoute();
+				if (dest is IPower)
+					(dest as IPower).PowerOff();
+			}
+			else
+			{
+				var source = DeviceManager.GetDeviceForKey(route.SourceKey) as IRoutingOutputs;
+				if (source == null)
+				{
+					Debug.Console(1, this, "Cannot route unknown source '{0}' to {1}", route.SourceKey, route.DestinationKey);
+					return false;
+				}
+				dest.ReleaseAndMakeRoute(source, route.Type);
+			}
+			return true;
+		}
+
+        public override void RoomVacatedForTimeoutPeriod(object o)
+        {
+            //Implement this
+        }
+
+		/// <summary>
+		/// Runs "roomOff" action on all rooms not set to ExcludeFromGlobalFunctions
+		/// </summary>
+		public static void AllRoomsOff()
+		{
+			var allRooms = DeviceManager.AllDevices.Where(d => 
+				d is EssentialsHuddleSpaceRoom && !(d as EssentialsHuddleSpaceRoom).ExcludeFromGlobalFunctions);
+			foreach (var room in allRooms)
+				(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff");
+		}
+	}
 }

PepperDashEssentials/Room/Types/EssentialsRoomBase.cs

@@ -1,264 +1,297 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
-using System.Text;
+using System.Text;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
-using PepperDash.Core;
+using Crestron.SimplSharp.Scheduler;
-using PepperDash.Essentials.Core;
+
-using PepperDash.Essentials.Devices.Common.Occupancy;
+using PepperDash.Core;
-
+using PepperDash.Essentials.Core;
-namespace PepperDash.Essentials
+using PepperDash.Essentials.Core.Config;
-{
+using PepperDash.Essentials.Core.Devices;
-    /// <summary>
+using PepperDash.Essentials.Devices.Common.Occupancy;
-    /// 
+
-    /// </summary>
+namespace PepperDash.Essentials
-    public abstract class EssentialsRoomBase : Device
+{
-    {
+    /// <summary>
-        /// <summary>
+    /// 
-        ///
+    /// </summary>
-        /// </summary>
+    public abstract class EssentialsRoomBase : ReconfigurableDevice
-        public BoolFeedback OnFeedback { get; private set; }
+    {
-
+        /// <summary>
-        public BoolFeedback IsWarmingUpFeedback { get; private set; }
+        ///
-        public BoolFeedback IsCoolingDownFeedback { get; private set; }
+        /// </summary>
-
+        public BoolFeedback OnFeedback { get; private set; }
-        public IOccupancyStatusProvider RoomOccupancy { get; private set; }
+
-
+        /// <summary>
-        public bool OccupancyStatusProviderIsRemote { get; private set; }
+        /// Fires when the RoomOccupancy object is set
-
+        /// </summary>
-        protected abstract Func<bool> IsWarmingFeedbackFunc { get; }
+        public event EventHandler<EventArgs> RoomOccupancyIsSet;
-        protected abstract Func<bool> IsCoolingFeedbackFunc { get; }
+
-
+        public BoolFeedback IsWarmingUpFeedback { get; private set; }
-        /// <summary>
+        public BoolFeedback IsCoolingDownFeedback { get; private set; }
-        /// Timer used for informing the UIs of a shutdown
+
-        /// </summary>        
+        public IOccupancyStatusProvider RoomOccupancy { get; private set; }
-        public SecondsCountdownTimer ShutdownPromptTimer { get; private set; }
+
-
+        public bool OccupancyStatusProviderIsRemote { get; private set; }
-        /// <summary>
+
-        /// 
+        protected abstract Func<bool> IsWarmingFeedbackFunc { get; }
-        /// </summary>
+        protected abstract Func<bool> IsCoolingFeedbackFunc { get; }
-        public int ShutdownPromptSeconds { get; set; }
+
-        public int ShutdownVacancySeconds { get; set; }
+        /// <summary>
-        public eShutdownType ShutdownType { get; private set; }
+        /// Timer used for informing the UIs of a shutdown
-
+        /// </summary>        
-        public PepperDash.Essentials.Room.EssentialsRoomEmergencyBase Emergency { get; set; }
+        public SecondsCountdownTimer ShutdownPromptTimer { get; private set; }
-
+
-        public PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController MicrophonePrivacy { get; set; }
+        /// <summary>
-
+        /// 
-        public string LogoUrl { get; set; }
+        /// </summary>
-
+        public int ShutdownPromptSeconds { get; set; }
-        protected SecondsCountdownTimer RoomVacancyShutdownTimer { get; private set; }
+        public int ShutdownVacancySeconds { get; set; }
-
+        public eShutdownType ShutdownType { get; private set; }
-        public eVacancyMode VacancyMode { get; private set; }
+
-
+        public PepperDash.Essentials.Room.EssentialsRoomEmergencyBase Emergency { get; set; }
-        /// <summary>
+
-        /// Seconds after vacancy prompt is displayed until shutdown
+        public PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController MicrophonePrivacy { get; set; }
-        /// </summary>
+
-        protected int RoomVacancyShutdownSeconds;
+        public string LogoUrl { get; set; }
-
+
-        /// <summary>
+        protected SecondsCountdownTimer RoomVacancyShutdownTimer { get; private set; }
-        /// Seconds after vacancy detected until prompt is displayed
+
-        /// </summary>
+        public eVacancyMode VacancyMode { get; private set; }
-        protected int RoomVacancyShutdownPromptSeconds;
+
-
+        /// <summary>
-        /// <summary>
+        /// Seconds after vacancy prompt is displayed until shutdown
-        /// 
+        /// </summary>
-        /// </summary>
+        protected int RoomVacancyShutdownSeconds;
-        protected abstract Func<bool> OnFeedbackFunc { get; }
+
-
+        /// <summary>
-		protected Dictionary<IBasicVolumeWithFeedback, uint> SavedVolumeLevels = new Dictionary<IBasicVolumeWithFeedback, uint>();
+        /// Seconds after vacancy detected until prompt is displayed
-
+        /// </summary>
-		/// <summary>
+        protected int RoomVacancyShutdownPromptSeconds;
-		/// When volume control devices change, should we zero the one that we are leaving?
+
-		/// </summary>
+        /// <summary>
-		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; private set; }
+        /// 
-
+        /// </summary>
-        /// <summary>
+        protected abstract Func<bool> OnFeedbackFunc { get; }
-        /// 
+
-        /// </summary>
+		protected Dictionary<IBasicVolumeWithFeedback, uint> SavedVolumeLevels = new Dictionary<IBasicVolumeWithFeedback, uint>();
-        /// <param name="key"></param>
+
-        /// <param name="name"></param>
+		/// <summary>
-        public EssentialsRoomBase(string key, string name) : base(key, name)
+		/// When volume control devices change, should we zero the one that we are leaving?
-        {
+		/// </summary>
-            // Setup the ShutdownPromptTimer
+		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; private set; }
-            ShutdownPromptTimer = new SecondsCountdownTimer(Key + "-offTimer");
+
-            ShutdownPromptTimer.IsRunningFeedback.OutputChange += (o, a) =>
+
-            {
+        public EssentialsRoomBase(DeviceConfig config)
-                if (!ShutdownPromptTimer.IsRunningFeedback.BoolValue)
+            : base(config)
-                    ShutdownType = eShutdownType.None;
+        {
-            };
+            // Setup the ShutdownPromptTimer
-            ShutdownPromptTimer.HasFinished += (o, a) => Shutdown(); // Shutdown is triggered 
+            ShutdownPromptTimer = new SecondsCountdownTimer(Key + "-offTimer");
-
+            ShutdownPromptTimer.IsRunningFeedback.OutputChange += (o, a) =>
-            ShutdownPromptSeconds = 60;
+            {
-            ShutdownVacancySeconds = 120;
+                if (!ShutdownPromptTimer.IsRunningFeedback.BoolValue)
-            ShutdownType = eShutdownType.None;
+                    ShutdownType = eShutdownType.None;
-
+            };
-            RoomVacancyShutdownTimer = new SecondsCountdownTimer(Key + "-vacancyOffTimer");
+            ShutdownPromptTimer.HasFinished += (o, a) => Shutdown(); // Shutdown is triggered 
-            //RoomVacancyShutdownTimer.IsRunningFeedback.OutputChange += (o, a) =>
+
-            //{
+            ShutdownPromptSeconds = 60;
-            //    if (!RoomVacancyShutdownTimer.IsRunningFeedback.BoolValue)
+            ShutdownVacancySeconds = 120;
-            //        ShutdownType = ShutdownType.Vacancy;
+            ShutdownType = eShutdownType.None;
-            //};
+
-            RoomVacancyShutdownTimer.HasFinished += new EventHandler<EventArgs>(RoomVacancyShutdownPromptTimer_HasFinished); // Shutdown is triggered
+            RoomVacancyShutdownTimer = new SecondsCountdownTimer(Key + "-vacancyOffTimer");
-
+            //RoomVacancyShutdownTimer.IsRunningFeedback.OutputChange += (o, a) =>
-            RoomVacancyShutdownPromptSeconds = 1500;    //  25 min to prompt warning
+            //{
-            RoomVacancyShutdownSeconds = 240;           //  4 min after prompt will trigger shutdown prompt
+            //    if (!RoomVacancyShutdownTimer.IsRunningFeedback.BoolValue)
-            VacancyMode = eVacancyMode.None;
+            //        ShutdownType = ShutdownType.Vacancy;
-
+            //};
-            OnFeedback = new BoolFeedback(OnFeedbackFunc);
+            RoomVacancyShutdownTimer.HasFinished += new EventHandler<EventArgs>(RoomVacancyShutdownPromptTimer_HasFinished); // Shutdown is triggered
-
+
-            IsWarmingUpFeedback = new BoolFeedback(IsWarmingFeedbackFunc);
+            RoomVacancyShutdownPromptSeconds = 1500;    //  25 min to prompt warning
-            IsCoolingDownFeedback = new BoolFeedback(IsCoolingFeedbackFunc);
+            RoomVacancyShutdownSeconds = 240;           //  4 min after prompt will trigger shutdown prompt
-        }
+            VacancyMode = eVacancyMode.None;
-
+
-        void RoomVacancyShutdownPromptTimer_HasFinished(object sender, EventArgs e)
+            OnFeedback = new BoolFeedback(OnFeedbackFunc);
-        {
+
-            switch (VacancyMode)
+            IsWarmingUpFeedback = new BoolFeedback(IsWarmingFeedbackFunc);
-            {
+            IsCoolingDownFeedback = new BoolFeedback(IsCoolingFeedbackFunc);
-                case eVacancyMode.None:
+
-                    StartRoomVacancyTimer(eVacancyMode.InInitialVacancy);
+            AddPostActivationAction(() =>
-                    break;
+            {
-                case eVacancyMode.InInitialVacancy:
+                if (RoomOccupancy != null)
-                    StartRoomVacancyTimer(eVacancyMode.InShutdownWarning);
+                    OnRoomOccupancyIsSet();
-                    break;
+            });
-                case eVacancyMode.InShutdownWarning:
+        }
-                    {
+
-                        StartShutdown(eShutdownType.Vacancy);
+        void RoomVacancyShutdownPromptTimer_HasFinished(object sender, EventArgs e)
-                        Debug.Console(0, this, "Shutting Down due to vacancy.");
+        {
-                        break;
+            switch (VacancyMode)
-                    }
+            {
-                default:
+                case eVacancyMode.None:
-                    break;
+                    StartRoomVacancyTimer(eVacancyMode.InInitialVacancy);
-            }
+                    break;
-        }
+                case eVacancyMode.InInitialVacancy:
-
+                    StartRoomVacancyTimer(eVacancyMode.InShutdownWarning);
-        /// <summary>
+                    break;
-        /// 
+                case eVacancyMode.InShutdownWarning:
-        /// </summary>
+                    {
-        /// <param name="type"></param>
+                        StartShutdown(eShutdownType.Vacancy);
-        public void StartShutdown(eShutdownType type)
+                        Debug.Console(0, this, "Shutting Down due to vacancy.");
-        {
+                        break;
-            // Check for shutdowns running. Manual should override other shutdowns
+                    }
-
+                default:
-            if (type == eShutdownType.Manual)
+                    break;
-                ShutdownPromptTimer.SecondsToCount = ShutdownPromptSeconds;
+            }
-            else if (type == eShutdownType.Vacancy)
+        }
-                ShutdownPromptTimer.SecondsToCount = ShutdownVacancySeconds;
+
-            ShutdownType = type;
+        /// <summary>
-            ShutdownPromptTimer.Start();
+        /// 
-        }
+        /// </summary>
-
+        /// <param name="type"></param>
-        public void StartRoomVacancyTimer(eVacancyMode mode)
+        public void StartShutdown(eShutdownType type)
-        {
+        {
-            if (mode == eVacancyMode.None)
+            // Check for shutdowns running. Manual should override other shutdowns
-                RoomVacancyShutdownTimer.SecondsToCount = RoomVacancyShutdownPromptSeconds;
+
-            else if (mode == eVacancyMode.InInitialVacancy)
+            if (type == eShutdownType.Manual)
-                RoomVacancyShutdownTimer.SecondsToCount = RoomVacancyShutdownSeconds;
+                ShutdownPromptTimer.SecondsToCount = ShutdownPromptSeconds;
-            VacancyMode = mode;
+            else if (type == eShutdownType.Vacancy)
-            RoomVacancyShutdownTimer.Start();
+                ShutdownPromptTimer.SecondsToCount = ShutdownVacancySeconds;
-
+            ShutdownType = type;
-            Debug.Console(0, this, "Vacancy Timer Started.");
+            ShutdownPromptTimer.Start();
-        }
+
-
+            Debug.Console(0, this, "ShutdwonPromptTimer Started. Type: {0}.  Seconds: {1}", ShutdownType, ShutdownPromptTimer.SecondsToCount);
-        /// <summary>
+        }
-        /// Resets the vacancy mode and shutsdwon the room
+
-        /// </summary>
+        public void StartRoomVacancyTimer(eVacancyMode mode)
-        public void Shutdown()
+        {
-        {
+            if (mode == eVacancyMode.None)
-            VacancyMode = eVacancyMode.None;
+                RoomVacancyShutdownTimer.SecondsToCount = RoomVacancyShutdownPromptSeconds;
-            EndShutdown();
+            else if (mode == eVacancyMode.InInitialVacancy)
-        }
+                RoomVacancyShutdownTimer.SecondsToCount = RoomVacancyShutdownSeconds;
-
+            VacancyMode = mode;
-        /// <summary>
+            RoomVacancyShutdownTimer.Start();
-        /// This method is for the derived class to define it's specific shutdown
+
-        /// requirements but should not be called directly.  It is called by Shutdown()
+            Debug.Console(0, this, "Vacancy Timer Started. Mode: {0}.  Seconds: {1}", VacancyMode, RoomVacancyShutdownTimer.SecondsToCount);
-        /// </summary>
+        }
-        protected abstract void EndShutdown();
+
-
+        /// <summary>
-
+        /// Resets the vacancy mode and shutsdwon the room
-        /// <summary>
+        /// </summary>
-        /// Override this to implement a default volume level(s) method
+        public void Shutdown()
-        /// </summary>
+        {
-        public abstract void SetDefaultLevels();
+            VacancyMode = eVacancyMode.None;
-
+            EndShutdown();
-        /// <summary>
+        }
-        /// Sets the object to be used as the IOccupancyStatusProvider for the room. Can be an Occupancy Aggregator or a specific device
+
-        /// </summary>
+        /// <summary>
-        /// <param name="statusProvider"></param>
+        /// This method is for the derived class to define it's specific shutdown
-        public void SetRoomOccupancy(IOccupancyStatusProvider statusProvider, int timeoutMinutes)
+        /// requirements but should not be called directly.  It is called by Shutdown()
-        {
+        /// </summary>
-			if (statusProvider == null)
+        protected abstract void EndShutdown();
-			{
+
-				Debug.Console(0, this, "ERROR: Occupancy sensor device is null");
+
-				return;
+        /// <summary>
-			}
+        /// Override this to implement a default volume level(s) method
-
+        /// </summary>
-            // If status provider is fusion, set flag to remote
+        public abstract void SetDefaultLevels();
-            if (statusProvider is PepperDash.Essentials.Fusion.EssentialsHuddleSpaceFusionSystemControllerBase)
+
-                OccupancyStatusProviderIsRemote = true;
+        /// <summary>
-
+        /// Sets the object to be used as the IOccupancyStatusProvider for the room. Can be an Occupancy Aggregator or a specific device
-            if(timeoutMinutes > 0)
+        /// </summary>
-                RoomVacancyShutdownSeconds = timeoutMinutes * 60;
+        /// <param name="statusProvider"></param>
-
+        public void SetRoomOccupancy(IOccupancyStatusProvider statusProvider, int timeoutMinutes)
-            RoomOccupancy = statusProvider;
+        { 
-
+			if (statusProvider == null)
-            RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += RoomIsOccupiedFeedback_OutputChange;
+			{
-        }
+				Debug.Console(0, this, "ERROR: Occupancy sensor device is null");
-
+				return;
-        void RoomIsOccupiedFeedback_OutputChange(object sender, EventArgs e)
+			}
-        {
+
-            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false)
+            // If status provider is fusion, set flag to remote
-            {
+            if (statusProvider is PepperDash.Essentials.Fusion.EssentialsHuddleSpaceFusionSystemControllerBase)
-                Debug.Console(1, this, "Notice: Vacancy Detected");
+                OccupancyStatusProviderIsRemote = true;
-                // Trigger the timer when the room is vacant
+
-                StartRoomVacancyTimer(eVacancyMode.InInitialVacancy);
+            if(timeoutMinutes > 0)
-            }
+                RoomVacancyShutdownSeconds = timeoutMinutes * 60;
-            else
+
-            {
+            Debug.Console(1, this, "RoomVacancyShutdownSeconds set to {0}", RoomVacancyShutdownSeconds);
-                Debug.Console(1, this, "Notice: Occupancy Detected");
+
-                // Reset the timer when the room is occupied
+            RoomOccupancy = statusProvider;
-
+
-                    RoomVacancyShutdownTimer.Cancel();
+            OnRoomOccupancyIsSet();
-            }
+
-        }
+            RoomOccupancy.RoomIsOccupiedFeedback.OutputChange -= RoomIsOccupiedFeedback_OutputChange;
-
+            RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += RoomIsOccupiedFeedback_OutputChange;
-		//void SwapVolumeDevices(IBasicVolumeControls currentDevice, IBasicVolumeControls newDevice)
+
-		//{
+            Debug.Console(0, this, "Room Occupancy set to device: '{0}'", (statusProvider as Device).Key);
-
+        }
-		//}
+
-
+        void OnRoomOccupancyIsSet()
-        /// <summary>
+        {
-        /// Executes when RoomVacancyShutdownTimer expires.  Used to trigger specific room actions as needed.  Must nullify the timer object when executed
+            var handler = RoomOccupancyIsSet;
-        /// </summary>
+            if (handler != null)
-        /// <param name="o"></param>
+                handler(this, new EventArgs());
-        public abstract void RoomVacatedForTimeoutPeriod(object o);
+        }
-    }
+
-        
+        /// <summary>
-    /// <summary>
+        /// To allow base class to power room on to last source
-    /// To describe the various ways a room may be shutting down
+        /// </summary>
-    /// </summary>
+        public abstract void PowerOnToDefaultOrLastSource();
-    public enum eShutdownType
+
-    {
+        /// <summary>
-        None = 0,
+        /// To allow base class to power room on to default source
-        External,
+        /// </summary>
-        Manual,
+        /// <returns></returns>
-        Vacancy
+        public abstract bool RunDefaultPresentRoute();
-    }
+
-
+        void RoomIsOccupiedFeedback_OutputChange(object sender, EventArgs e)
-    public enum eVacancyMode
+        {
-    {
+            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false)
-        None = 0,
+            {
-        InInitialVacancy,
+                Debug.Console(1, this, "Notice: Vacancy Detected");
-        InShutdownWarning
+                // Trigger the timer when the room is vacant
-    }
+                StartRoomVacancyTimer(eVacancyMode.InInitialVacancy);
-
+            }
-    /// <summary>
+            else
-    /// 
+            {
-    /// </summary>
+                Debug.Console(1, this, "Notice: Occupancy Detected");
-    public enum eWarmingCoolingMode
+                // Reset the timer when the room is occupied
-    {
+                RoomVacancyShutdownTimer.Cancel();
-        None,
+            }
-        Warming,
+        }
-        Cooling
+
-    }
+        /// <summary>
+        /// Executes when RoomVacancyShutdownTimer expires.  Used to trigger specific room actions as needed.  Must nullify the timer object when executed
+        /// </summary>
+        /// <param name="o"></param>
+        public abstract void RoomVacatedForTimeoutPeriod(object o);
+    }
+        
+    /// <summary>
+    /// To describe the various ways a room may be shutting down
+    /// </summary>
+    public enum eShutdownType
+    {
+        None = 0,
+        External,
+        Manual,
+        Vacancy
+    }
+
+    public enum eVacancyMode
+    {
+        None = 0,
+        InInitialVacancy,
+        InShutdownWarning
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public enum eWarmingCoolingMode
+    {
+        None,
+        Warming,
+        Cooling
+    }
 }

PepperDashEssentials/UIDrivers/Essentials/EssentialsHeaderDriver.cs

@@ -76,7 +76,7 @@ namespace PepperDash.Essentials
                 avDriver.PopupInterlock.HideAndClear());
         }
 
-        void SetUpHelpButton(EssentialsRoomPropertiesConfig roomConf)
+        public void SetUpHelpButton(EssentialsRoomPropertiesConfig roomConf)
         {
             // Help roomConf and popup
             if (roomConf.Help != null)
@@ -107,7 +107,7 @@ namespace PepperDash.Essentials
                 var room = DeviceManager.GetDeviceForKey(Config.DefaultRoomKey)
                     as EssentialsHuddleSpaceRoom;
                 if (room != null)
-                    message = room.Config.HelpMessage;
+                    message = room.PropertiesConfig.HelpMessage;
                 else
                     message = "Sorry, no help message available. No room connected.";
                 //TriList.StringInput[UIStringJoin.HelpMessage].StringValue = message;
@@ -227,7 +227,7 @@ namespace PepperDash.Essentials
 
             TriList.SetBool(UIBoolJoin.TopBarHabaneroDynamicVisible, true);
 
-            var roomConf = currentRoom.Config;
+            var roomConf = currentRoom.PropertiesConfig;
 
             // Register for the PopupInterlock IsShowsFeedback event to tie the header carets subpage visiblity to it
             Parent.AvDriver.PopupInterlock.StatusChanged -= PopupInterlock_StatusChanged;
@@ -289,7 +289,7 @@ namespace PepperDash.Essentials
 
             TriList.SetBool(UIBoolJoin.TopBarHabaneroDynamicVisible, true);
 
-            var roomConf = currentRoom.Config;
+            var roomConf = currentRoom.PropertiesConfig;
 
             // Register for the PopupInterlock IsShowsFeedback event to tie the header carets subpage visiblity to it
             Parent.AvDriver.PopupInterlock.StatusChanged -= PopupInterlock_StatusChanged;

PepperDashEssentials/UIDrivers/EssentialsHuddle/EssentialsHuddlePanelAvFunctionsDriver.cs

@@ -6,6 +6,7 @@ using Crestron.SimplSharpPro.UI;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.SmartObjects;
 using PepperDash.Essentials.Core.PageManagers;
 
@@ -163,7 +164,7 @@ namespace PepperDash.Essentials
             get
             {
                 if (_TechDriver == null)
-                    _TechDriver = new PepperDash.Essentials.UIDrivers.EssentialsHuddleTechPageDriver(TriList, CurrentRoom.Config.Tech);
+                    _TechDriver = new PepperDash.Essentials.UIDrivers.EssentialsHuddleTechPageDriver(TriList, CurrentRoom.PropertiesConfig.Tech);
                 return _TechDriver;
             }
         }
@@ -219,9 +220,7 @@ namespace PepperDash.Essentials
                 return;
             }
 
-            var roomConf = CurrentRoom.Config;
+            var roomConf = CurrentRoom.PropertiesConfig;
-
-            TriList.SetString(UIStringJoin.CurrentRoomName, CurrentRoom.Name);
 
             if (Config.HeaderStyle.ToLower() == CrestronTouchpanelPropertiesConfig.Habanero)
             {
@@ -592,7 +591,7 @@ namespace PepperDash.Essentials
             EndMeetingButtonSig.BoolValue = true;
             ShareButtonSig.BoolValue = false;
 
-            if (CurrentRoom.ShutdownType == eShutdownType.Manual)
+            if (CurrentRoom.ShutdownType == eShutdownType.Manual || CurrentRoom.ShutdownType == eShutdownType.Vacancy)
             {
                 PowerDownModal = new ModalDialog(TriList);
                 var message = string.Format("Meeting will end in {0} seconds", CurrentRoom.ShutdownPromptSeconds);
@@ -723,20 +722,19 @@ namespace PepperDash.Essentials
 				CurrentRoom.CurrentVolumeControls.VolumeDown(state);
 		}
 
-		/// <summary>
+
-		/// Helper for property setter. Sets the panel to the given room, latching up all functionality
+        /// <summary>
-		/// </summary>
+        /// Helper for property setter. Sets the panel to the given room, latching up all functionality
-		void SetCurrentRoom(EssentialsHuddleSpaceRoom room)
+        /// </summary>
-		{
+        public void RefreshCurrentRoom(EssentialsHuddleSpaceRoom room)
-			if (_CurrentRoom == room) return;
+        {
-            // Disconnect current (probably never called)
+            if (_CurrentRoom != null)
-			if (_CurrentRoom != null)
+            {
-			{
+                // Disconnect current room
-				// Disconnect current room
+                _CurrentRoom.CurrentVolumeDeviceChange -= this.CurrentRoom_CurrentAudioDeviceChange;
-				_CurrentRoom.CurrentVolumeDeviceChange -= this.CurrentRoom_CurrentAudioDeviceChange;
+                ClearAudioDeviceConnections();
-				ClearAudioDeviceConnections();
+                _CurrentRoom.CurrentSingleSourceChange -= this.CurrentRoom_SourceInfoChange;
-				_CurrentRoom.CurrentSingleSourceChange -= this.CurrentRoom_SourceInfoChange;
+                DisconnectSource(_CurrentRoom.CurrentSourceInfo);
-				DisconnectSource(_CurrentRoom.CurrentSourceInfo);
                 _CurrentRoom.ShutdownPromptTimer.HasStarted -= ShutdownPromptTimer_HasStarted;
                 _CurrentRoom.ShutdownPromptTimer.HasFinished -= ShutdownPromptTimer_HasFinished;
                 _CurrentRoom.ShutdownPromptTimer.WasCancelled -= ShutdownPromptTimer_WasCancelled;
@@ -746,40 +744,40 @@ namespace PepperDash.Essentials
                 _CurrentRoom.IsCoolingDownFeedback.OutputChange -= IsCoolingDownFeedback_OutputChange;
             }
 
-			_CurrentRoom = room;
+            _CurrentRoom = room;
 
-			if (_CurrentRoom != null)
+            if (_CurrentRoom != null)
-			{
+            {
-				// get the source list config and set up the source list
+                // get the source list config and set up the source list
-				var config = ConfigReader.ConfigObject.SourceLists;
+                var config = ConfigReader.ConfigObject.SourceLists;
-				if (config.ContainsKey(_CurrentRoom.SourceListKey))
+                if (config.ContainsKey(_CurrentRoom.SourceListKey))
-				{
+                {
-					var srcList = config[_CurrentRoom.SourceListKey];
+                    var srcList = config[_CurrentRoom.SourceListKey];
-					// Setup sources list			
+                    // Setup sources list			
-					uint i = 1; // counter for UI list
+                    uint i = 1; // counter for UI list
-					foreach (var kvp in srcList)
+                    foreach (var kvp in srcList)
-					{
+                    {
-						var srcConfig = kvp.Value;
+                        var srcConfig = kvp.Value;
-						if (!srcConfig.IncludeInSourceList) // Skip sources marked this way
+                        if (!srcConfig.IncludeInSourceList) // Skip sources marked this way
-							continue;
+                            continue;
 
-						var actualSource = DeviceManager.GetDeviceForKey(srcConfig.SourceKey) as Device;
+                        var actualSource = DeviceManager.GetDeviceForKey(srcConfig.SourceKey) as Device;
-						if (actualSource == null)
+                        if (actualSource == null)
-						{
+                        {
-							Debug.Console(1, "Cannot assign missing source '{0}' to source UI list",
+                            Debug.Console(1, "Cannot assign missing source '{0}' to source UI list",
-								srcConfig.SourceKey);
+                                srcConfig.SourceKey);
-							continue;
+                            continue;
-						}
+                        }
-						var routeKey = kvp.Key;
+                        var routeKey = kvp.Key;
                         var item = new SubpageReferenceListSourceItem(i++, SourcesSrl, srcConfig,
                             b => { if (!b) UiSelectSource(routeKey); });
                         SourcesSrl.AddItem(item); // add to the SRL
                         item.RegisterForSourceChange(_CurrentRoom);
-					}
+                    }
                     SourcesSrl.Count = (ushort)(i - 1);
-				}
+                }
                 // Name and logo
-				TriList.StringInput[UIStringJoin.CurrentRoomName].StringValue = _CurrentRoom.Name;
+                TriList.StringInput[UIStringJoin.CurrentRoomName].StringValue = _CurrentRoom.Name;
                 if (_CurrentRoom.LogoUrl == null)
                 {
                     TriList.BooleanInput[UIBoolJoin.LogoDefaultVisible].BoolValue = true;
@@ -803,97 +801,40 @@ namespace PepperDash.Essentials
                 _CurrentRoom.IsWarmingUpFeedback.OutputChange += CurrentRoom_IsWarmingFeedback_OutputChange;
                 _CurrentRoom.IsCoolingDownFeedback.OutputChange += IsCoolingDownFeedback_OutputChange;
 
-				_CurrentRoom.CurrentVolumeDeviceChange += CurrentRoom_CurrentAudioDeviceChange;
+                _CurrentRoom.CurrentVolumeDeviceChange += CurrentRoom_CurrentAudioDeviceChange;
-				RefreshAudioDeviceConnections();
+                RefreshAudioDeviceConnections();
-				_CurrentRoom.CurrentSingleSourceChange += CurrentRoom_SourceInfoChange;
+                _CurrentRoom.CurrentSingleSourceChange += CurrentRoom_SourceInfoChange;
-				RefreshSourceInfo();
+                RefreshSourceInfo();
 
                 (Parent as EssentialsPanelMainInterfaceDriver).HeaderDriver.SetupHeaderButtons(this, CurrentRoom);
             }
-			else
+            else
-			{
+            {
-				// Clear sigs that need to be
+                // Clear sigs that need to be
-				TriList.StringInput[UIStringJoin.CurrentRoomName].StringValue = "Select a room";
+                TriList.StringInput[UIStringJoin.CurrentRoomName].StringValue = "Select a room";
-			}
+            }
+        }
+
+		void SetCurrentRoom(EssentialsHuddleSpaceRoom room)
+		{
+			if (_CurrentRoom == room) return;
+            // Disconnect current (probably never called)
+
+            room.ConfigChanged -= room_ConfigChanged;
+            room.ConfigChanged += room_ConfigChanged;
+
+            RefreshCurrentRoom(room);
 		}
 
-        //void SetupHeaderButtons()
+        /// <summary>
-        //{
+        /// Fires when room config of current room has changed.  Meant to refresh room values to propegate any updates to UI
-        //    HeaderButtonsAreSetUp = false;
+        /// </summary>
-
+        /// <param name="sender"></param>
-        //    TriList.SetBool(UIBoolJoin.TopBarHabaneroDynamicVisible, true);
+        /// <param name="e"></param>
-
+        void room_ConfigChanged(object sender, EventArgs e)
-        //    var roomConf = CurrentRoom.Config;
+        {
-
+            RefreshCurrentRoom(_CurrentRoom);
-        //    // Gear
+        }
-        //    TriList.SetString(UIStringJoin.HeaderButtonIcon5, "Gear");
-        //    TriList.SetSigHeldAction(UIBoolJoin.HeaderIcon5Press, 2000,
-        //        ShowTech,
-        //        null,
-        //        () =>
-        //        {
-        //            if (CurrentRoom.OnFeedback.BoolValue)
-        //                PopupInterlock.ShowInterlockedWithToggle(UIBoolJoin.VolumesPageVisible);
-        //            else
-        //                PopupInterlock.ShowInterlockedWithToggle(UIBoolJoin.VolumesPagePowerOffVisible);
-        //        });
-        //    TriList.SetSigFalseAction(UIBoolJoin.TechExitButton, () =>
-        //        PopupInterlock.HideAndClear());
-
-        //    // Help button and popup
-        //    if (CurrentRoom.Config.Help != null)
-        //    {
-        //        TriList.SetString(UIStringJoin.HelpMessage, roomConf.Help.Message);
-        //        TriList.SetBool(UIBoolJoin.HelpPageShowCallButtonVisible, roomConf.Help.ShowCallButton);
-        //        TriList.SetString(UIStringJoin.HelpPageCallButtonText, roomConf.Help.CallButtonText);
-        //        if (roomConf.Help.ShowCallButton)
-        //            TriList.SetSigFalseAction(UIBoolJoin.HelpPageShowCallButtonPress, () => { }); // ************ FILL IN
-        //        else
-        //            TriList.ClearBoolSigAction(UIBoolJoin.HelpPageShowCallButtonPress);
-        //    }
-        //    else // older config
-        //    {
-        //        TriList.SetString(UIStringJoin.HelpMessage, CurrentRoom.Config.HelpMessage);
-        //        TriList.SetBool(UIBoolJoin.HelpPageShowCallButtonVisible, false);
-        //        TriList.SetString(UIStringJoin.HelpPageCallButtonText, null);
-        //        TriList.ClearBoolSigAction(UIBoolJoin.HelpPageShowCallButtonPress);
-        //    }
-        //    TriList.SetString(UIStringJoin.HeaderButtonIcon4, "Help");
-        //    TriList.SetSigFalseAction(UIBoolJoin.HeaderIcon4Press, () =>
-        //    {
-        //        string message = null;
-        //        var room = DeviceManager.GetDeviceForKey(Config.DefaultRoomKey)
-        //            as EssentialsHuddleSpaceRoom;
-        //        if (room != null)
-        //            message = room.Config.HelpMessage;
-        //        else
-        //            message = "Sorry, no help message available. No room connected.";
-        //        //TriList.StringInput[UIStringJoin.HelpMessage].StringValue = message;
-        //        PopupInterlock.ShowInterlockedWithToggle(UIBoolJoin.HelpPageVisible);
-        //    });
-        //    uint nextJoin = 3953;
-
-        //    //// Calendar button
-        //    //if (_CurrentRoom.ScheduleSource != null)
-        //    //{
-        //    //    TriList.SetString(nextJoin, "Calendar");
-        //    //    TriList.SetSigFalseAction(nextJoin, CalendarPress);
-
-        //    //    nextJoin--;
-        //    //}
-
-        //    //nextJoin--;
-
-        //    // blank any that remain
-        //    for (var i = nextJoin; i > 3950; i--)
-        //    {
-        //        TriList.SetString(i, "Blank");
-        //        TriList.SetSigFalseAction(i, () => { });
-        //    }
-
-        //    HeaderButtonsAreSetUp = true;
-        //}
-
 
         /// <summary>
         /// For room on/off changes

PepperDashEssentials/UIDrivers/EssentialsHuddle/EssentialsHuddleTechPageDriver.cs

@@ -8,7 +8,8 @@ using Crestron.SimplSharpPro.DeviceSupport;
 
 using PepperDash.Core;
 using PepperDash.Essentials;
-using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.SmartObjects;
 using PepperDash.Essentials.Core.Touchpanels.Keyboards;
 using PepperDash.Essentials.Devices.Displays;

PepperDashEssentials/UIDrivers/VC/EssentialsVideoCodecUiDriver.cs

@@ -484,9 +484,9 @@ namespace PepperDash.Essentials.UIDrivers.VC
 					TriList.SetString(timeTextOffset + i, timeText);
 
 					string iconName = null;
-					if (c.OccurenceType == eCodecOccurrenceType.Received)
+					if (c.OccurrenceType == eCodecOccurrenceType.Received)
                         iconName = "Misc-18_Light";
-                    else if (c.OccurenceType == eCodecOccurrenceType.Placed)
+                    else if (c.OccurrenceType == eCodecOccurrenceType.Placed)
                         iconName = "Misc-17_Light";
 					else
 						iconName = "Delete";

devjson commands.json

@@ -12,7 +12,7 @@ devjson:1 {"deviceKey":"timer","methodName":"Cancel" }
 
 devjson:1 {"deviceKey":"timer","methodName":"Reset" }
 
-devjson:10 {"deviceKey":"room1","methodName":"Shutdown" }
+devjson:1 {"deviceKey":"room1","methodName":"Shutdown" }
 
 devjson:1 {"deviceKey":"mockVc-1", "methodName":"TestIncomingVideoCall", "params": ["123-456-7890"]}
 
@@ -30,8 +30,8 @@ devjson:1 {"deviceKey":"room1.InCallFeedback","methodName":"SetTestValue", "para
 
 devjson:1 {"deviceKey":"room1.InCallFeedback","methodName":"ClearTestValue", "params": []}
 
+devjson:3 {"deviceKey":"room1.RoomOccupancy.RoomIsOccupiedFeedback","methodName":"SetTestValue", "params": [ true ]}
 
+devjson:2 {"deviceKey":"codec-comms-ssh", "methodName":"SendText", "params": ["xcommand dial number: 10.11.50.211\r"]}
 
-devjson:10 {"deviceKey":"mobileControlBridge-essentialsHuddle","methodName":"TestOne"}
+devjson:2 {"deviceKey":"codec-comms-ssh", "methodName":"Connect", "params": []}
-devjson:10 {"deviceKey":"mobileControlBridge-essentialsHuddle","methodName":"TestMulti"}
-  devjson:10 {"deviceKey":"room1","methodName":"RunDefaultPresentRoute"}