Merged in feature/ecs-1251 (pull request #45)

Feature/ecs 1251

Approved-by: Neil Dorin <ndorin@pepperdash.com>

.gitignore

@@ -20,4 +20,5 @@ obj/
 [Rr]elease*/
 _ReSharper*/
 SIMPLSharpLogs/
-*.projectinfo
+*.projectinfo
+essentials-framework/EssentialDMTestConfig/

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "essentials-framework"]
-	path = essentials-framework
-	url = https://bitbucket.org/Pepperdash_Products/essentials-framework.git
+[submodule "essentials-framework/pepperdashcore-builds"]
+	path = essentials-framework/pepperdashcore-builds
+	url = https://bitbucket.org/Pepperdash_Products/pepperdashcore-builds.git

PepperDashEssentials.sln

@@ -1,49 +1,49 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual Studio 2008
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDashEssentials", ".\PepperDashEssentials\PepperDashEssentials.csproj", "{1BED5BA9-88C4-4365-9362-6F4B128071D3}"
-	ProjectSection(ProjectDependencies) = postProject
-		{892B761C-E479-44CE-BD74-243E9214AF13} = {892B761C-E479-44CE-BD74-243E9214AF13}
-		{9199CE8A-0C9F-4952-8672-3EED798B284F} = {9199CE8A-0C9F-4952-8672-3EED798B284F}
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDash_Essentials_Core", ".\essentials-framework\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj", "{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials Devices Common", ".\essentials-framework\Essentials Devices Common\Essentials Devices Common\Essentials Devices Common.csproj", "{892B761C-E479-44CE-BD74-243E9214AF13}"
-	ProjectSection(ProjectDependencies) = postProject
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials_DM", ".\essentials-framework\Essentials DM\Essentials_DM\Essentials_DM.csproj", "{9199CE8A-0C9F-4952-8672-3EED798B284F}"
-	ProjectSection(ProjectDependencies) = postProject
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDashEssentials", ".\PepperDashEssentials\PepperDashEssentials.csproj", "{1BED5BA9-88C4-4365-9362-6F4B128071D3}"
+	ProjectSection(ProjectDependencies) = postProject
+		{892B761C-E479-44CE-BD74-243E9214AF13} = {892B761C-E479-44CE-BD74-243E9214AF13}
+		{9199CE8A-0C9F-4952-8672-3EED798B284F} = {9199CE8A-0C9F-4952-8672-3EED798B284F}
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDash_Essentials_Core", ".\essentials-framework\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj", "{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials Devices Common", ".\essentials-framework\Essentials Devices Common\Essentials Devices Common\Essentials Devices Common.csproj", "{892B761C-E479-44CE-BD74-243E9214AF13}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials_DM", ".\essentials-framework\Essentials DM\Essentials_DM\Essentials_DM.csproj", "{9199CE8A-0C9F-4952-8672-3EED798B284F}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1BED5BA9-88C4-4365-9362-6F4B128071D3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

PepperDashEssentials/AppServer/DeviceTypeInterfaces/IChannelExtensions.cs

@@ -6,29 +6,29 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class IChannelExtensions
     {
-        public static void LinkActions(this IChannel dev, CotijaSystemController controller)
+        public static void LinkActions(this IChannel dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
-            controller.AddAction(prefix + "chanup", new PressAndHoldAction(dev.ChannelUp));
-            controller.AddAction(prefix + "chandown", new PressAndHoldAction(dev.ChannelDown));
-            controller.AddAction(prefix + "lastchan", new PressAndHoldAction(dev.LastChannel));
+            controller.AddAction(prefix + "chanUp", new PressAndHoldAction(dev.ChannelUp));
+            controller.AddAction(prefix + "chanDown", new PressAndHoldAction(dev.ChannelDown));
+            controller.AddAction(prefix + "lastChan", new PressAndHoldAction(dev.LastChannel));
             controller.AddAction(prefix + "guide", new PressAndHoldAction(dev.Guide));
             controller.AddAction(prefix + "info", new PressAndHoldAction(dev.Info));
             controller.AddAction(prefix + "exit", new PressAndHoldAction(dev.Exit));
         }
 
-        public static void UnlinkActions(this IChannel dev, CotijaSystemController controller)
+        public static void UnlinkActions(this IChannel dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
-            controller.RemoveAction(prefix + "chanup");
-            controller.RemoveAction(prefix + "chandown");
-            controller.RemoveAction(prefix + "lastchan");
+            controller.RemoveAction(prefix + "chanUp");
+            controller.RemoveAction(prefix + "chanDown");
+            controller.RemoveAction(prefix + "lastChan");
             controller.RemoveAction(prefix + "guide");
             controller.RemoveAction(prefix + "info");
             controller.RemoveAction(prefix + "exit");

PepperDashEssentials/AppServer/DeviceTypeInterfaces/IColorExtensions.cs

@@ -6,11 +6,11 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class IColorExtensions
     {
-        public static void LinkActions(this IColor dev, CotijaSystemController controller)
+        public static void LinkActions(this IColor dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
@@ -20,7 +20,7 @@ namespace PepperDash.Essentials.Room.Cotija
             controller.AddAction(prefix + "blue", new PressAndHoldAction(dev.Blue));
         }
 
-        public static void UnlinkActions(this IColor dev, CotijaSystemController controller)
+        public static void UnlinkActions(this IColor dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 

PepperDashEssentials/AppServer/DeviceTypeInterfaces/IDPadExtensions.cs

@@ -6,11 +6,11 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class IDPadExtensions
     {
-        public static void LinkActions(this IDPad dev, CotijaSystemController controller)
+        public static void LinkActions(this IDPad dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
@@ -23,7 +23,7 @@ namespace PepperDash.Essentials.Room.Cotija
             controller.AddAction(prefix + "exit", new PressAndHoldAction(dev.Exit));
         }
 
-        public static void UnlinkActions(this IDPad dev, CotijaSystemController controller)
+        public static void UnlinkActions(this IDPad dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 

PepperDashEssentials/AppServer/DeviceTypeInterfaces/IDvrExtensions.cs

@@ -6,11 +6,11 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class IDvrExtensions
     {
-        public static void LinkActions(this IDvr dev, CotijaSystemController controller)
+        public static void LinkActions(this IDvr dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
@@ -18,7 +18,7 @@ namespace PepperDash.Essentials.Room.Cotija
             controller.AddAction(prefix + "record", new PressAndHoldAction(dev.Record));
         }
 
-        public static void UnlinkActions(this IDvr dev, CotijaSystemController controller)
+        public static void UnlinkActions(this IDvr dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 

PepperDashEssentials/AppServer/DeviceTypeInterfaces/INumericExtensions.cs

@@ -6,11 +6,11 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class INumericExtensions
     {
-        public static void LinkActions(this INumericKeypad dev, CotijaSystemController controller)
+        public static void LinkActions(this INumericKeypad dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
@@ -24,12 +24,12 @@ namespace PepperDash.Essentials.Room.Cotija
             controller.AddAction(prefix + "num7", new PressAndHoldAction(dev.Digit0));
             controller.AddAction(prefix + "num8", new PressAndHoldAction(dev.Digit0));
             controller.AddAction(prefix + "num9", new PressAndHoldAction(dev.Digit0));
-            controller.AddAction(prefix + "dash", new PressAndHoldAction(dev.KeypadAccessoryButton1));
-            controller.AddAction(prefix + "enter", new PressAndHoldAction(dev.KeypadAccessoryButton2));
+            controller.AddAction(prefix + "numDash", new PressAndHoldAction(dev.KeypadAccessoryButton1));
+            controller.AddAction(prefix + "numEnter", new PressAndHoldAction(dev.KeypadAccessoryButton2));
             // Deal with the Accessory functions on the numpad later
         }
 
-        public static void UnlinkActions(this INumericKeypad dev, CotijaSystemController controller)
+        public static void UnlinkActions(this INumericKeypad dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
@@ -43,8 +43,8 @@ namespace PepperDash.Essentials.Room.Cotija
             controller.RemoveAction(prefix + "num7");
             controller.RemoveAction(prefix + "num8");
             controller.RemoveAction(prefix + "num9");
-            controller.RemoveAction(prefix + "dash");
-            controller.RemoveAction(prefix + "enter");
+            controller.RemoveAction(prefix + "numDash");
+            controller.RemoveAction(prefix + "numEnter");
         }
     }
 }

PepperDashEssentials/AppServer/DeviceTypeInterfaces/IPowerExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Room.MobileControl
+{
+    public static class IPowerExtensions
+    {
+        public static void LinkActions(this IPower dev, MobileControlSystemController controller)
+        {
+            var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
+
+            controller.AddAction(prefix + "powerOn", new Action(dev.PowerOn));
+            controller.AddAction(prefix + "powerOff", new Action(dev.PowerOff));
+            controller.AddAction(prefix + "powerToggle", new Action(dev.PowerToggle));
+        }
+
+        public static void UnlinkActions(this IPower dev, MobileControlSystemController controller)
+        {
+            var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
+
+            controller.RemoveAction(prefix + "powerOn");
+            controller.RemoveAction(prefix + "powerOff");
+            controller.RemoveAction(prefix + "powerToggle");
+  
+        }
+    }
+}

PepperDashEssentials/AppServer/DeviceTypeInterfaces/ISetTopBoxControlsExtensions.cs

@@ -6,23 +6,23 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class ISetTopBoxControlsExtensions
     {
-        public static void LinkActions(this ISetTopBoxControls dev, CotijaSystemController controller)
+        public static void LinkActions(this ISetTopBoxControls dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
-            controller.AddAction(prefix + "dvrlist", new PressAndHoldAction(dev.DvrList));
+            controller.AddAction(prefix + "dvrList", new PressAndHoldAction(dev.DvrList));
             controller.AddAction(prefix + "replay", new PressAndHoldAction(dev.Replay));
         }
 
-        public static void UnlinkActions(this ISetTopBoxControls dev, CotijaSystemController controller)
+        public static void UnlinkActions(this ISetTopBoxControls dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
-            controller.RemoveAction(prefix + "dvrlist");
+            controller.RemoveAction(prefix + "dvrList");
             controller.RemoveAction(prefix + "replay");
         }
     }

PepperDashEssentials/AppServer/DeviceTypeInterfaces/ITransportExtensions.cs

@@ -6,33 +6,33 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
     public static class ITransportExtensions
     {
-        public static void LinkActions(this ITransport dev, CotijaSystemController controller)
+        public static void LinkActions(this ITransport dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
             controller.AddAction(prefix + "play", new PressAndHoldAction(dev.Play));
             controller.AddAction(prefix + "pause", new PressAndHoldAction(dev.Pause));
             controller.AddAction(prefix + "stop", new PressAndHoldAction(dev.Stop));
-            controller.AddAction(prefix + "prevtrack", new PressAndHoldAction(dev.ChapPlus));
-            controller.AddAction(prefix + "nexttrack", new PressAndHoldAction(dev.ChapMinus));
+            controller.AddAction(prefix + "prevTrack", new PressAndHoldAction(dev.ChapPlus));
+            controller.AddAction(prefix + "nextTrack", new PressAndHoldAction(dev.ChapMinus));
             controller.AddAction(prefix + "rewind", new PressAndHoldAction(dev.Rewind));
             controller.AddAction(prefix + "ffwd", new PressAndHoldAction(dev.FFwd));
             controller.AddAction(prefix + "record", new PressAndHoldAction(dev.Record));
         }
 
-        public static void UnlinkActions(this ITransport dev, CotijaSystemController controller)
+        public static void UnlinkActions(this ITransport dev, MobileControlSystemController controller)
         {
             var prefix = string.Format(@"/device/{0}/", (dev as IKeyed).Key);
 
             controller.RemoveAction(prefix + "play");
             controller.RemoveAction(prefix + "pause");
             controller.RemoveAction(prefix + "stop");
-            controller.RemoveAction(prefix + "prevtrack");
-            controller.RemoveAction(prefix + "nexttrack");
+            controller.RemoveAction(prefix + "prevTrack");
+            controller.RemoveAction(prefix + "nextTrack");
             controller.RemoveAction(prefix + "rewind");
             controller.RemoveAction(prefix + "ffwd");
             controller.RemoveAction(prefix + "record");

PepperDashEssentials/AppServer/Interfaces.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Room.MobileControl
+{
+	/// <summary>
+	/// Represents a room whose configuration is derived from runtime data,
+	/// perhaps from another program, and that the data may not be fully
+	/// available at startup.
+	/// </summary>
+	public interface IDelayedConfiguration
+	{
+		event EventHandler<EventArgs> ConfigurationIsReady;
+	}
+}
+

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(MobileControlSystemController 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/ConfigMessenger.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+
+    /// <summary>
+    /// Handles interactions with the app server to update the config
+    /// </summary>
+    public class ConfigMessenger : MessengerBase
+    {
+        public ConfigMessenger(string key, string messagePath)
+            : base(key, messagePath)
+        {
+            ConfigUpdater.ConfigStatusChanged -= ConfigUpdater_ConfigStatusChanged;
+            ConfigUpdater.ConfigStatusChanged += new EventHandler<ConfigStatusEventArgs>(ConfigUpdater_ConfigStatusChanged);
+        }
+
+        void ConfigUpdater_ConfigStatusChanged(object sender, ConfigStatusEventArgs e)
+        {
+            PostUpdateStatus(e.UpdateStatus.ToString());
+        }
+
+        protected override void CustomRegisterWithAppServer(MobileControlSystemController appServerController)
+        {
+            appServerController.AddAction(MessagePath + "/updateConfig", new Action<string>(s => GetConfigFile(s)));
+        }
+
+        /// <summary>
+        /// Generates or passes the URL to make the request to GET the config from a server
+        /// </summary>
+        /// <param name="url"></param>
+        void GetConfigFile(string url)
+        {
+            try
+            {
+                // Attempt to parse the URL
+                var parser = new Crestron.SimplSharp.Net.Http.UrlParser(url);
+
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Successfully parsed URL from AppServer message: {0}", parser.Url);
+            }
+            catch (Exception e)
+            {
+                // If unable to parse the URL, generate it from config data
+                Debug.Console(2, "Error parsing URL: {0}", e);
+
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Unable to parse URL from AppServer message.  Generating URL from config data");
+                url = string.Format("http://{0}/api/system/{1}/config", AppServerController.Config.ServerUrl, AppServerController.SystemUuid);
+            }
+
+            ConfigUpdater.GetConfigFromServer(url);
+        }
+
+        /// <summary>
+        /// Posts a message with the current status of the config update
+        /// </summary>
+        /// <param name="status"></param>
+        void PostUpdateStatus(string status)
+        {
+            PostStatusMessage(new
+            {
+                updateStatus = status
+            });
+        }
+
+    }
+
+
+}

PepperDashEssentials/AppServer/Messengers/Ddvc01AtcMessenger.cs

@@ -0,0 +1,216 @@
+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 Ddvc01AtcMessenger : MessengerBase
+	{
+		BasicTriList EISC;
+
+		/// <summary>
+		/// 221
+		/// </summary>
+		const uint BDialHangupOnHook = 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>
+		/// 201
+		/// </summary>
+		const uint SCurrentDialString = 201;
+		/// <summary>
+		/// 211
+		/// </summary>
+		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>
+		{
+			{ "1", 201 },
+			{ "2", 202 },
+			{ "3", 203 },
+			{ "4", 204 },
+			{ "5", 205 },
+			{ "6", 206 },
+			{ "7", 207 },
+			{ "8", 208 },
+			{ "9", 209 },
+			{ "0", 210 },
+			{ "*", 211 },
+			{ "#", 212 },
+		};
+
+		/// <summary>
+		/// 
+		/// </summary>
+		CodecActiveCallItem CurrentCallItem;
+
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="eisc"></param>
+		/// <param name="messagePath"></param>
+		public Ddvc01AtcMessenger(string key, BasicTriList eisc, string messagePath)
+			: base(key, messagePath)
+		{
+			EISC = eisc;
+
+			CurrentCallItem = new CodecActiveCallItem();
+			CurrentCallItem.Type = eCodecCallType.Audio;
+			CurrentCallItem.Id = "-audio-";
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void SendFullStatus()
+		{
+            
+
+			this.PostStatusMessage(new
+			{				
+				calls = GetCurrentCallList(),
+				currentCallString = EISC.GetString(SCurrentCallNumber),
+				currentDialString = EISC.GetString(SCurrentDialString),
+                isInCall = EISC.GetString(SHookState) == "Connected"
+			});
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="appServerController"></param>
+		protected override void CustomRegisterWithAppServer(MobileControlSystemController appServerController)
+		{
+            //EISC.SetStringSigAction(SCurrentDialString, s => PostStatusMessage(new { currentDialString = s }));
+
+			EISC.SetStringSigAction(SHookState, s => 
+			{
+				CurrentCallItem.Status = (eCodecCallStatus)Enum.Parse(typeof(eCodecCallStatus), s, true);
+                //GetCurrentCallList();
+				SendFullStatus();
+			});
+
+			EISC.SetStringSigAction(SCurrentCallNumber, s => 
+			{
+				CurrentCallItem.Number = s;
+                SendCallsList();
+			});
+
+            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)));
+
+			// Add straight pulse calls
+			Action<string, uint> addAction = (s, u) =>
+				AppServerController.AddAction(MessagePath + s, new Action(() => EISC.PulseBool(u, 100)));
+            addAction("/endCallById", BDialHangupOnHook);
+			addAction("/endAllCalls", BDialHangupOnHook);
+            addAction("/acceptById", BIncomingAnswer);
+            addAction("/rejectById", BIncomingReject);
+			addAction("/speedDial1", BSpeedDial1);
+			addAction("/speedDial2", BSpeedDial2);
+			addAction("/speedDial3", BSpeedDial3);
+			addAction("/speedDial4", BSpeedDial4);
+
+			// Get status
+			AppServerController.AddAction(MessagePath + "/fullStatus", new Action(SendFullStatus));
+			// Dial on string
+			AppServerController.AddAction(MessagePath + "/dial", new Action<string>(s => EISC.SetString(SCurrentDialString, s)));
+			// Pulse DTMF
+			AppServerController.AddAction(MessagePath + "/dtmf", new Action<string>(s =>
+			{
+				if (DTMFMap.ContainsKey(s))
+				{
+					EISC.PulseBool(DTMFMap[s], 100);
+				}
+			}));
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+        void SendCallsList()
+        {
+            PostStatusMessage(new
+            {
+                calls = GetCurrentCallList(),
+            });
+        }
+
+		/// <summary>
+		/// Turns the 
+		/// </summary>
+		/// <returns></returns>
+		List<CodecActiveCallItem> GetCurrentCallList()
+		{
+			if (CurrentCallItem.Status == eCodecCallStatus.Disconnected)
+			{
+				return new List<CodecActiveCallItem>();
+			}
+			else
+			{
+				return new List<CodecActiveCallItem>() { CurrentCallItem };
+			}
+		}
+	}
+}

PepperDashEssentials/AppServer/Messengers/Ddvc01VtcMessenger.cs

@@ -0,0 +1,648 @@
+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;
+
+		/// <summary>
+		/// 841
+		/// </summary>
+		const uint BCameraSelfView = 841;
+
+		/// <summary>
+		/// 842
+		/// </summary>
+		const uint BCameraLayout = 842;
+		/// <summary>
+		/// 843
+		/// </summary>
+		const uint BCameraSupportsAutoMode = 843;
+		/// <summary>
+		/// 844
+		/// </summary>
+		const uint BCameraSupportsOffMode = 844;
+
+
+		/********* 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(MobileControlSystemController 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();
+			});
+
+			EISC.SetBoolSigAction(BCameraSupportsAutoMode, b =>
+			{
+				PostStatusMessage(new
+				{	
+					cameraSupportsAutoMode = b
+				});
+			});
+			EISC.SetBoolSigAction(BCameraSupportsOffMode, b =>
+			{
+				PostStatusMessage(new
+				{
+					cameraSupportsOffMode = b
+				});
+			});
+
+			// 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.SetBoolSigAction(BCameraSelfView, b => PostStatusMessage(new 
+				{
+					cameraSelfView = b
+				}));
+
+			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("/endAllCalls", 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);
+			addAction("/cameraSelfView", BCameraSelfView);
+			addAction("/cameraLayout", BCameraLayout);
+
+			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(),
+				cameraSelfView = EISC.GetBool(BCameraSelfView),
+				cameraSupportsAutoMode = EISC.GetBool(BCameraSupportsAutoMode),
+				cameraSupportsOffMode = EISC.GetBool(BCameraSupportsOffMode),
+				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 = !EISC.BooleanOutput[502].BoolValue,
+				hasCameras = true,
+				showCamerasWhenNotInCall = EISC.BooleanOutput[503].BoolValue,
+				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

@@ -0,0 +1,81 @@
+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.Devices.Common.Codec;
+using PepperDash.Essentials.Devices.Common.VideoCodec;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+	/// <summary>
+	/// Provides a messaging bridge for a VideoCodecBase
+	/// </summary>
+	public abstract class MessengerBase : IKeyed
+	{
+        public string Key { get; private set; }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		public MobileControlSystemController AppServerController { get; private set; }
+
+		public string MessagePath { get; private set; }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="codec"></param>
+		public MessengerBase(string key, string messagePath)
+		{
+            Key = key;
+
+			if (string.IsNullOrEmpty(messagePath))
+				throw new ArgumentException("messagePath must not be empty or null");
+
+			MessagePath = messagePath;
+		}
+		
+
+		/// <summary>
+		/// Registers this messenger with appserver controller
+		/// </summary>
+		/// <param name="appServerController"></param>
+		public void RegisterWithAppServer(MobileControlSystemController appServerController)
+		{
+			if (appServerController == null)
+				throw new ArgumentNullException("appServerController");
+			
+			AppServerController = appServerController;
+			CustomRegisterWithAppServer(AppServerController);
+		}
+
+		/// <summary>
+		/// Implemented in extending classes. Wire up API calls and feedback here
+		/// </summary>
+		/// <param name="appServerController"></param>
+		abstract protected void CustomRegisterWithAppServer(MobileControlSystemController appServerController);
+
+		/// <summary>
+		/// Helper for posting status message
+		/// </summary>
+		/// <param name="contentObject">The contents of the content object</param>
+		protected void PostStatusMessage(object contentObject)
+		{
+            if (AppServerController != null)
+            {
+                AppServerController.SendMessageToServer(JObject.FromObject(new
+                {
+                    type = MessagePath,
+                    content = contentObject
+                }));
+            }
+		}
+	}
+}

PepperDashEssentials/AppServer/Messengers/SystemMonitorMessenger.cs

@@ -0,0 +1,95 @@
+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)
+        {
+            if (e.ProgramInfo != null)
+            {
+                //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(MobileControlSystemController appServerController)
+        {
+            AppServerController.AddAction(MessagePath + "/fullStatus", new Action(SendFullStatusMessage));
+        }
+
+    }
+}

PepperDashEssentials/AppServer/Messengers/VideoCodecBaseMessenger.cs

@@ -0,0 +1,373 @@
+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.Cameras;
+using PepperDash.Essentials.Devices.Common.VideoCodec;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+	/// <summary>
+	/// Provides a messaging bridge for a VideoCodecBase device
+	/// </summary>
+	public class VideoCodecBaseMessenger : MessengerBase
+	{
+		/// <summary>
+		/// 
+		/// </summary>
+		public VideoCodecBase Codec { get; private set; }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="codec"></param>
+		public VideoCodecBaseMessenger(string key, VideoCodecBase codec, string messagePath)
+            : base(key, messagePath)
+		{
+			if (codec == null)
+				throw new ArgumentNullException("codec");
+
+			Codec = codec;
+			codec.CallStatusChange += new EventHandler<CodecCallStatusItemChangeEventArgs>(codec_CallStatusChange);
+			codec.IsReadyChange += new EventHandler<EventArgs>(codec_IsReadyChange);
+
+			var dirCodec = codec as IHasDirectory;
+			if (dirCodec != null)
+			{
+				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>
+		/// 
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
+		void dirCodec_DirectoryResultReturned(object sender, DirectoryEventArgs e)
+		{
+            SendDirectory((Codec as IHasDirectory).CurrentDirectoryResult, e.DirectoryIsOnRoot);
+		}
+
+        /// <summary>
+        /// Posts the current directory
+        /// </summary>
+        void SendDirectory(CodecDirectory directory, bool isRoot)
+        {
+            var dirCodec = Codec as IHasDirectory;
+
+            if (dirCodec != null)
+            {
+                var prefixedDirectoryResults = PrefixDirectoryFolderItems(directory);
+
+                var directoryMessage = new
+                {
+                    currentDirectory = new
+                    {
+                        directoryResults = prefixedDirectoryResults,
+                        isRootDirectory = isRoot
+                    }
+                };
+                PostStatusMessage(directoryMessage);
+            }
+        }
+
+        /// <summary>
+        /// Iterates a directory object and prefixes any folder items with "[+] "
+        /// </summary>
+        /// <param name="directory"></param>
+        /// <returns></returns>
+         List<DirectoryItem> PrefixDirectoryFolderItems (CodecDirectory directory)
+        {
+            var tempDirectoryList = new List<DirectoryItem>();
+
+            if (directory.CurrentDirectoryResults.Count > 0)
+            {
+                foreach (var item in directory.CurrentDirectoryResults)
+                {
+                    if (item is DirectoryFolder)
+                    {
+                        var newFolder = new DirectoryFolder();
+
+                        newFolder = (DirectoryFolder)item.Clone();
+
+                        string prefixName = "[+] " + newFolder.Name;
+
+                        newFolder.Name = prefixName;
+
+                        tempDirectoryList.Add(newFolder);
+                    }
+                    else
+                    {
+                        tempDirectoryList.Add(item);
+                    }
+                }
+            }
+            //else
+            //{
+            //    DirectoryItem noResults = new DirectoryItem() { Name = "No Results Found" };
+
+            //    tempDirectoryList.Add(noResults);
+            //}
+
+            return tempDirectoryList;
+        }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
+		void codec_IsReadyChange(object sender, EventArgs e)
+		{
+			PostStatusMessage(new
+			{
+				isReady = true
+			});
+		}
+
+		/// <summary>
+		/// Called from base's RegisterWithAppServer method
+		/// </summary>
+		/// <param name="appServerController"></param>
+		protected override void CustomRegisterWithAppServer(MobileControlSystemController appServerController)
+		{
+			appServerController.AddAction("/device/videoCodec/isReady", new Action(SendIsReady));
+			appServerController.AddAction("/device/videoCodec/fullStatus", new Action(SendVtcFullMessageObject));
+			appServerController.AddAction("/device/videoCodec/dial", new Action<string>(s => Codec.Dial(s)));
+			appServerController.AddAction("/device/videoCodec/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);
+			}));
+
+            // Directory actions
+            var dirCodec = Codec as IHasDirectory;
+            if (dirCodec != null)
+            {
+                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 + "/directoryBack", new Action(GetPreviousDirectory));
+            }
+
+            // History actions
+            var recCodec = Codec as IHasCallHistory;
+            if (recCodec != null)
+            {
+                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));
+			appServerController.AddAction(MessagePath + "/sharingStart", new Action(Codec.StartSharing));
+			appServerController.AddAction(MessagePath + "/sharingStop", new Action(Codec.StopSharing));
+			appServerController.AddAction(MessagePath + "/standbyOn", new Action(Codec.StandbyActivate));
+			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()
+		{
+
+		}
+
+		/// <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);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="s"></param>
+		void DirectorySearch(string s)
+		{
+			var dirCodec = Codec as IHasDirectory;
+			if (dirCodec != null)
+			{
+				dirCodec.SearchDirectory(s);
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="id"></param>
+		void GetDirectory(string id)
+		{
+			var dirCodec = Codec as IHasDirectory;
+			if(dirCodec == null)
+			{
+				return;
+			}
+			dirCodec.GetDirectoryFolderContents(id);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void GetDirectoryRoot()
+		{
+			var dirCodec = Codec as IHasDirectory;
+			if (dirCodec == null)
+			{
+				// do something else?
+				return;
+			}
+			if (!dirCodec.PhonebookSyncState.InitialSyncComplete)
+			{
+				PostStatusMessage(new
+				{
+					initialSyncComplete = false
+				});
+				return;
+			}
+
+            dirCodec.SetCurrentDirectoryToRoot();
+
+            //PostStatusMessage(new
+            //{
+            //    currentDirectory = dirCodec.DirectoryRoot
+            //});
+		}
+
+        /// <summary>
+        /// Requests the parent folder contents
+        /// </summary>
+        void GetPreviousDirectory()
+        {
+            var dirCodec = Codec as IHasDirectory;
+            if (dirCodec == null)
+            {
+                return;
+            }
+
+            dirCodec.GetDirectoryParentFolderContents();
+        }
+
+		/// <summary>
+		/// Handler for codec changes
+		/// </summary>
+		void codec_CallStatusChange(object sender, CodecCallStatusItemChangeEventArgs e)
+		{
+			SendVtcFullMessageObject();
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void SendIsReady()
+		{
+			PostStatusMessage(new
+			{
+				isReady = Codec.IsReady
+			});
+		}
+
+		/// <summary>
+		/// Helper method to build call status for vtc
+		/// </summary>
+		/// <returns></returns>
+		void SendVtcFullMessageObject()
+		{
+			if (!Codec.IsReady)
+			{
+				return;
+			}
+
+			var info = Codec.CodecInfo;
+			PostStatusMessage(new
+			{
+				isInCall = Codec.IsInCall,
+				privacyModeIsOn = Codec.PrivacyModeIsOnFeedback.BoolValue,
+				sharingContentIsOn = Codec.SharingContentIsOnFeedback.BoolValue,
+				sharingSource = Codec.SharingSourceFeedback.StringValue,
+				standbyIsOn = Codec.StandbyIsOnFeedback.StringValue,
+				calls = Codec.ActiveCalls,
+				info = new
+				{
+					autoAnswerEnabled = info.AutoAnswerEnabled,
+					e164Alias = info.E164Alias,
+					h323Id = info.H323Id,
+					ipAddress = info.IpAddress,
+					sipPhoneNumber = info.SipPhoneNumber,
+					sipURI = info.SipUri
+				},
+				showSelfViewByDefault = Codec.ShowSelfViewByDefault,
+				hasDirectory = Codec is IHasDirectory,
+                hasDirectorySearch = true,
+                hasRecents = Codec is IHasCallHistory,
+                hasCameras = Codec is IHasCodecCameras
+			});
+		}
+	}
+}

PepperDashEssentials/AppServer/MobileControlConfig.cs

@@ -13,7 +13,7 @@ namespace PepperDash.Essentials
 	/// <summary>
 	/// 
 	/// </summary>
-    public class CotijaConfig
+    public class MobileControlConfig
     {       
 		[JsonProperty("serverUrl")]
         public string ServerUrl { get; set; }
@@ -25,7 +25,7 @@ namespace PepperDash.Essentials
 	/// <summary>
 	/// 
 	/// </summary>
-	public class CotijaDdvc01RoomBridgePropertiesConfig
+	public class MobileControlDdvc01RoomBridgePropertiesConfig
 	{
 		[JsonProperty("eiscId")]
 		public string EiscId { get; set; }

PepperDashEssentials/AppServer/MobileControlDdvc01DeviceBridge.cs

@@ -8,19 +8,19 @@ using Crestron.SimplSharpPro.EthernetCommunication;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 
-namespace PepperDash.Essentials.Room.Cotija
+namespace PepperDash.Essentials.Room.MobileControl
 {
 	/// <summary>
 	/// Represents a generic device connection through to and EISC for DDVC01
 	/// </summary>
-	public class CotijaDdvc01DeviceBridge : Device, IChannel, INumericKeypad 
+	public class MobileControlDdvc01DeviceBridge : Device, IChannel, INumericKeypad 
 	{
 		/// <summary>
 		/// EISC used to talk to Simpl
 		/// </summary>
 		ThreeSeriesTcpIpEthernetIntersystemCommunications EISC;
 
-		public CotijaDdvc01DeviceBridge(string key, string name, ThreeSeriesTcpIpEthernetIntersystemCommunications eisc)
+		public MobileControlDdvc01DeviceBridge(string key, string name, ThreeSeriesTcpIpEthernetIntersystemCommunications eisc)
 			: base(key, name)
 		{
 			EISC = eisc;

PepperDashEssentials/AppServer/MobileControlSystemController.cs

@@ -15,14 +15,18 @@ using Newtonsoft.Json.Linq;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Room.Cotija;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Room.MobileControl;
+using PepperDash.Essentials.AppServer.Messengers;
 
 namespace PepperDash.Essentials
 {
-    public class CotijaSystemController : Device
+    public class MobileControlSystemController : Device
     {
 		WebSocketClient WSClient;
 
+		//bool LinkUp;
+
 		/// <summary>
 		/// Prevents post operations from stomping on each other and getting lost
 		/// </summary>
@@ -30,12 +34,14 @@ namespace PepperDash.Essentials
 
 		CEvent RegisterLockEvent = new CEvent(true, true);
 
-		public CotijaConfig Config { get; private set; }
+		public MobileControlConfig Config { get; private set; }
 
         Dictionary<string, Object> ActionDictionary = new Dictionary<string, Object>(StringComparer.InvariantCultureIgnoreCase);
 
         Dictionary<string, CTimer> PushedActions = new Dictionary<string, CTimer>();
 
+        public ConfigMessenger ConfigMessenger { get; private set; }
+
         CTimer ServerHeartbeatCheckTimer;
 
         long ServerHeartbeatInterval = 20000;
@@ -44,9 +50,11 @@ namespace PepperDash.Essentials
 
         long ServerReconnectInterval = 5000;
 
-        string SystemUuid;
+        DateTime LastAckMessage;
 
-		List<CotijaBridgeBase> RoomBridges = new List<CotijaBridgeBase>();
+        public string SystemUuid;
+
+		List<MobileControlBridgeBase> RoomBridges = new List<MobileControlBridgeBase>();
 
         long ButtonHeartbeatInterval = 1000;
 
@@ -61,13 +69,16 @@ namespace PepperDash.Essentials
 		/// <param name="key"></param>
 		/// <param name="name"></param>
 		/// <param name="config"></param>
-        public CotijaSystemController(string key, string name, CotijaConfig config) : base(key, name)
+        public MobileControlSystemController(string key, string name, MobileControlConfig config) : base(key, name)
         {
             Config = config;
+
+            SystemUuid = ConfigReader.ConfigObject.SystemUuid;
+
 			Debug.Console(0, this, "Mobile UI controller initializing for server:{0}", config.ServerUrl);
 
 			CrestronConsole.AddNewConsoleCommand(AuthorizeSystem,
-				"mobileauth", "Authorizes system to talk to cotija server", ConsoleAccessLevelEnum.AccessOperator);
+				"mobileauth", "Authorizes system to talk to Mobile Control server", ConsoleAccessLevelEnum.AccessOperator);
 			CrestronConsole.AddNewConsoleCommand(s => ShowInfo(),
 				"mobileinfo", "Shows information for current mobile control session", ConsoleAccessLevelEnum.AccessOperator);
 			CrestronConsole.AddNewConsoleCommand(s => { 
@@ -82,6 +93,76 @@ namespace PepperDash.Essentials
 			CrestronConsole.AddNewConsoleCommand(TestHttpRequest,
 			"mobilehttprequest", "Tests an HTTP get to URL given", ConsoleAccessLevelEnum.AccessOperator);
 
+            CrestronConsole.AddNewConsoleCommand(PrintActionDictionaryPaths, "mobileshowactionpaths", 
+				"Prints the paths in the Action Dictionary", ConsoleAccessLevelEnum.AccessOperator);
+			CrestronConsole.AddNewConsoleCommand(s => ConnectWebsocketClient(), "mobileconnect", 
+				"Forces connect of websocket", ConsoleAccessLevelEnum.AccessOperator);
+			CrestronConsole.AddNewConsoleCommand(s => CleanUpWebsocketClient(), "mobiledisco",
+				"Disconnects websocket", ConsoleAccessLevelEnum.AccessOperator);
+
+            CrestronConsole.AddNewConsoleCommand(s => ParseStreamRx(s), "mobilesimulateaction", "Simulates a message from the server", ConsoleAccessLevelEnum.AccessOperator);
+
+            CrestronEnvironment.ProgramStatusEventHandler += new ProgramStatusEventHandler(CrestronEnvironment_ProgramStatusEventHandler);
+			CrestronEnvironment.EthernetEventHandler += new EthernetEventHandler(CrestronEnvironment_EthernetEventHandler);
+
+            // Config Messenger
+            var cmKey = Key + "-config";
+            ConfigMessenger = new ConfigMessenger(cmKey, "/config");
+            ConfigMessenger.RegisterWithAppServer(this);			
+        }
+
+        /// <summary>
+        /// If config rooms is empty or null then go
+        /// </summary>
+        /// <returns></returns>
+        public override bool CustomActivate()
+        {
+            if (ConfigReader.ConfigObject.Rooms == null || ConfigReader.ConfigObject.Rooms.Count == 0)
+            {
+                Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Config contains no rooms.  Registering with Server.");
+                RegisterSystemToServer();
+            }
+
+            return base.CustomActivate();
+        }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="ethernetEventArgs"></param>
+		void CrestronEnvironment_EthernetEventHandler(EthernetEventArgs args)
+		{
+			Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Ethernet status change, port {0}: {1}",
+				args.EthernetAdapter, args.EthernetEventType);
+
+			if (args.EthernetEventType == eEthernetEventType.LinkDown && WSClient != null && args.EthernetAdapter == WSClient.EthernetAdapter)
+			{
+				CleanUpWebsocketClient();
+			}
+		}
+
+        /// <summary>
+        /// Sends message to server to indicate the system is shutting down
+        /// </summary>
+        /// <param name="programEventType"></param>
+        void CrestronEnvironment_ProgramStatusEventHandler(eProgramStatusEventType programEventType)
+        {
+            if (programEventType == eProgramStatusEventType.Stopping 
+				&& WSClient != null
+				&& WSClient.Connected)
+            {
+				CleanUpWebsocketClient();
+            }
+        }
+
+        public void PrintActionDictionaryPaths(object o)
+        {
+            Debug.Console(0, this, "ActionDictionary Contents:");
+
+            foreach (var item in ActionDictionary)
+            {
+                Debug.Console(0, this, "{0}", item.Key);
+            }
         }
 
         /// <summary>
@@ -115,7 +196,7 @@ namespace PepperDash.Essentials
 		/// 
 		/// </summary>
 		/// <param name="bridge"></param>
-		public void AddBridge(CotijaBridgeBase bridge)
+		public void AddBridge(MobileControlBridgeBase bridge)
 		{
 			RoomBridges.Add(bridge);
 			var b = bridge as IDelayedConfiguration;
@@ -127,6 +208,7 @@ namespace PepperDash.Essentials
 			else
 			{
 				Debug.Console(0, this, "Adding room bridge and sending configuration");
+                //SystemUuid = ConfigReader.ConfigObject.SystemUuid;
 				RegisterSystemToServer();
 			}
 		}
@@ -139,6 +221,7 @@ namespace PepperDash.Essentials
 		void bridge_ConfigurationIsReady(object sender, EventArgs e)
 		{
 			Debug.Console(1, this, "Bridge ready.  Registering");
+            //SystemUuid = ConfigReader.ConfigObject.SystemUuid;
 			// send the configuration object to the server
 			RegisterSystemToServer();
 		}
@@ -158,6 +241,14 @@ namespace PepperDash.Essentials
 		/// <param name="command"></param>
 		void AuthorizeSystem(string code)
 		{
+            //SystemUuid = ConfigReader.ConfigObject.SystemUuid;
+
+			if (string.IsNullOrEmpty(SystemUuid))
+			{
+				CrestronConsole.ConsoleCommandResponse("System does not have a UUID. Please ensure proper portal-format configuration is loaded and restart.");
+				return;
+			}
+
 			if (string.IsNullOrEmpty(code))
 			{
 				CrestronConsole.ConsoleCommandResponse("Please enter a user code to authorize a system");
@@ -184,6 +275,7 @@ namespace PepperDash.Essentials
 						if (r.Code == 200)
 						{
 							Debug.Console(0, "System authorized, sending config.");
+#warning This registration may need to wait for config ready. Maybe.
 							RegisterSystemToServer();
 						}
 						else if (r.Code == 404)
@@ -228,14 +320,19 @@ namespace PepperDash.Essentials
 				code = "Not available";
 			}
 			var conn = WSClient == null ? "No client" : (WSClient.Connected ? "Yes" : "No");
+            var secSinceLastAck = DateTime.Now - LastAckMessage;
+
 
 			CrestronConsole.ConsoleCommandResponse(@"Mobile Control Information:
 	Server address: {0}
 	System Name: {1}
-	System UUID: {2}
-	System User code: {3}
-	Connected?: {4}", url, name, SystemUuid, 
-					code, conn);
+    System URL: {2}
+	System UUID: {3}
+	System User code: {4}
+	Connected?: {5}
+    Seconds Since Last Ack: {6}"
+                , url, name, ConfigReader.ConfigObject.SystemUrl, SystemUuid,
+                    code, conn, secSinceLastAck.Seconds);
 		}
 
         /// <summary>
@@ -244,57 +341,103 @@ namespace PepperDash.Essentials
         /// <param name="url">URL of the server, including the port number, if not 80.  Format: "serverUrlOrIp:port"</param>
         void RegisterSystemToServer()
         {
-			var ready = RegisterLockEvent.Wait(20000);
-			if (!ready)
-			{
-				Debug.Console(1, this, "RegisterSystemToServer failed to enter after 20 seconds.  Ignoring");
-				return;
-			}
-			RegisterLockEvent.Reset();
-
-			try
-            {
-				var confObject = ConfigReader.ConfigObject;
-                confObject.Info.RuntimeInfo.AppName = Assembly.GetExecutingAssembly().GetName().Name;
-                var version = Assembly.GetExecutingAssembly().GetName().Version;
-                confObject.Info.RuntimeInfo.AssemblyVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
-                confObject.Info.RuntimeInfo.OsVersion = Crestron.SimplSharp.CrestronEnvironment.OSVersion.Firmware;
-
-				string postBody = JsonConvert.SerializeObject(confObject);
-				SystemUuid = confObject.SystemUuid;
-
-                if (string.IsNullOrEmpty(postBody))
-                {
-                    Debug.Console(1, this, "ERROR: Config body is empty. Cannot register with server.");
-                }
-                else
-                {
-					var regClient = new HttpClient();
-					regClient.Verbose = true;
-					regClient.KeepAlive = true;
-
-					string url = string.Format("http://{0}/api/system/join/{1}", Config.ServerUrl, SystemUuid);
-					Debug.Console(1, this, "Joining server at {0}", url);
-
-                    HttpClientRequest request = new HttpClientRequest();
-                    request.Url.Parse(url);
-                    request.RequestType = RequestType.Post;
-                    request.Header.SetHeaderValue("Content-Type", "application/json");
-                    request.ContentString = postBody;
-
-					var err = regClient.DispatchAsync(request, RegistrationConnectionCallback);
-                }
-
-            }
-            catch (Exception e)
-            {
-                Debug.Console(0, this, "ERROR: Initilizing Room: {0}", e);
-				RegisterLockEvent.Set();
-				StartReconnectTimer();
-            }
-
+			ConnectWebsocketClient();
         }
 
+		/// <summary>
+		/// Connects the Websocket Client
+		/// </summary>
+		/// <param name="o"></param>
+		void ConnectWebsocketClient()
+		{
+
+			Debug.Console(1, this, "Initializing Stream client to server.");
+
+			if (WSClient != null)
+			{
+				Debug.Console(1, this, "Cleaning up previous socket");
+				CleanUpWebsocketClient();
+			}
+
+			WSClient = new WebSocketClient();
+			WSClient.URL = string.Format("wss://{0}/system/join/{1}", Config.ServerUrl, this.SystemUuid);
+			WSClient.ConnectionCallBack = Websocket_ConnectCallback;
+			WSClient.ConnectAsync();
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="code"></param>
+		/// <returns></returns>
+		int Websocket_ConnectCallback(WebSocketClient.WEBSOCKET_RESULT_CODES code)
+		{
+			if (code == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
+			{
+				StopServerReconnectTimer();
+				Debug.Console(1, this, "Websocket connected");
+				WSClient.DisconnectCallBack = Websocket_DisconnectCallback;
+				WSClient.SendCallBack = Websocket_SendCallback;
+				WSClient.ReceiveCallBack = Websocket_ReceiveCallback;
+				WSClient.ReceiveAsync();
+				SendMessageObjectToServer(new
+				{
+					type = "hello"
+				});
+			}
+			else
+			{
+				if (code == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_HTTP_HANDSHAKE_TOKEN_ERROR)
+				{
+					// This is the case when app server is running behind a websever and app server is down
+					Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Web socket connection failed. Check that app server is running behind web server");
+				}
+				else if (code == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SOCKET_CONNECTION_FAILED)
+				{
+					// this will be the case when webserver is unreachable
+					Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Web socket connection failed");
+				}
+				else
+				{
+					Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Web socket connection failure: {0}", code);
+				} 
+				StartServerReconnectTimer();
+			}
+
+			return 0;
+		}
+
+		/// <summary>
+		/// After a "hello" from the server, sends config and stuff
+		/// </summary>
+		void SendInitialMessage()
+		{
+			Debug.Console(1, this, "Sending initial join message");
+			var confObject = ConfigReader.ConfigObject;
+			confObject.Info.RuntimeInfo.AppName = Assembly.GetExecutingAssembly().GetName().Name;
+			var version = Assembly.GetExecutingAssembly().GetName().Version;
+			confObject.Info.RuntimeInfo.AssemblyVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
+
+			var msg = new
+			{
+				type = "join",
+				content = new
+				{
+					config = confObject
+				}
+			};
+			SendMessageObjectToServer(msg);
+		}
+
+		/// <summary>
+		/// Sends any object type to server
+		/// </summary>
+		/// <param name="o"></param>
+		public void SendMessageObjectToServer(object o)
+		{
+			SendMessageToServer(JObject.FromObject(o));
+		}
+
         /// <summary>
         /// Sends a message to the server from a room
         /// </summary>
@@ -302,78 +445,72 @@ namespace PepperDash.Essentials
         /// <param name="o">object to be serialized and sent in post body</param>
         public void SendMessageToServer(JObject o)
         {
-
             if (WSClient != null && WSClient.Connected)
             {
                 string message = JsonConvert.SerializeObject(o, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
-				Debug.Console(1, this, "Message TX: {0}", message);
+
+                if (!message.Contains("/system/heartbeat"))
+                    Debug.Console(1, this, "Message TX: {0}", message);
+                //else
+                //    Debug.Console(1, this, "TX messages contains /system/heartbeat");
+
                 var messageBytes = System.Text.Encoding.UTF8.GetBytes(message);
-				WSClient.Send(messageBytes, (uint)messageBytes.Length, WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__TEXT_FRAME);
-				//WSClient.SendAsync(messageBytes, (uint)messageBytes.Length, WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__TEXT_FRAME);
+				var result = WSClient.Send(messageBytes, (uint)messageBytes.Length, WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__TEXT_FRAME);
+				if (result != WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
+				{
+					Debug.Console(1, this, "Socket send result error: {0}", result);
+				}
             }
- 
+			else if (WSClient == null)
+			{
+				Debug.Console(1, this, "Cannot send. Not connected.");
+			}
         }
 
         /// <summary>
         /// Disconnects the SSE Client and stops the heartbeat timer
         /// </summary>
         /// <param name="command"></param>
-        void DisconnectStreamClient(string command)
+        void CleanUpWebsocketClient()
         {
-			//if(SseClient != null)
-			//    SseClient.Disconnect();
-
-			if (WSClient != null && WSClient.Connected)
-				WSClient.Disconnect();
-
-            if (ServerHeartbeatCheckTimer != null)
-            {
-                ServerHeartbeatCheckTimer.Stop();
-
-                ServerHeartbeatCheckTimer = null;
-            }
+			Debug.Console(1, this, "Disconnecting websocket");
+			if (WSClient != null)
+			{
+				WSClient.SendCallBack = null;
+				WSClient.ReceiveCallBack = null;
+				WSClient.ConnectionCallBack = null;
+				WSClient.DisconnectCallBack = null;
+				if (WSClient.Connected)
+				{
+					WSClient.Disconnect();
+				}
+				WSClient = null;
+			}
         }
-        
-        /// <summary>
-        /// The callback that fires when we get a response from our registration attempt
-        /// </summary>
-        /// <param name="resp"></param>
-        /// <param name="err"></param>
-        void RegistrationConnectionCallback(HttpClientResponse resp, HTTP_CALLBACK_ERROR err)
-        {
-			CheckHttpDebug(resp, err);
-			Debug.Console(1, this, "RegistrationConnectionCallback: {0}", err);
-            try
-            {
-                if (resp != null && resp.Code == 200)
-                {
-                    if(ServerReconnectTimer != null)
-                    {
-                        ServerReconnectTimer.Stop();
-                        ServerReconnectTimer = null;
-                    }
 
-					// Success here!
-                    ConnectStreamClient();
-                }
-                else
-                {
-					if (resp != null)
-						Debug.Console(1, this, "Response from server: {0}\n{1}", resp.Code, err);
-					else
-					{
-						Debug.Console(1, this, "Null response received from server.");
-					}
-					StartReconnectTimer();
-                }
-            }
-            catch (Exception e)
-            {
-                Debug.Console(1, this, "Error Initializing Stream Client: {0}", e);
-				StartReconnectTimer();
-            }
-			RegisterLockEvent.Set();
-        }
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="dueTime"></param>
+		/// <param name="repeatTime"></param>
+		void StartServerReconnectTimer()
+		{
+			StopServerReconnectTimer();
+			ServerReconnectTimer = new CTimer(ReconnectToServerTimerCallback, ServerReconnectInterval);
+			Debug.Console(1, this, "Reconnect Timer Started.");
+		}
+
+		/// <summary>
+		/// Does what it says
+		/// </summary>
+		void StopServerReconnectTimer()
+		{
+			if (ServerReconnectTimer != null)
+			{
+				ServerReconnectTimer.Stop();
+				ServerReconnectTimer = null;
+			}
+		}
 
         /// <summary>
         /// Executes when we don't get a heartbeat message in time.  Triggers reconnect.
@@ -387,23 +524,8 @@ namespace PepperDash.Essentials
                 ServerHeartbeatCheckTimer.Stop();
                 ServerHeartbeatCheckTimer = null;
             }
-            StartReconnectTimer();
-        }
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="dueTime"></param>
-		/// <param name="repeatTime"></param>
-        void StartReconnectTimer()
-        {
-            // Start the reconnect timer
-			if (ServerReconnectTimer == null)
-			{
-				ServerReconnectTimer = new CTimer(ReconnectToServerTimerCallback, null, ServerReconnectInterval, ServerReconnectInterval);
-				Debug.Console(1, this, "Reconnect Timer Started.");
-			}
-			ServerReconnectTimer.Reset(ServerReconnectInterval, ServerReconnectInterval);
+			CleanUpWebsocketClient();
+            StartServerReconnectTimer();
         }
 
 		/// <summary>
@@ -413,43 +535,53 @@ namespace PepperDash.Essentials
 		/// <param name="repeatTime"></param>
         void ResetOrStartHearbeatTimer()
         {
-            if (ServerHeartbeatCheckTimer == null)
-            {
-				ServerHeartbeatCheckTimer = new CTimer(HeartbeatExpiredTimerCallback, null, ServerHeartbeatInterval, ServerHeartbeatInterval);
-
-                Debug.Console(1, this, "Heartbeat Timer Started.");
-            }
-
-			ServerHeartbeatCheckTimer.Reset(ServerHeartbeatInterval, ServerHeartbeatInterval);
-        }
-
-
-        /// <summary>
-        /// Connects the SSE Client
-        /// </summary>
-        /// <param name="o"></param>
-        void ConnectStreamClient()
-        {
-            Debug.Console(0, this, "Initializing Stream client to server.");
-
-			if (WSClient == null)
+			if (ServerHeartbeatCheckTimer == null)
 			{
-				WSClient = new WebSocketClient();
+				ServerHeartbeatCheckTimer = new CTimer(HeartbeatExpiredTimerCallback, null, ServerHeartbeatInterval, ServerHeartbeatInterval);
+				Debug.Console(1, this, "Heartbeat Timer Started.");
+			}
+			else
+			{
+				ServerHeartbeatCheckTimer.Reset(ServerHeartbeatInterval, ServerHeartbeatInterval);
 			}
-			WSClient.URL = string.Format("wss://{0}/system/join/{1}", Config.ServerUrl, this.SystemUuid);
-			WSClient.Connect();
-			Debug.Console(0, this, "Websocket connected");
-			WSClient.ReceiveCallBack = WebsocketReceiveCallback;
-			//WSClient.SendCallBack = WebsocketSendCallback;
-			WSClient.ReceiveAsync();
         }
 
+		/// <summary>
+		/// Waits two and goes again
+		/// </summary>
+		void ReconnectStreamClient()
+		{
+			new CTimer(o => ConnectWebsocketClient(), 2000);
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="code"></param>
+		/// <returns></returns>
+		int Websocket_DisconnectCallback(WebSocketClient.WEBSOCKET_RESULT_CODES code, object o)
+		{
+			Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Websocket disconnected with code: {0}", code);
+
+			if (ServerHeartbeatCheckTimer != null)
+				ServerHeartbeatCheckTimer.Stop();
+			// Start the reconnect timer
+			StartServerReconnectTimer();
+			return 0;
+		}
+
+
 		/// <summary>
 		/// Resets reconnect timer and updates usercode
 		/// </summary>
 		/// <param name="content"></param>
 		void HandleHeartBeat(JToken content)
 		{
+            SendMessageToServer(JObject.FromObject(new
+            {
+                type = "/system/heartbeatAck"
+            }));
+
 			var code = content["userCode"];
 			if(code != null) 
 			{
@@ -471,12 +603,26 @@ namespace PepperDash.Essentials
 		{
 			if (HttpDebugEnabled)
 			{
-				Debug.Console(0, this, "------ Begin HTTP Debug ---------------------------------------");
-				Debug.Console(0, this, "HTTP Response URL: {0}", r.ResponseUrl.ToString());
-				Debug.Console(0, this, "HTTP Response 'error' {0}", e);
-				Debug.Console(0, this, "HTTP Response code: {0}", r.Code);
-				Debug.Console(0, this, "HTTP Response content: \r{0}", r.ContentString);
-				Debug.Console(0, this, "------ End HTTP Debug -----------------------------------------");
+				try
+				{
+					Debug.Console(0, this, "------ Begin HTTP Debug ---------------------------------------");
+					if (r != null)
+					{
+						Debug.Console(0, this, "HTTP Response URL: {0}", r.ResponseUrl != null ? r.ResponseUrl.ToString() : "NONE");
+						Debug.Console(0, this, "HTTP Response code: {0}", r.Code);
+						Debug.Console(0, this, "HTTP Response content: \r{0}", r.ContentString);
+					}
+					else
+					{
+						Debug.Console(0, this, "No HTTP response");
+					}
+					Debug.Console(0, this, "HTTP Response 'error' {0}", e);
+					Debug.Console(0, this, "------ End HTTP Debug -----------------------------------------");
+				}
+				catch (Exception ex)
+				{
+					Debug.Console(0, this, "HttpDebugError: {0}", ex);
+				}
 			}
 		}
 
@@ -487,14 +633,28 @@ namespace PepperDash.Essentials
 		/// <param name="length"></param>
 		/// <param name="opcode"></param>
 		/// <param name="err"></param>
-		int WebsocketReceiveCallback(byte[] data, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode,
+		int Websocket_ReceiveCallback(byte[] data, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode,
 			WebSocketClient.WEBSOCKET_RESULT_CODES err)
 		{
-			var rx = System.Text.Encoding.UTF8.GetString(data, 0, (int)length);
-			if(rx.Length > 0)
-				ParseStreamRx(rx);
-			WSClient.ReceiveAsync();
-			return 1;
+			if (opcode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__TEXT_FRAME)
+			{
+				var rx = System.Text.Encoding.UTF8.GetString(data, 0, (int)length);
+				if (rx.Length > 0)
+					ParseStreamRx(rx);
+				WSClient.ReceiveAsync();
+			}
+
+			else if (opcode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__CLOSE)
+			{
+				Debug.Console(1, this, "Websocket disconnect received from remote");
+				CleanUpWebsocketClient();
+			}
+			else
+			{
+				Debug.Console(1, this, "websocket rx opcode/err {0}/{1}", opcode, err);
+				WSClient.ReceiveAsync();
+			}
+			return 0;
 		}
 
         /// <summary>
@@ -502,11 +662,11 @@ namespace PepperDash.Essentials
         /// </summary>
         /// <param name="result"></param>
         /// <returns></returns>
-        int WebsocketSendCallback(Crestron.SimplSharp.CrestronWebSocketClient.WebSocketClient.WEBSOCKET_RESULT_CODES result)
+        int Websocket_SendCallback(Crestron.SimplSharp.CrestronWebSocketClient.WebSocketClient.WEBSOCKET_RESULT_CODES result)
         {
-            Debug.Console(1, this, "SendCallback result: {0}", result);
-
-            return 1;
+			if(result != WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
+	            Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "SendCallback questionable result: {0}", result);
+			return 1;
         }
 
 		/// <summary>
@@ -519,7 +679,15 @@ namespace PepperDash.Essentials
             if(string.IsNullOrEmpty(message))
                 return;
 
-            Debug.Console(1, this, "Message RX: '{0}'", message);
+			if (!message.Contains("/system/heartbeat"))
+			{
+				Debug.Console(1, this, "Message RX: {0}", message);
+			}
+			else
+			{
+				LastAckMessage = DateTime.Now;
+			}
+
             try
             {
                 var messageObj = JObject.Parse(message);
@@ -528,19 +696,25 @@ namespace PepperDash.Essentials
 
                 if (type == "hello")
                 {
+					SendInitialMessage();
                     ResetOrStartHearbeatTimer();
                 }
 				else if (type == "/system/heartbeat")
 				{
 					HandleHeartBeat(messageObj["content"]);
 				}
+				else if (type == "raw")
+				{
+					var wrapper = messageObj["content"].ToObject<DeviceActionWrapper>();
+					DeviceJsonApi.DoDeviceAction(wrapper);
+				}
 				else if (type == "close")
 				{
-					WSClient.Disconnect();
+					Debug.Console(1, this, "Received close message from server.");
+					// DisconnectWebsocketClient();
 
-					ServerHeartbeatCheckTimer.Stop();
-					// Start the reconnect timer
-					StartReconnectTimer();
+					if (ServerHeartbeatCheckTimer != null)
+						ServerHeartbeatCheckTimer.Stop();
 				}
 				else
 				{
@@ -577,7 +751,7 @@ namespace PepperDash.Essentials
 										}
 									case "held":
 										{
-											if (!PushedActions.ContainsKey(type))
+											if (PushedActions.ContainsKey(type))
 											{
 												PushedActions[type].Reset(ButtonHeartbeatInterval, ButtonHeartbeatInterval);
 											}

PepperDashEssentials/AppServer/RoomBridges/MobileControlBridgeBase.cs

@@ -12,15 +12,15 @@ namespace PepperDash.Essentials
 	/// <summary>
 	/// 
 	/// </summary>
-	public abstract class CotijaBridgeBase: Device
+	public abstract class MobileControlBridgeBase: Device
 	{
-		public CotijaSystemController Parent { get; private set; }
+		public MobileControlSystemController Parent { get; private set; }
 
 		public string UserCode { get; private set; }
 
 		public abstract string RoomName { get; }
 
-		public CotijaBridgeBase(string key, string name)
+		public MobileControlBridgeBase(string key, string name)
 			: base(key, name)
 		{
 		}
@@ -30,7 +30,7 @@ namespace PepperDash.Essentials
 		/// as adding actions to parent
 		/// </summary>
 		/// <param name="parent"></param>
-		public virtual void AddParent(CotijaSystemController parent)
+		public virtual void AddParent(MobileControlSystemController parent)
 		{
 			Parent = parent;
 		}

PepperDashEssentials/AppServer/RoomBridges/MobileControlDdvc01RoomBridge.cs

@@ -0,0 +1,912 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.Reflection;
+using Crestron.SimplSharpPro.EthernetCommunication;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+using PepperDash.Core;
+using PepperDash.Essentials.AppServer.Messengers;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Room.Config;
+
+
+namespace PepperDash.Essentials.Room.MobileControl
+{
+	public class MobileControlDdvc01RoomBridge : MobileControlBridgeBase, IDelayedConfiguration
+	{
+		public class BoolJoin
+		{
+			/// <summary>
+			/// 301
+			/// </summary>
+			public const uint RoomIsOn = 301;
+
+			/// <summary>
+			/// 12
+			/// </summary>
+			public const uint PrivacyMute = 12;
+
+			/// <summary>
+			/// 41
+			/// </summary>
+			public const uint PromptForCode = 41;
+			/// <summary>
+			/// 42
+			/// </summary>
+			public const uint ClientJoined = 42;
+			/// <summary>
+			/// 51
+			/// </summary>
+			public const uint ActivityShare = 51;
+			/// <summary>
+			/// 52
+			/// </summary>
+			public const uint ActivityPhoneCall = 52;
+			/// <summary>
+			/// 53
+			/// </summary>
+			public const uint ActivityVideoCall = 53;
+
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint MasterVolumeIsMuted = 1;
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint MasterVolumeMuteToggle = 1;
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint VolumeMutesJoinStart = 1;
+			/// <summary>
+			/// 61
+			/// </summary>
+			public const uint ShutdownCancel = 61;
+			/// <summary>
+			/// 62
+			/// </summary>
+			public const uint ShutdownEnd = 62;			
+			/// <summary>
+			/// 63
+			/// </summary>
+			public const uint ShutdownStart = 63;
+			/// <summary>
+			/// 72
+			/// </summary>
+			public const uint SourceHasChanged = 71;
+
+			/// <summary>
+			/// 261 - The start of the range of speed dial visibles
+			/// </summary>
+			public const uint SpeedDialVisibleStartJoin = 261;
+			/// <summary>
+			/// 501
+			/// </summary>
+			public const uint ConfigIsReady = 501;
+			/// <summary>
+			/// 502
+			/// </summary>
+			public const uint HideVideoConfRecents = 502;
+			/// <summary>
+			/// 503
+			/// </summary>
+			public const uint ShowCameraWhenNotInCall = 503;
+			/// <summary>
+			/// 504
+			/// </summary>
+			public const uint UseSourceEnabled = 504;
+			/// <summary>
+			/// 601
+			/// </summary>
+			public const uint SourceShareDisableJoinStart = 601;
+			/// <summary>
+			/// 621
+			/// </summary>
+			public const uint SourceIsEnabledJoinStart = 621;
+
+		}
+
+		public class UshortJoin
+		{
+			/// <summary>
+			/// 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 NumberOfAuxFaders = 101;
+		}
+
+		public class StringJoin
+		{
+			/// <summary>
+			/// 1
+			/// </summary>
+			public const uint VolumeSliderNamesJoinStart = 1;
+			/// <summary>
+			/// 71
+			/// </summary>
+			public const uint SelectedSourceKey = 71;
+
+			/// <summary>
+			/// 241
+			/// </summary>
+			public const uint SpeedDialNameStartJoin = 241;
+
+			/// <summary>
+			/// 251
+			/// </summary>
+			public const uint SpeedDialNumberStartJoin = 251;
+			
+			/// <summary>
+			/// 501
+			/// </summary>
+			public const uint ConfigRoomName = 501;
+			/// <summary>
+			/// 502
+			/// </summary>
+			public const uint ConfigHelpMessage = 502;
+			/// <summary>
+			/// 503
+			/// </summary>
+			public const uint ConfigHelpNumber = 503;
+			/// <summary>
+			/// 504
+			/// </summary>
+			public const uint ConfigRoomPhoneNumber = 504;
+			/// <summary>
+			/// 505
+			/// </summary>
+			public const uint ConfigRoomURI = 505;
+			/// <summary>
+			/// 401
+			/// </summary>
+			public const uint UserCodeToSystem = 401;
+			/// <summary>
+			/// 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>
+		/// Fires when config is ready to go
+		/// </summary>
+		public event EventHandler<EventArgs> ConfigurationIsReady;
+
+		public ThreeSeriesTcpIpEthernetIntersystemCommunications EISC { get; private set; }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		public bool ConfigIsLoaded { get; private set; }
+
+		public override string RoomName
+		{
+			get { 
+				var name = EISC.StringOutput[StringJoin.ConfigRoomName].StringValue;
+				return string.IsNullOrEmpty(name) ? "Not Loaded" : name;
+			}
+		}
+
+		MobileControlDdvc01DeviceBridge SourceBridge;
+
+		Ddvc01AtcMessenger AtcMessenger;
+		Ddvc01VtcMessenger VtcMessenger;
+
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="ipId"></param>
+		public MobileControlDdvc01RoomBridge(string key, string name, uint ipId)
+			: base(key, name)
+		{
+			try
+			{
+				EISC = new ThreeSeriesTcpIpEthernetIntersystemCommunications(ipId, "127.0.0.2", Global.ControlSystem);
+				var reg = EISC.Register();
+				if (reg != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
+					Debug.Console(0, this, "Cannot connect EISC at IPID {0}: \r{1}", ipId, reg);
+
+				SourceBridge = new MobileControlDdvc01DeviceBridge(key + "-sourceBridge", "DDVC01 source bridge", EISC);
+				DeviceManager.AddDevice(SourceBridge);
+			}
+			catch (Exception)
+			{
+				throw;
+			}
+		}
+
+		/// <summary>
+		/// Finish wiring up everything after all devices are created. The base class will hunt down the related
+		/// parent controller and link them up.
+		/// </summary>
+		/// <returns></returns>
+		public override bool CustomActivate()
+		{
+			Debug.Console(0, this, "Final activation. Setting up actions and feedbacks");
+			SetupFunctions();
+			SetupFeedbacks();
+
+            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) =>
+			{
+				Debug.Console(1, this, "DDVC EISC online={0}. Config is ready={1}", a.DeviceOnLine, EISC.BooleanOutput[BoolJoin.ConfigIsReady].BoolValue);
+				if (a.DeviceOnLine && EISC.BooleanOutput[BoolJoin.ConfigIsReady].BoolValue)
+					LoadConfigValues();
+			};
+			// load config if it's already there
+			if (EISC.IsOnline && EISC.BooleanOutput[BoolJoin.ConfigIsReady].BoolValue) // || EISC.BooleanInput[BoolJoin.ConfigIsReady].BoolValue)
+				LoadConfigValues();
+
+
+			CrestronConsole.AddNewConsoleCommand(s =>
+			{
+				for (uint i = 1; i < 1000; i++)
+				{
+					if (s.ToLower().Equals("b"))
+					{
+						CrestronConsole.ConsoleCommandResponse("D{0,6} {1} - ", i, EISC.BooleanOutput[i].BoolValue);
+					}
+					else if (s.ToLower().Equals("u"))
+					{
+						CrestronConsole.ConsoleCommandResponse("U{0,6} {1,8} - ", i, EISC.UShortOutput[i].UShortValue);
+					}
+					else if (s.ToLower().Equals("s"))
+					{
+						var val = EISC.StringOutput[i].StringValue;
+						if(!string.IsNullOrEmpty(val))
+							CrestronConsole.ConsoleCommandResponse("S{0,6} {1}\r", i, EISC.StringOutput[i].StringValue);
+					}
+
+				}
+			}, "mobilebridgedump", "Dumps DDVC01 bridge EISC data b,u,s", ConsoleAccessLevelEnum.AccessOperator);
+
+			return base.CustomActivate();
+		}
+
+
+		/// <summary>
+		/// Setup the actions to take place on various incoming API calls
+		/// </summary>
+		void SetupFunctions()
+		{
+			Parent.AddAction(@"/room/room1/promptForCode", new Action(() => EISC.PulseBool(BoolJoin.PromptForCode)));
+			Parent.AddAction(@"/room/room1/clientJoined", new Action(() => EISC.PulseBool(BoolJoin.ClientJoined)));
+
+			Parent.AddAction(@"/room/room1/status", new Action(SendFullStatus));
+
+			Parent.AddAction(@"/room/room1/source", new Action<SourceSelectMessageContent>(c =>
+			{
+				EISC.SetString(StringJoin.SelectedSourceKey, c.SourceListItem);
+				EISC.PulseBool(BoolJoin.SourceHasChanged);
+			}));
+
+			Parent.AddAction(@"/room/room1/defaultsource", new Action(() => 
+				EISC.PulseBool(BoolJoin.ActivityShare)));
+			Parent.AddAction(@"/room/room1/activityPhone", new Action(() =>
+				EISC.PulseBool(BoolJoin.ActivityPhoneCall)));
+			Parent.AddAction(@"/room/room1/activityVideo", new Action(() =>
+				EISC.PulseBool(BoolJoin.ActivityVideoCall)));
+
+			Parent.AddAction(@"/room/room1/volumes/master/level", new Action<ushort>(u => 
+				EISC.SetUshort(UshortJoin.MasterVolumeLevel, u)));
+			Parent.AddAction(@"/room/room1/volumes/master/muteToggle", new Action(() => 
+				EISC.PulseBool(BoolJoin.MasterVolumeIsMuted)));
+			Parent.AddAction(@"/room/room1/volumes/master/privacyMuteToggle", new Action(() =>
+				EISC.PulseBool(BoolJoin.PrivacyMute)));
+
+
+			// /xyzxyz/volumes/master/muteToggle ---> BoolInput[1]
+
+			for (uint i = 2; i <= 7; i++)
+			{
+				var index = i;
+				Parent.AddAction(string.Format(@"/room/room1/volumes/level-{0}/level", index), new Action<ushort>(u =>
+					EISC.SetUshort(index, u)));
+				Parent.AddAction(string.Format(@"/room/room1/volumes/level-{0}/muteToggle", index), new Action(() =>
+					EISC.PulseBool(index)));
+			}
+
+			Parent.AddAction(@"/room/room1/shutdownStart", new Action(() =>
+				EISC.PulseBool(BoolJoin.ShutdownStart)));
+			Parent.AddAction(@"/room/room1/shutdownEnd", new Action(() =>
+				EISC.PulseBool(BoolJoin.ShutdownEnd)));
+			Parent.AddAction(@"/room/room1/shutdownCancel", new Action(() =>
+				EISC.PulseBool(BoolJoin.ShutdownCancel)));
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="devKey"></param>
+		void SetupSourceFunctions(string devKey)
+		{
+			SourceDeviceMapDictionary sourceJoinMap = new SourceDeviceMapDictionary();
+
+			var prefix = string.Format("/device/{0}/", devKey);
+
+			foreach (var item in sourceJoinMap)
+			{
+				var join = item.Value;
+				Parent.AddAction(string.Format("{0}{1}", prefix, item.Key), new PressAndHoldAction(b => EISC.SetBool(join, b)));
+			}
+		}
+
+
+		/// <summary>
+		/// Links feedbacks to whatever is gonna happen!
+		/// </summary>
+		void SetupFeedbacks()
+		{
+			// Power 
+			EISC.SetBoolSigAction(BoolJoin.RoomIsOn, b =>
+				PostStatusMessage(new
+					{
+						isOn = b
+					}));
+
+			// Source change things
+			EISC.SetSigTrueAction(BoolJoin.SourceHasChanged, () =>
+				PostStatusMessage(new
+					{
+						selectedSourceKey = EISC.StringOutput[StringJoin.SelectedSourceKey].StringValue
+					}));
+
+			// Volume things
+			EISC.SetUShortSigAction(UshortJoin.MasterVolumeLevel, u =>
+                PostStatusMessage(new
+                {
+                    volumes = new
+                    {
+                        master = new
+                        {
+                            level = u
+                        }
+                    }
+                }));
+
+			// map MasterVolumeIsMuted join -> status/volumes/master/muted
+			// 
+
+			EISC.SetBoolSigAction(BoolJoin.MasterVolumeIsMuted, b =>
+                PostStatusMessage(new
+                {
+                    volumes = new
+                    {
+                        master = new
+                        {
+                            muted = b
+                        }
+                    }
+                }));
+			EISC.SetBoolSigAction(BoolJoin.PrivacyMute, b => 
+				PostStatusMessage(new
+				{
+					volumes = new 
+					{
+						master = new 
+						{
+							privacyMuted = b
+						}
+					}
+				}));
+
+			for (uint i = 2; i <= 7; i++)
+			{
+				var index = i; // local scope for lambdas
+				EISC.SetUShortSigAction(index, u => // start at join 2
+				{
+					// need a dict in order to create the level-n property on auxFaders
+					var dict = new Dictionary<string, object>();
+					dict.Add("level-" + index, new { level = u });
+					PostStatusMessage(new
+					{
+						volumes = new
+						{
+							auxFaders = dict,
+						}
+					});
+				});
+				EISC.SetBoolSigAction(index, b =>
+				{
+					// need a dict in order to create the level-n property on auxFaders
+					var dict = new Dictionary<string, object>();
+					dict.Add("level-" + index, new { muted = b });
+					PostStatusMessage(new
+					{
+						volumes = new
+						{
+							auxFaders = dict,
+						}
+					});
+				});
+			}
+
+			EISC.SetUShortSigAction(UshortJoin.NumberOfAuxFaders, u => 
+				PostStatusMessage(new {
+					volumes = new {
+						numberOfAuxFaders = u,
+					}
+				}));
+
+			// shutdown things
+			EISC.SetSigTrueAction(BoolJoin.ShutdownCancel, new Action(() =>
+				PostMessage("/room/shutdown/", new
+				{
+					state = "wasCancelled"
+				})));
+			EISC.SetSigTrueAction(BoolJoin.ShutdownEnd, new Action(() =>
+				PostMessage("/room/shutdown/", new
+				{
+					state = "hasFinished"
+				})));
+			EISC.SetSigTrueAction(BoolJoin.ShutdownStart, new Action(() =>
+				PostMessage("/room/shutdown/", new
+				{
+					state = "hasStarted",
+					duration = EISC.UShortOutput[UshortJoin.ShutdownPromptDuration].UShortValue
+				})));
+
+			// Config things
+			EISC.SetSigTrueAction(BoolJoin.ConfigIsReady, LoadConfigValues);
+
+			// Activity modes
+			EISC.SetSigTrueAction(BoolJoin.ActivityShare, () => UpdateActivity(1));
+			EISC.SetSigTrueAction(BoolJoin.ActivityPhoneCall, () => UpdateActivity(2));
+			EISC.SetSigTrueAction(BoolJoin.ActivityVideoCall, () => UpdateActivity(3));
+		}
+
+
+		/// <summary>
+		/// Updates activity states
+		/// </summary>
+		void UpdateActivity(int mode)
+		{
+			PostStatusMessage(new
+			{
+				activityMode = mode,
+			});
+		}
+
+		/// <summary>
+		/// Reads in config values when the Simpl program is ready
+		/// </summary>
+		void LoadConfigValues()
+		{
+			Debug.Console(1, this, "Loading configuration from DDVC01 EISC bridge");
+			ConfigIsLoaded = false;
+
+			var co = ConfigReader.ConfigObject;
+
+            co.Info.RuntimeInfo.AppName = Assembly.GetExecutingAssembly().GetName().Name;
+            var version = Assembly.GetExecutingAssembly().GetName().Version;
+            co.Info.RuntimeInfo.AssemblyVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
+
+			//Room
+			//if (co.Rooms == null)
+			// always start fresh in case simpl changed
+			co.Rooms = new List<DeviceConfig>();
+			var rm = new DeviceConfig();
+            if (co.Rooms.Count == 0)
+            {
+                Debug.Console(0, this, "Adding room to config");
+                co.Rooms.Add(rm);
+            }
+            else
+            {
+                Debug.Console(0, this, "Replacing Room[0] in config");
+                co.Rooms[0] = rm;
+            }
+			rm.Name = EISC.StringOutput[StringJoin.ConfigRoomName].StringValue;
+			rm.Key = "room1";
+			rm.Type = "ddvc01";
+
+			DDVC01RoomPropertiesConfig rmProps;
+			if (rm.Properties == null)
+				rmProps = new DDVC01RoomPropertiesConfig();
+			else
+				rmProps = JsonConvert.DeserializeObject<DDVC01RoomPropertiesConfig>(rm.Properties.ToString());
+
+			rmProps.Help = new EssentialsHelpPropertiesConfig();
+			rmProps.Help.CallButtonText = EISC.StringOutput[StringJoin.ConfigHelpNumber].StringValue;
+			rmProps.Help.Message = EISC.StringOutput[StringJoin.ConfigHelpMessage].StringValue;
+
+			rmProps.Environment = new EssentialsEnvironmentPropertiesConfig(); // enabled defaults to false
+
+			rmProps.RoomPhoneNumber = EISC.StringOutput[StringJoin.ConfigRoomPhoneNumber].StringValue;
+			rmProps.RoomURI = EISC.StringOutput[StringJoin.ConfigRoomURI].StringValue;
+			rmProps.SpeedDials = new List<DDVC01SpeedDial>();
+
+			// This MAY need a check 
+			rmProps.AudioCodecKey = "audioCodec";
+			rmProps.VideoCodecKey = "videoCodec";
+
+			// volume control names
+			var volCount = EISC.UShortOutput[UshortJoin.NumberOfAuxFaders].UShortValue;
+
+            //// use Volumes object or?
+            //rmProps.VolumeSliderNames = new List<string>();
+            //for(uint i = 701; i <= 700 + volCount; i++)
+            //{
+            //    rmProps.VolumeSliderNames.Add(EISC.StringInput[i].StringValue);
+            //}
+
+			// There should be Mobile Control devices in here, I think...
+			if(co.Devices == null)
+				co.Devices = new List<DeviceConfig>();
+
+			// clear out previous DDVC devices
+			co.Devices.RemoveAll(d => 
+				d.Key.StartsWith("source-", StringComparison.OrdinalIgnoreCase)
+				|| d.Key.Equals("audioCodec", StringComparison.OrdinalIgnoreCase) 
+				|| d.Key.Equals("videoCodec", StringComparison.OrdinalIgnoreCase));
+			
+			rmProps.SourceListKey = "default";
+			rm.Properties = JToken.FromObject(rmProps);
+
+			// Source list! This might be brutal!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+			var groupMap = GetSourceGroupDictionary();
+
+			co.SourceLists = new Dictionary<string,Dictionary<string,SourceListItem>>();
+			var newSl = new Dictionary<string, SourceListItem>();
+			// add "none" source if VTC present
+
+			if (!string.IsNullOrEmpty(rmProps.VideoCodecKey))
+			{
+				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 (EISC.BooleanOutput[BoolJoin.UseSourceEnabled].BoolValue
+					&& !EISC.BooleanOutput[BoolJoin.SourceIsEnabledJoinStart + i].BoolValue)
+				{
+					continue;
+				}		
+				else if(!EISC.BooleanOutput[BoolJoin.UseSourceEnabled].BoolValue && string.IsNullOrEmpty(name))
+					break;
+				var icon = EISC.StringOutput[StringJoin.SourceIconJoinStart + i].StringValue;
+				var key = EISC.StringOutput[StringJoin.SourceKeyJoinStart + i].StringValue;
+				var type = EISC.StringOutput[StringJoin.SourceTypeJoinStart + i].StringValue;
+				var disableShare = EISC.BooleanOutput[BoolJoin.SourceShareDisableJoinStart + i].BoolValue;
+
+				Debug.Console(0, this, "Adding source {0} '{1}'", key, name);
+				var newSLI = new SourceListItem{
+					Icon = icon,
+					Name = name,
+					Order = (int)i + 10,
+					SourceKey = key,
+					Type = eSourceListItemType.Route,
+					DisableCodecSharing = disableShare,
+				};
+				newSl.Add(key, newSLI);
+                
+				string group = "genericsource";
+				if (groupMap.ContainsKey(type))
+				{
+					group = groupMap[type];
+				}
+				
+				// add dev to devices list
+				var devConf = new DeviceConfig {
+					Group = group,
+					Key = key,
+					Name = name,
+					Type = type
+				};
+				co.Devices.Add(devConf);
+
+				if (group.ToLower().StartsWith("settopbox")) // Add others here as needed
+				{
+					SetupSourceFunctions(key);
+				}
+			}
+
+			co.SourceLists.Add("default", newSl);
+
+			// Build "audioCodec" config if we need
+			if (!string.IsNullOrEmpty(rmProps.AudioCodecKey))
+			{
+				var acFavs = new List<PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem>();
+				for (uint i = 0; i < 4; i++)
+				{
+					if (!EISC.GetBool(BoolJoin.SpeedDialVisibleStartJoin + i))
+					{
+						break;
+					}
+					acFavs.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
+					});
+				}
+
+				var acProps = new
+				{
+					favorites = acFavs
+				};
+
+				var acStr = "audioCodec";
+				var acConf = new DeviceConfig()
+				{
+					Group = acStr,
+					Key = acStr,
+					Name = acStr,
+					Type = acStr,
+					Properties = JToken.FromObject(acProps)
+				};
+				co.Devices.Add(acConf);
+			}
+
+			// Build Video codec config
+			if (!string.IsNullOrEmpty(rmProps.VideoCodecKey))
+			{
+				// No favorites, for now?
+				var favs = new List<PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem>();
+
+				// 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));
+
+			var handler = ConfigurationIsReady;
+			if (handler != null)
+			{
+				handler(this, new EventArgs());
+			}
+
+			ConfigIsLoaded = true;
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		void SendFullStatus()
+		{
+			if (ConfigIsLoaded)
+			{
+                var count = EISC.UShortOutput[UshortJoin.NumberOfAuxFaders].UShortValue;
+
+                Debug.Console(1, this, "The Fader Count is : {0}", count);
+
+                // build volumes object, serialize and put in content of method below
+
+                // Create auxFaders
+				var auxFaderDict = new Dictionary<string, Volume>();
+				for (uint i = 2; i <= count; i++)
+				{
+					auxFaderDict.Add("level-" + i,
+						new Volume("level-" + i,
+							EISC.UShortOutput[i].UShortValue,
+							EISC.BooleanOutput[i].BoolValue,
+							EISC.StringOutput[i].StringValue,
+							true,
+							"someting.png"));
+				}
+
+                var volumes = new Volumes();
+
+                volumes.Master = new Volume("master", 
+                                EISC.UShortOutput[UshortJoin.MasterVolumeLevel].UShortValue,
+                                EISC.BooleanOutput[BoolJoin.MasterVolumeIsMuted].BoolValue,
+                  				EISC.StringOutput[1].StringValue,
+				                true,
+				                "something.png");
+				volumes.Master.HasPrivacyMute = true;
+				volumes.Master.PrivacyMuted = EISC.BooleanOutput[BoolJoin.PrivacyMute].BoolValue;
+
+                volumes.AuxFaders = auxFaderDict;
+				volumes.NumberOfAuxFaders = EISC.UShortInput[UshortJoin.NumberOfAuxFaders].UShortValue;
+
+                PostStatusMessage(new
+                    {
+						activityMode = GetActivityMode(),
+                        isOn = EISC.BooleanOutput[BoolJoin.RoomIsOn].BoolValue,
+                        selectedSourceKey = EISC.StringOutput[StringJoin.SelectedSourceKey].StringValue,
+                        volumes = volumes
+                    });			
+			}
+			else
+			{
+				PostStatusMessage(new
+				{
+					error = "systemNotReady"
+				});
+			}
+		}
+
+		/// <summary>
+		/// Returns the activity mode int
+		/// </summary>
+		/// <returns></returns>
+		int GetActivityMode()
+		{
+			if (EISC.BooleanOutput[BoolJoin.ActivityPhoneCall].BoolValue) return 2;
+			else if (EISC.BooleanOutput[BoolJoin.ActivityShare].BoolValue) return 1;
+			else if (EISC.BooleanOutput[BoolJoin.ActivityVideoCall].BoolValue) return 3;
+			return 0;
+		}
+
+		/// <summary>
+		/// Helper for posting status message
+		/// </summary>
+		/// <param name="contentObject">The contents of the content object</param>
+		void PostStatusMessage(object contentObject)
+		{
+			Parent.SendMessageToServer(JObject.FromObject(new
+				{
+					type = "/room/status/",
+					content = contentObject
+				}));
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="messageType"></param>
+		/// <param name="contentObject"></param>
+		void PostMessage(string messageType, object contentObject)
+		{
+			Parent.SendMessageToServer(JObject.FromObject(new
+			{
+				type = messageType,
+				content = contentObject
+			}));
+		}
+
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="currentDevice"></param>
+		/// <param name="args"></param>
+		void EISC_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args)
+		{
+			if (Debug.Level >= 1)
+				Debug.Console(1, this, "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);
+		}
+
+		/// <summary>
+		/// Returns the mapping of types to groups, for setting up devices.
+		/// </summary>
+		/// <returns></returns>
+		Dictionary<string, string> GetSourceGroupDictionary()
+		{
+			//type, group
+			var d = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+			{
+				{ "laptop", "pc" },
+				{ "pc", "pc" },
+				{ "wireless", "genericsource" },
+				{ "iptv", "settopbox" }
+
+			};
+			return d;
+		}
+
+		/// <summary>
+		/// updates the usercode from server
+		/// </summary>
+		protected override void UserCodeChange()
+		{
+			Debug.Console(1, this, "Server user code changed: {0}", UserCode);
+			EISC.StringInput[StringJoin.UserCodeToSystem].StringValue = UserCode;
+			EISC.StringInput[StringJoin.ServerUrl].StringValue = Parent.Config.ClientAppUrl;
+		}
+	}
+}

PepperDashEssentials/AppServer/RoomBridges/MobileControlEssentialsHuddleSpaceRoomBridge.cs

@@ -5,15 +5,26 @@ using System.Text;
 using Crestron.SimplSharp;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+
+using PepperDash.Core;
+using PepperDash.Essentials.AppServer.Messengers;
 using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Room.Cotija;
+using PepperDash.Essentials.Room.MobileControl;
+using PepperDash.Essentials.Devices.Common.Codec;
+using PepperDash.Essentials.Devices.Common.VideoCodec;
+using PepperDash.Essentials.Devices.Common.AudioCodec;
 
 namespace PepperDash.Essentials
 {
-    public class CotijaEssentialsHuddleSpaceRoomBridge : CotijaBridgeBase
+    public class MobileConrolEssentialsHuddleSpaceRoomBridge : MobileControlBridgeBase
     {
 
-        public EssentialsHuddleSpaceRoom Room { get; private set; }
+        public EssentialsRoomBase Room { get; private set; }
+
+		public VideoCodecBaseMessenger VCMessenger { get; private set; }
+
+        public AudioCodecBaseMessenger ACMessenger { get; private set; }
+
 
 		/// <summary>
 		/// 
@@ -31,7 +42,7 @@ namespace PepperDash.Essentials
 		/// </summary>
 		/// <param name="parent"></param>
 		/// <param name="room"></param>
-        public CotijaEssentialsHuddleSpaceRoomBridge(EssentialsHuddleSpaceRoom room):
+        public MobileConrolEssentialsHuddleSpaceRoomBridge(EssentialsRoomBase room):
 			base("mobileControlBridge-essentialsHuddle", "Essentials Mobile Control Bridge-Huddle")
         {
             Room = room;   
@@ -41,7 +52,7 @@ namespace PepperDash.Essentials
 		/// Override of base: calls base to add parent and then registers actions and events.
 		/// </summary>
 		/// <param name="parent"></param>
-		public override void AddParent(CotijaSystemController parent)
+		public override void AddParent(MobileControlSystemController parent)
 		{
 			base.AddParent(parent);
 
@@ -51,22 +62,69 @@ namespace PepperDash.Essentials
 			// doesn't need to know about everything.
 
 			// Source Changes and room off
-			Parent.AddAction(string.Format(@"/room/{0}/status", Room.Key), new Action(() => Room_RoomFullStatus(Room)));
-			Parent.AddAction(string.Format(@"/room/{0}/source", Room.Key), new Action<SourceSelectMessageContent>(c => Room.RunRouteAction(c.SourceListItem)));
-			Parent.AddAction(string.Format(@"/room/{0}/defaultsource", Room.Key), new Action(Room.RunDefaultRoute));
+			Parent.AddAction(string.Format(@"/room/{0}/status", Room.Key), new Action(() => SendFullStatus(Room)));
 
-			Parent.AddAction(string.Format(@"/room/{0}/masterVolumeLevel", Room.Key), new Action<ushort>(u =>
-				(Room.CurrentVolumeControls as IBasicVolumeWithFeedback).SetVolume(u)));
-			Parent.AddAction(string.Format(@"/room/{0}/masterVolumeMuteToggle", Room.Key), new Action(() => Room.CurrentVolumeControls.MuteToggle()));
+			var routeRoom = Room as IRunRouteAction;
+			if(routeRoom != null)
+				Parent.AddAction(string.Format(@"/room/{0}/source", Room.Key), new Action<SourceSelectMessageContent>(c => 
+					routeRoom.RunRouteAction(c.SourceListItem)));
+
+			var defaultRoom = Room as IRunDefaultPresentRoute;
+			if(defaultRoom != null)
+				Parent.AddAction(string.Format(@"/room/{0}/defaultsource", Room.Key), new Action(() => defaultRoom.RunDefaultPresentRoute()));
+
+			var volumeRoom = Room as IHasCurrentVolumeControls;
+			if (volumeRoom != null)
+			{
+				Parent.AddAction(string.Format(@"/room/{0}/volumes/master/level", Room.Key), new Action<ushort>(u =>
+					(volumeRoom.CurrentVolumeControls as IBasicVolumeWithFeedback).SetVolume(u)));
+				Parent.AddAction(string.Format(@"/room/{0}/volumes/master/muteToggle", Room.Key), new Action(() => 
+					volumeRoom.CurrentVolumeControls.MuteToggle()));
+				volumeRoom.CurrentVolumeDeviceChange += new EventHandler<VolumeDeviceChangeEventArgs>(Room_CurrentVolumeDeviceChange);
+
+				// Registers for initial volume events, if possible
+				var currentVolumeDevice = volumeRoom.CurrentVolumeControls as IBasicVolumeWithFeedback;
+				if (currentVolumeDevice != null)
+				{
+					currentVolumeDevice.MuteFeedback.OutputChange += MuteFeedback_OutputChange;
+					currentVolumeDevice.VolumeLevelFeedback.OutputChange += VolumeLevelFeedback_OutputChange;
+				}
+			}
+
+			var sscRoom = Room as IHasCurrentSourceInfoChange;
+			if(sscRoom != null)
+				sscRoom.CurrentSourceChange += new SourceInfoChangeHandler(Room_CurrentSingleSourceChange);
+
+			var vcRoom = Room as IHasVideoCodec;
+			if (vcRoom != null && vcRoom.VideoCodec != null)
+			{
+				var codec = vcRoom.VideoCodec;
+                var key = vcRoom.VideoCodec.Key + "-" + parent.Key;
+				VCMessenger = new VideoCodecBaseMessenger(key, vcRoom.VideoCodec, "/device/videoCodec");
+				VCMessenger.RegisterWithAppServer(Parent);
+
+				vcRoom.IsSharingFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(IsSharingFeedback_OutputChange);
+			}
+
+            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)
+			{
+				Parent.AddAction(string.Format(@"/room/{0}/activityVideo", Room.Key), new Action(()=>defCallRm.RunDefaultCallRoute()));
+			}
 
 			Parent.AddAction(string.Format(@"/room/{0}/shutdownStart", Room.Key), new Action(() => Room.StartShutdown(eShutdownType.Manual)));
 			Parent.AddAction(string.Format(@"/room/{0}/shutdownEnd", Room.Key), new Action(() => Room.ShutdownPromptTimer.Finish()));
 			Parent.AddAction(string.Format(@"/room/{0}/shutdownCancel", Room.Key), new Action(() => Room.ShutdownPromptTimer.Cancel()));
 
-			Room.CurrentSingleSourceChange += new SourceInfoChangeHandler(Room_CurrentSingleSourceChange);
-
-			Room.CurrentVolumeDeviceChange += new EventHandler<VolumeDeviceChangeEventArgs>(Room_CurrentVolumeDeviceChange);
-
 			Room.OnFeedback.OutputChange += OnFeedback_OutputChange;
 			Room.IsCoolingDownFeedback.OutputChange += IsCoolingDownFeedback_OutputChange;
 			Room.IsWarmingUpFeedback.OutputChange += IsWarmingUpFeedback_OutputChange;
@@ -74,20 +132,54 @@ namespace PepperDash.Essentials
 			Room.ShutdownPromptTimer.HasStarted += ShutdownPromptTimer_HasStarted;
 			Room.ShutdownPromptTimer.HasFinished += ShutdownPromptTimer_HasFinished;
 			Room.ShutdownPromptTimer.WasCancelled += ShutdownPromptTimer_WasCancelled;
+		}
 
-			// Registers for initial volume events, if possible
-			var currentVolumeDevice = Room.CurrentVolumeControls;
-
-			if (currentVolumeDevice != null)
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
+		void IsSharingFeedback_OutputChange(object sender, FeedbackEventArgs e)
+		{
+			// sharing source 
+			string shareText;
+			bool isSharing;
+#warning This share update needs to happen on source change as well!
+			var vcRoom = Room as IHasVideoCodec;
+			var srcInfoRoom = Room as IHasCurrentSourceInfoChange;
+			if (vcRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue && srcInfoRoom.CurrentSourceInfo != null)
 			{
-				if (currentVolumeDevice is IBasicVolumeWithFeedback)
-				{
-					var newDev = currentVolumeDevice as IBasicVolumeWithFeedback;
 
-					newDev.MuteFeedback.OutputChange += VolumeLevelFeedback_OutputChange;
-					newDev.VolumeLevelFeedback.OutputChange += VolumeLevelFeedback_OutputChange;
-				}
+				shareText = srcInfoRoom.CurrentSourceInfo.PreferredName;
+				isSharing = true;
 			}
+			else
+			{
+				shareText = "None";
+				isSharing = false;
+			}
+
+			PostStatusMessage(new
+			{
+				share = new
+				{
+					currentShareText = shareText,
+					isSharing = isSharing
+				}
+			});
+		}
+
+		/// <summary>
+		/// Helper for posting status message
+		/// </summary>
+		/// <param name="contentObject">The contents of the content object</param>
+		void PostStatusMessage(object contentObject)
+		{
+			Parent.SendMessageToServer(JObject.FromObject(new
+			{
+				type = "/room/status/",
+				content = contentObject
+			}));
 		}
 
 		/// <summary>
@@ -143,14 +235,12 @@ namespace PepperDash.Essentials
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
-		void IsWarmingUpFeedback_OutputChange(object sender, EventArgs e)
+		void IsWarmingUpFeedback_OutputChange(object sender, FeedbackEventArgs e)
 		{
-			JObject roomStatus = new JObject();
-			roomStatus.Add("isWarmingUp", (sender as BoolFeedback).BoolValue);
-			JObject message = new JObject();
-			message.Add("type", "/room/status/");
-			message.Add("content", roomStatus);
-			Parent.SendMessageToServer(message);
+			PostStatusMessage(new
+			{
+				isWarmingUp = e.BoolValue
+			});
 		}
 
 		/// <summary>
@@ -158,14 +248,12 @@ namespace PepperDash.Essentials
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
-		void IsCoolingDownFeedback_OutputChange(object sender, EventArgs e)
+		void IsCoolingDownFeedback_OutputChange(object sender, FeedbackEventArgs e)
 		{
-			JObject roomStatus = new JObject();
-			roomStatus.Add("isCoolingDown", (sender as BoolFeedback).BoolValue);
-			JObject message = new JObject();
-			message.Add("type", "/room/status/");
-			message.Add("content", roomStatus);
-			Parent.SendMessageToServer(message);
+			PostStatusMessage(new
+			{
+				isCoolingDown = e.BoolValue
+			});
 		}
 
 		/// <summary>
@@ -173,27 +261,12 @@ namespace PepperDash.Essentials
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
-        void OnFeedback_OutputChange(object sender, EventArgs e)
+        void OnFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
-            /* Example message
-            * {
-                 "type":"/room/status",
-                 "content": {
-                   "isOn": false
-                 }
-               }
-            */
-
-            JObject roomStatus = new JObject();
-
-            roomStatus.Add("isOn", (sender as BoolFeedback).BoolValue);
-
-            JObject message = new JObject();
-
-            message.Add("type", "/room/status/");
-            message.Add("content", roomStatus);
-
-            Parent.SendMessageToServer(message);
+            PostStatusMessage(new
+				{
+					isOn = e.BoolValue
+				});
         }
 
         void Room_CurrentVolumeDeviceChange(object sender, VolumeDeviceChangeEventArgs e)
@@ -201,55 +274,54 @@ namespace PepperDash.Essentials
             if (e.OldDev is IBasicVolumeWithFeedback)
             {
                 var oldDev = e.OldDev as IBasicVolumeWithFeedback;
-
-                oldDev.MuteFeedback.OutputChange -= VolumeLevelFeedback_OutputChange;
+                oldDev.MuteFeedback.OutputChange -= MuteFeedback_OutputChange;
                 oldDev.VolumeLevelFeedback.OutputChange -= VolumeLevelFeedback_OutputChange;
             }
 
             if (e.NewDev is IBasicVolumeWithFeedback)
             {
                 var newDev = e.NewDev as IBasicVolumeWithFeedback;
-
-                newDev.MuteFeedback.OutputChange += VolumeLevelFeedback_OutputChange;
+				newDev.MuteFeedback.OutputChange += MuteFeedback_OutputChange;
                 newDev.VolumeLevelFeedback.OutputChange += VolumeLevelFeedback_OutputChange;
             }
         }
 
-        void VolumeLevelFeedback_OutputChange(object sender, EventArgs e)
+		/// <summary>
+		/// Event handler for mute changes
+		/// </summary>
+		void MuteFeedback_OutputChange(object sender, FeedbackEventArgs e)
+		{
+			PostStatusMessage(new
+			{
+				volumes = new
+				{
+					master = new
+					{
+						muted = e.BoolValue
+					}
+				}
+			});
+		}
+
+		/// <summary>
+		/// Handles Volume changes on room
+		/// </summary>
+        void VolumeLevelFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
-            /* Example message
-             * {
-                  "type":"/room/status",
-                  "content": {
-                    "masterVolumeLevel": 12345,
-                    "masterVolumeMuteState": false
-                  }
-                }
-             */
-
-            var huddleRoom = Room as EssentialsHuddleSpaceRoom;
-
-            if(huddleRoom.CurrentVolumeControls is IBasicVolumeWithFeedback)
-            {
-                JObject roomStatus = new JObject();
-
-                if (huddleRoom.CurrentVolumeControls is IBasicVolumeWithFeedback)
-                {
-                    var currentVolumeConstrols = huddleRoom.CurrentVolumeControls as IBasicVolumeWithFeedback;
-                    roomStatus.Add("masterVolumeLevel", currentVolumeConstrols.VolumeLevelFeedback.IntValue);
-                    roomStatus.Add("masterVolumeMuteState", currentVolumeConstrols.MuteFeedback.BoolValue);
-                }
-
-                JObject message = new JObject();
-
-                message.Add("type", "/room/status/");
-                message.Add("content", roomStatus);
-
-                Parent.SendMessageToServer(message);
-            }
+			PostStatusMessage(new
+			{
+				volumes = new
+				{
+					master = new
+					{
+						level = e.IntValue
+					}
+				}
+			});
         }
 
-        void Room_CurrentSingleSourceChange(EssentialsRoomBase room, PepperDash.Essentials.Core.SourceListItem info, ChangeType type)
+
+        void Room_CurrentSingleSourceChange(PepperDash.Essentials.Core.SourceListItem info, ChangeType type)
         {
             /* Example message
              * {
@@ -310,16 +382,14 @@ namespace PepperDash.Essentials
                     if (dev is ITransport)
                         (dev as ITransport).LinkActions(Parent);
 
-					var huddleRoom = room as EssentialsHuddleSpaceRoom;
-					JObject roomStatus = new JObject();
-					roomStatus.Add("selectedSourceKey", huddleRoom.CurrentSourceInfoKey);
-
-					JObject message = new JObject();
-
-					message.Add("type", "/room/status/");
-					message.Add("content", roomStatus);
-
-					Parent.SendMessageToServer(message);
+					var srcRm = Room as IHasCurrentSourceInfoChange;
+                    if (srcRm != null)
+                    {
+                        PostStatusMessage(new
+                        {
+                            selectedSourceKey = srcRm.CurrentSourceInfoKey
+                        });
+                    }
                 }
             }
         }
@@ -328,52 +398,44 @@ namespace PepperDash.Essentials
         /// Posts the full status of the room to the server
         /// </summary>
         /// <param name="room"></param>
-        void Room_RoomFullStatus(EssentialsRoomBase room)
+        void SendFullStatus(EssentialsRoomBase room)
         {
-            /* Example message
-            * {
-                 "type":"/room/status",
-                 "content": {
-                   "selectedSourceKey": "off",
-                   "isOn": false,
-                   "masterVolumeLevel": 50,
-                   "masterVolumeMuteState": false
-                 }
-               }
-            */
-
-            JObject roomStatus = new JObject();
-
-            var huddleRoom = room as EssentialsHuddleSpaceRoom;
-            roomStatus.Add("isOn", huddleRoom.OnFeedback.BoolValue);
-            roomStatus.Add("selectedSourceKey", huddleRoom.CurrentSourceInfoKey);
-
-
-            if(huddleRoom.CurrentVolumeControls is IBasicVolumeWithFeedback)
-            {
-                var currentVolumeConstrols = huddleRoom.CurrentVolumeControls as IBasicVolumeWithFeedback;
-                roomStatus.Add("masterVolumeLevel", currentVolumeConstrols.VolumeLevelFeedback.IntValue);
-                roomStatus.Add("masterVolumeMuteState", currentVolumeConstrols.MuteFeedback.BoolValue);
-            }
-
-            JObject message = new JObject();
-
-            message.Add("type", "/room/status/");
-            message.Add("content", roomStatus);
-
-            Parent.SendMessageToServer(message);
+			var sourceKey = room is IHasCurrentSourceInfoChange ? (room as IHasCurrentSourceInfoChange).CurrentSourceInfoKey : null;
+			
+			var rmVc = room as IHasCurrentVolumeControls;
+			var volumes = new Volumes();
+			if (rmVc != null)
+			{
+				var vc = rmVc.CurrentVolumeControls as IBasicVolumeWithFeedback;
+				if (vc != null)
+				{
+					volumes.Master = new Volume("master", vc.VolumeLevelFeedback.UShortValue, vc.MuteFeedback.BoolValue, "Volume", true, "");
+				}
+			}
 
+			PostStatusMessage(new
+			{
+                //calls = GetCallsMessageObject(),
+				isOn = room.OnFeedback.BoolValue,
+				selectedSourceKey = sourceKey,
+                //vtc = GetVtcCallsMessageObject(),
+				volumes = volumes
+			});
         }
-     
     }
 
+	/// <summary>
+	/// 
+	/// </summary>
     public class SourceSelectMessageContent
     {
 		public string SourceListItem { get; set; }
-		//public string Destination { get; set; }
-		//public string SourceSelect { get; set; }
     }
 
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="b"></param>
     public delegate void PressAndHoldAction(bool b);
 
 }

PepperDashEssentials/AppServer/RoomBridges/SourceDeviceMapDictionary.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Room.MobileControl
+{
+
+    /// <summary>
+    /// Contains all of the default joins that map to API funtions
+    /// </summary>
+    public class SourceDeviceMapDictionary : Dictionary<string, uint>
+    {
+
+        public SourceDeviceMapDictionary(): base()
+        {
+            var dictionary = new Dictionary<string, uint>
+            {
+                {"preset01", 101},
+                {"preset02", 102},
+                {"preset03", 103},
+                {"preset04", 104},
+                {"preset05", 105},
+                {"preset06", 106},
+                {"preset07", 107},
+                {"preset08", 108},
+                {"preset09", 109},
+                {"preset10", 110},
+                {"preset11", 111},
+                {"preset12", 112},
+                {"preset13", 113},
+                {"preset14", 114},
+                {"preset15", 115},
+                {"preset16", 116},
+                {"preset17", 117},
+                {"preset18", 118},
+                {"preset19", 119},
+                {"preset20", 120},
+                {"preset21", 121},
+                {"preset22", 122},
+                {"preset23", 123},
+                {"preset24", 124},
+
+                {"num0", 130},
+                {"num1", 131},
+                {"num2", 132},
+                {"num3", 133},
+                {"num4", 134},
+                {"num5", 135},
+                {"num6", 136},
+                {"num7", 137},
+                {"num8", 138},
+                {"num9", 139},
+                {"numDash", 140},
+                {"numEnter", 141},
+                {"chanUp", 142},
+                {"chanDown", 143},
+                {"lastChan", 144},
+                {"exit", 145},
+                {"powerToggle", 146},
+                {"red", 147},
+                {"green", 148},
+                {"yellow", 149},
+                {"blue", 150},
+                {"video", 151},
+                {"previous", 152},
+                {"next", 153},
+                {"rewind", 154},
+                {"ffwd", 155},
+                {"closedCaption", 156},
+                {"stop", 157},
+                {"pause", 158},
+                {"up", 159},
+                {"down", 160},
+                {"left", 161},
+                {"right", 162},
+                {"settings", 163},
+                {"info", 164},
+                {"return", 165},
+                {"guide", 166},
+                {"reboot", 167},
+                {"dvrList", 168},
+                {"replay", 169},           
+                {"play", 170},
+                {"select", 171},
+                {"record", 172},
+                {"menu", 173},
+                {"topMenu", 174},
+                {"prevTrack", 175},
+                {"nextTrack", 176},
+                {"powerOn", 177},
+                {"powerOff", 178},
+                {"dot", 179}
+
+            };
+
+            foreach (var item in dictionary)
+            {
+                this.Add(item.Key, item.Value);
+            }
+        }
+    }
+}

PepperDashEssentials/AppServer/Volumes.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Room.MobileControl
+{
+	public class Volumes
+	{
+		[JsonProperty("master")]
+		public Volume Master { get; set; }
+
+		[JsonProperty("auxFaders")]
+		public Dictionary<string, Volume> AuxFaders { get; set; }
+
+		[JsonProperty("numberOfAuxFaders")]
+		public int NumberOfAuxFaders { get; set; }
+
+		public Volumes()
+		{
+			AuxFaders = new Dictionary<string, Volume>();	
+		}
+	}
+
+	public class Volume
+	{
+		[JsonProperty("key")]
+		public string Key { get; set; }
+
+		[JsonProperty("level")]
+		public ushort Level { get; set; }
+
+		[JsonProperty("muted")]
+		public bool Muted { get; set; }
+
+		[JsonProperty("label")]
+		public string Label { get; set; }
+
+		[JsonProperty("hasMute")]
+		public bool HasMute { get; set; }
+
+		[JsonProperty("hasPrivacyMute")]
+		public bool HasPrivacyMute { get; set; }
+
+		[JsonProperty("privacyMuted")]
+		public bool PrivacyMuted { get; set; }
+
+
+		[JsonProperty("muteIcon")]
+		public string MuteIcon { get; set; }
+
+		public Volume(string key, ushort level, bool muted, string label, bool hasMute, string muteIcon)
+		{
+			Key = key;
+			Level = level;
+			Muted = muted;
+			Label = label;
+			HasMute = hasMute;
+			MuteIcon = muteIcon;
+		}
+	}
+}

PepperDashEssentials/Bridges/AirMediaControllerBridge.cs

@@ -0,0 +1,61 @@
+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;
+using PepperDash.Essentials.DM.AirMedia;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+	public static class AirMediaControllerApiExtensions
+	{
+        public static void LinkToApi(this AirMediaController airMedia, BasicTriList trilist, uint joinStart, string joinMapKey)
+		{
+            AirMediaControllerJoinMap joinMap = new AirMediaControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<AirMediaControllerJoinMap>(joinMapSerialized);
+
+			joinMap.OffsetJoinNumbers(joinStart);
+
+			Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+			Debug.Console(0, "Linking to Airmedia: {0}", airMedia.Name);
+
+			trilist.StringInput[joinMap.Name].StringValue = airMedia.Name;			
+
+			var commMonitor = airMedia as ICommunicationMonitor;
+            if (commMonitor != null)
+            {
+                commMonitor.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            }
+
+            airMedia.IsInSessionFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsInSession]);
+            airMedia.HdmiVideoSyncDetectedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiVideoSync]);
+
+            trilist.SetSigTrueAction(joinMap.AutomaticInputRoutingEnabled, new Action( airMedia.AirMedia.DisplayControl.EnableAutomaticRouting));
+            trilist.SetSigFalseAction(joinMap.AutomaticInputRoutingEnabled, new Action( airMedia.AirMedia.DisplayControl.DisableAutomaticRouting));
+            airMedia.AutomaticInputRoutingEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AutomaticInputRoutingEnabled]);
+
+            trilist.SetUShortSigAction(joinMap.VideoOut, new Action<ushort>((u) => airMedia.SelectVideoOut(u)));
+
+            airMedia.VideoOutFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoOut]);
+            airMedia.ErrorFeedback.LinkInputSig(trilist.UShortInput[joinMap.ErrorFB]);
+            airMedia.NumberOfUsersConnectedFeedback.LinkInputSig(trilist.UShortInput[joinMap.NumberOfUsersConnectedFB]);
+
+            trilist.SetUShortSigAction(joinMap.LoginCode, new Action<ushort>((u) => airMedia.AirMedia.AirMedia.LoginCode.UShortValue = u));
+            airMedia.LoginCodeFeedback.LinkInputSig(trilist.UShortInput[joinMap.LoginCode]);
+
+            airMedia.ConnectionAddressFeedback.LinkInputSig(trilist.StringInput[joinMap.ConnectionAddressFB]);
+            airMedia.HostnameFeedback.LinkInputSig(trilist.StringInput[joinMap.HostnameFB]);
+            airMedia.SerialNumberFeedback.LinkInputSig(trilist.StringInput[joinMap.SerialNumberFeedback]);
+		}
+	}	
+}

PepperDashEssentials/Bridges/AppleTvBridge.cs

@@ -0,0 +1,41 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class AppleTvApiExtensions
+    {
+        public static void LinkToApi(this AppleTV appleTv, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            AppleTvJoinMap joinMap = new AppleTvJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if(!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<AppleTvJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+            Debug.Console(0, "Linking to Bridge Type {0}", appleTv.GetType().Name.ToString());
+
+            trilist.SetBoolSigAction(joinMap.UpArrow, (b) => appleTv.Up(b));
+            trilist.SetBoolSigAction(joinMap.DnArrow, (b) => appleTv.Down(b));
+            trilist.SetBoolSigAction(joinMap.LeftArrow, (b) => appleTv.Left(b));
+            trilist.SetBoolSigAction(joinMap.RightArrow, (b) => appleTv.Right(b));
+            trilist.SetBoolSigAction(joinMap.Select, (b) => appleTv.Select(b));
+            trilist.SetBoolSigAction(joinMap.Menu, (b) => appleTv.Menu(b));
+            trilist.SetBoolSigAction(joinMap.PlayPause, (b) => appleTv.Play(b));
+        }
+    }
+}

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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.Devices.Common.Cameras;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.CrestronIO;
+using PepperDash.Essentials.DM;
+//using PepperDash.Essentials.Devices.Common.Cameras;
+
+namespace PepperDash.Essentials.Bridges
+{
+    /// <summary>
+    /// Base class for all bridge class variants
+    /// </summary>
+    public class BridgeBase : Device
+    {
+        public BridgeApi Api { get; private set; }
+
+        public BridgeBase(string key) :
+            base(key)
+        {
+
+        }
+            
+    }
+
+    /// <summary>
+    /// Base class for bridge API variants
+    /// </summary>
+    public abstract class BridgeApi : Device
+    {
+        public BridgeApi(string key) :
+            base(key)
+        {
+
+        }
+
+    }
+
+    /// <summary>
+    /// Bridge API using EISC
+    /// </summary>
+    public class EiscApi : BridgeApi
+    {
+        public EiscApiPropertiesConfig PropertiesConfig { get; private set; }
+
+        public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
+
+        public EiscApi(DeviceConfig dc) :
+            base(dc.Key)
+        {
+            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 IBridge)      // Check for this first to allow bridges in plugins to override existing bridges that apply to the same type.
+                        {
+                            (device as IBridge).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else 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.DisplayBase)
+						{
+							(device as DisplayBase).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 DmBladeChassisController) {
+                            (device as DmBladeChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is DmpsRoutingController)
+                        {
+                            (device as DmpsRoutingController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is DmpsAudioOutputController)
+                        {
+                            (device as DmpsAudioOutputController).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 AppleTV)
+                        {
+                            (device as AppleTV).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is HdMdxxxCEController)
+                        {
+                            (device as HdMdxxxCEController).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;
+                        }
+                        else if (device is PepperDash.Essentials.Devices.Common.Occupancy.GlsOccupancySensorBaseController)
+                        {
+                            (device as PepperDash.Essentials.Devices.Common.Occupancy.GlsOccupancySensorBaseController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                    }
+                }
+
+                Debug.Console(1, this, "Devices Linked.");
+            });
+        }
+
+        /// <summary>
+        /// Used for debugging to trigger an action based on a join number and type
+        /// </summary>
+        /// <param name="join"></param>
+        /// <param name="type"></param>
+        public void ExecuteJoinAction(uint join, string type, object state)
+        {
+            try
+            {
+                switch (type.ToLower())
+                {
+                    case "digital":
+                        {
+                            var uo = Eisc.BooleanOutput[join].UserObject as Action<bool>;
+                            if (uo != null)
+                            {
+                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                uo(Convert.ToBoolean(state));
+                            }
+                            else
+                                Debug.Console(1, this, "User Action is null.  Nothing to Execute");
+                            break;
+                        }
+                    case "analog":
+                        {
+                            var uo = Eisc.BooleanOutput[join].UserObject as Action<ushort>;
+                            if (uo != null)
+                            {
+                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                uo(Convert.ToUInt16(state));
+                            }
+                            else
+                                Debug.Console(1, this, "User Action is null.  Nothing to Execute"); break;
+                        }
+                    case "serial":
+                        {
+                            var uo = Eisc.BooleanOutput[join].UserObject as Action<string>;
+                            if (uo != null)
+                            {
+                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                uo(Convert.ToString(state));
+                            }
+                            else
+                                Debug.Console(1, this, "User Action is null.  Nothing to Execute");
+                            break;
+                        }
+                    default:
+                        {
+                            Debug.Console(1, "Unknown join type.  Use digital/serial/analog");
+                            break;
+                        }
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Error: {0}", e);
+            }
+
+        }
+
+        /// <summary>
+        /// Handles incoming sig changes
+        /// </summary>
+        /// <param name="currentDevice"></param>
+        /// <param name="args"></param>
+        void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args)
+        {
+            try
+            {
+                if (Debug.Level >= 1)
+                    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 != null)
+                {
+                    Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                    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);
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Console(2, this, "Error in Eisc_SigChange handler: {0}", e);
+            }
+        }
+    }
+
+    public class EiscApiPropertiesConfig
+    {
+        [JsonProperty("control")]
+        public EssentialsControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("devices")]
+        public List<ApiDevice> Devices { get; set; }
+
+
+        public class ApiDevice
+        {
+            [JsonProperty("deviceKey")]
+            public string DeviceKey { get; set; }
+
+            [JsonProperty("joinStart")]
+            public uint JoinStart { get; set; }
+
+            [JsonProperty("joinMapKey")]
+            public string JoinMapKey { get; set; }
+        }
+
+    }
+
+
+}

PepperDashEssentials/Bridges/BridgeFactory.cs

@@ -0,0 +1,139 @@
+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 PepperDash.Essentials.Bridges;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+
+namespace PepperDash.Essentials
+{
+    public class BridgeFactory
+    {
+        public static IKeyed GetDevice(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 { };
+
+            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 == "eiscapi")
+            {
+                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);
+                }
+            }
+
+            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 string ParentDeviceKey { get; set; }
+        public eApiType ApiType { get; set; }
+        public List<EiscProperties> Eiscs { get; set; }
+        public string ApiOverrideFilePath { get; set; }
+
+        public class EiscProperties
+        {
+            public string IpId { get; set; }
+            public string Hostname { get; set; }
+        }
+    }
+
+    public class CommBridgeProperties : EiscBridgeProperties
+    {
+        public List<string> CommDevices { get; set; }
+    }
+
+    public enum eApiType { Eisc = 0 }
+
+    public class BridgeApiEisc
+    {
+        public uint Ipid { get; private set; }
+        public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
+
+        public BridgeApiEisc(string ipid, string hostname)
+        {
+            Ipid = (UInt32)int.Parse(ipid, System.Globalization.NumberStyles.HexNumber);
+            Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(Ipid, hostname, Global.ControlSystem);
+            Eisc.Register();
+            Eisc.SigChange += Eisc_SigChange;
+            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);
+        }
+    }
+}

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,137 @@
+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;
+using PepperDash.Essentials.Devices.Common.Cameras;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class CameraControllerApiExtensions
+    {
+
+        public static void LinkToApi(this PepperDash.Essentials.Devices.Common.Cameras.CameraBase cameraDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            CameraControllerJoinMap joinMap = new CameraControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<CameraControllerJoinMap>(joinMapSerialized);
+
+            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]);
+
+            var ptzCamera = cameraDevice as IHasCameraPtzControl;
+
+            if (ptzCamera != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Left, (b) =>
+                    {
+                        if (b)
+                        {
+                            ptzCamera.PanLeft();
+                        }
+                        else
+                        {
+                            ptzCamera.PanStop();
+                        }
+                    });
+                trilist.SetBoolSigAction(joinMap.Right, (b) =>
+                {
+                    if (b)
+                    {
+                        ptzCamera.PanRight();
+                    }
+                    else
+                    {
+                        ptzCamera.PanStop();
+                    }
+                });
+
+                trilist.SetBoolSigAction(joinMap.Up, (b) =>
+                {
+                    if (b)
+                    {
+                        ptzCamera.TiltUp();
+                    }
+                    else
+                    {
+                        ptzCamera.TiltStop();
+                    }
+                });
+                trilist.SetBoolSigAction(joinMap.Down, (b) =>
+                {
+                    if (b)
+                    {
+                        ptzCamera.TiltDown();
+                    }
+                    else
+                    {
+                        ptzCamera.TiltStop();
+                    }
+                });
+
+                trilist.SetBoolSigAction(joinMap.ZoomIn, (b) =>
+                {
+                    if (b)
+                    {
+                        ptzCamera.ZoomIn();
+                    }
+                    else
+                    {
+                        ptzCamera.ZoomStop();
+                    }
+                });
+
+                trilist.SetBoolSigAction(joinMap.ZoomOut, (b) =>
+                {
+                    if (b)
+                    {
+                        ptzCamera.ZoomOut();
+                    }
+                    else
+                    {
+                        ptzCamera.ZoomStop();
+                    }
+                });
+            }
+
+            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);
+                    });
+                }
+            }
+        }
+    }
+
+}

PepperDashEssentials/Bridges/DigitalLoggerBridge.cs

@@ -0,0 +1,42 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DigitalLoggerApiExtensions
+    {
+        public static void LinkToApi(this DigitalLogger DigitalLogger, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DigitalLoggerJoinMap joinMap = new DigitalLoggerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DigitalLoggerJoinMap>(joinMapSerialized);
+
+            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));
+
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DisplayControllerBridge.cs

@@ -0,0 +1,153 @@
+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;
+
+using Newtonsoft.Json;
+
+
+namespace PepperDash.Essentials.Bridges
+{
+	public static class DisplayControllerApiExtensions
+	{
+		public static void LinkToApi(this PepperDash.Essentials.Core.DisplayBase displayDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+		{
+            int inputNumber = 0;
+            IntFeedback inputNumberFeedback;
+            List<string> inputKeys = new List<string>();
+
+            DisplayControllerJoinMap joinMap = new DisplayControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+            
+            if(!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DisplayControllerJoinMap>(joinMapSerialized);
+
+			joinMap.OffsetJoinNumbers(joinStart);
+
+			Debug.Console(1, "Linking to Trilist '{0}'",trilist.ID.ToString("X"));
+			Debug.Console(0, "Linking to Display: {0}", displayDevice.Name);
+
+            trilist.StringInput[joinMap.Name].StringValue = displayDevice.Name;			
+
+			var commMonitor = displayDevice as ICommunicationMonitor;
+            if (commMonitor != null)
+            {
+                commMonitor.CommunicationMonitor.IsOnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            }
+
+            inputNumberFeedback = new IntFeedback(() => { return inputNumber; });
+
+            // Two way feedbacks
+            var twoWayDisplay = displayDevice as PepperDash.Essentials.Core.TwoWayDisplayBase;
+            if (twoWayDisplay != null)
+            {
+                trilist.SetBool(joinMap.IsTwoWayDisplay, true);
+
+                twoWayDisplay.CurrentInputFeedback.OutputChange += new EventHandler<FeedbackEventArgs>(CurrentInputFeedback_OutputChange);
+
+
+                inputNumberFeedback.LinkInputSig(trilist.UShortInput[joinMap.InputSelect]);
+            }
+
+			// Power Off
+			trilist.SetSigTrueAction(joinMap.PowerOff, () =>
+				{
+					inputNumber = 102;
+					inputNumberFeedback.FireUpdate();
+					displayDevice.PowerOff();
+				});
+
+			displayDevice.PowerIsOnFeedback.OutputChange += new EventHandler<FeedbackEventArgs>( (o,a) => {
+                if (!a.BoolValue)
+                {
+                    inputNumber = 102;
+                    inputNumberFeedback.FireUpdate();
+
+                }
+                else
+                {
+                    inputNumber = 0;
+                    inputNumberFeedback.FireUpdate();
+                }
+            });
+
+			displayDevice.PowerIsOnFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.PowerOff]);
+
+			// PowerOn
+			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); });
+                Debug.Console(2, displayDevice, "Setting Input Select Action on Digital Join {0} to Input: {1}", joinMap.InputSelectOffset + count, displayDevice.InputPorts[tempKey].Key.ToString());
+				trilist.StringInput[(ushort)(joinMap.InputNamesOffset + count)].StringValue = input.Key.ToString();
+				count++;
+			}
+
+            Debug.Console(2, displayDevice, "Setting Input Select Action on Analog Join {0}", joinMap.InputSelect);
+			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();
+
+				}
+                if (twoWayDisplay != null)
+				    inputNumberFeedback.FireUpdate();
+			});
+
+
+            var volumeDisplay = displayDevice as IBasicVolumeControls;
+            if (volumeDisplay != null)
+            {
+                trilist.SetBoolSigAction(joinMap.VolumeUp, (b) => volumeDisplay.VolumeUp(b));
+                trilist.SetBoolSigAction(joinMap.VolumeDown, (b) => volumeDisplay.VolumeDown(b));
+                trilist.SetSigTrueAction(joinMap.VolumeMute, () => volumeDisplay.MuteToggle());
+
+                var volumeDisplayWithFeedback = volumeDisplay as IBasicVolumeWithFeedback;
+                if(volumeDisplayWithFeedback != null)
+                {
+                    trilist.SetUShortSigAction(joinMap.VolumeLevel, new Action<ushort>((u) => volumeDisplayWithFeedback.SetVolume(u)));
+                    volumeDisplayWithFeedback.VolumeLevelFeedback.LinkInputSig(trilist.UShortInput[joinMap.VolumeLevel]);
+                    volumeDisplayWithFeedback.MuteFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VolumeMute]);
+                }
+            }
+		}
+
+		static void CurrentInputFeedback_OutputChange(object sender, FeedbackEventArgs e)
+		{
+
+			Debug.Console(0, "CurrentInputFeedback_OutputChange {0}", e.StringValue);
+
+		}
+
+	}
+   
+}

PepperDashEssentials/Bridges/DmBladeChassisControllerBridge.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges {
+    public static class DmBladeChassisControllerApiExtentions {
+        public static void LinkToApi(this DmBladeChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey) {
+            DmBladeChassisControllerJoinMap joinMap = new DmBladeChassisControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmBladeChassisControllerJoinMap>(joinMapSerialized);
+
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            var chassis = dmChassis.Chassis as BladeSwitch;
+
+            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+
+            // Link up outputs
+            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs; i++) {
+                var ioSlot = i;
+
+                // Control
+                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
+
+                if (dmChassis.TxDictionary.ContainsKey(ioSlot)) {
+                    Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
+                    var txKey = dmChassis.TxDictionary[ioSlot];
+                    var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
+
+                    var advancedTxDevice = basicTxDevice as DmTxControllerBase;
+
+                    if (dmChassis.Chassis is DmMd128x128 || dmChassis.Chassis is DmMd64x64) {
+                        dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                    }
+                    else {
+                        if (advancedTxDevice != null) {
+                            advancedTxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                            Debug.Console(2, "Linking Tx Online Feedback from Advanced Transmitter at input {0}", ioSlot);
+                        }
+                        else if (dmChassis.InputEndpointOnlineFeedbacks[ioSlot] != null) {
+                            Debug.Console(2, "Linking Tx Online Feedback from Input Card {0}", ioSlot);
+                            dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                        }
+                    }
+
+                    if (basicTxDevice != null && advancedTxDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+                    if (advancedTxDevice != null) {
+                        advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+                    }
+                    else if (advancedTxDevice == null || basicTxDevice != null) {
+                        Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
+                        dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                        var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                        if (inputPort != null) {
+                            Debug.Console(1, "Port value for input card {0} is set", ioSlot);
+                            var port = inputPort.Port;
+
+                            if (port != null) {
+                                if (port is HdmiInputWithCEC) {
+                                    Debug.Console(1, "Port is HdmiInputWithCec");
+
+                                    var hdmiInPortWCec = port as HdmiInputWithCEC;
+
+                                    if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown) {
+                                        SetHdcpStateAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                        else {
+                            inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--dmIn", ioSlot)];
+
+                            if (inputPort != null) {
+                                var port = inputPort.Port;
+
+                                if (port is DMInputPortWithCec) {
+                                    Debug.Console(1, "Port is DMInputPortWithCec");
+
+                                    var dmInPortWCec = port as DMInputPortWithCec;
+
+                                    if (dmInPortWCec != null) {
+                                        SetHdcpStateAction(dmChassis.PropertiesConfig.InputSlotSupportsHdcp2[ioSlot], dmInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                    var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                    if (inputPort != null) {
+                        var hdmiPort = inputPort.Port as EndpointHdmiInput;
+
+                        if (hdmiPort != null) {
+                            SetHdcpStateAction(true, hdmiPort, joinMap.HdcpSupportState + ioSlot, trilist);
+                            dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + 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;
+                    //var hdBaseTDevice = DeviceManager.GetDeviceForKey(rxKey) as DmHdBaseTControllerBase;
+                    //if (hdBaseTDevice != null) {
+                        dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    //}
+                    //else if (rxDevice != null) {
+                    //    rxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    //}
+                }
+
+                // Feedback
+                dmChassis.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + 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]);
+            }
+        }
+
+        static void SetHdcpStateAction(bool hdcpTypeSimple, HdmiInputWithCEC 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>(u => {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(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>(u => {
+                            port.HdcpCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(bool supportsHdcp2, DMInputPortWithCec port, uint join, BasicTriList trilist) {
+            if (!supportsHdcp2) {
+                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>(u => {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+    }
+}

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -0,0 +1,284 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmChassisControllerApiExtentions
+    {
+        public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DmChassisControllerJoinMap joinMap = new DmChassisControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmChassisControllerJoinMap>(joinMapSerialized);
+            
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            var chassis = dmChassis.Chassis as DmMDMnxn;
+
+            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+            trilist.SetUShortSigAction(joinMap.SystemId, new Action<ushort>(o => chassis.SystemId.UShortValue = o));
+            trilist.SetSigTrueAction(joinMap.SystemId, new Action(() => chassis.ApplySystemId()));
+
+            dmChassis.SystemIdFeebdack.LinkInputSig(trilist.UShortInput[joinMap.SystemId]);
+            dmChassis.SystemIdBusyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SystemId]);
+
+            // Link up outputs
+            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs; 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)));
+                trilist.SetUShortSigAction(joinMap.OutputUsb + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.UsbOutput)));
+                trilist.SetUShortSigAction(joinMap.InputUsb + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.UsbInput)));
+
+                if (dmChassis.TxDictionary.ContainsKey(ioSlot))
+                {
+                    Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
+                    var txKey = dmChassis.TxDictionary[ioSlot];
+                    var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
+
+                    var advancedTxDevice = basicTxDevice as DmTxControllerBase;
+
+                    if (dmChassis.Chassis is DmMd8x8Cpu3 || dmChassis.Chassis is DmMd8x8Cpu3rps
+                        || dmChassis.Chassis is DmMd16x16Cpu3 || dmChassis.Chassis is DmMd16x16Cpu3rps
+                        || dmChassis.Chassis is DmMd32x32Cpu3 || dmChassis.Chassis is DmMd32x32Cpu3rps)
+                    {
+                        dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                    }
+                    else
+                    {
+                        if (advancedTxDevice != null)
+                        {
+                            advancedTxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                            Debug.Console(2, "Linking Tx Online Feedback from Advanced Transmitter at input {0}", ioSlot);
+                        }
+                        else if (dmChassis.InputEndpointOnlineFeedbacks[ioSlot] != null)
+                        {
+                            Debug.Console(2, "Linking Tx Online Feedback from Input Card {0}", ioSlot);
+                            dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);                           
+                        }
+                    }
+
+                    if (basicTxDevice != null && advancedTxDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+                    if (advancedTxDevice != null)
+                    {
+                        advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+                    }
+                    else if(advancedTxDevice == null || basicTxDevice != null)
+                    {
+                        Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
+                        dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                        var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                        if (inputPort != null)
+                        {
+                            Debug.Console(1, "Port value for input card {0} is set", ioSlot);
+                            var port = inputPort.Port;
+
+                            if (port != null)
+                            {
+                                if (port is HdmiInputWithCEC)
+                                {
+                                    Debug.Console(1, "Port is HdmiInputWithCec");
+
+                                    var hdmiInPortWCec = port as HdmiInputWithCEC;
+
+                                    if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown)
+                                    {
+                                        SetHdcpStateAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if(dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--dmIn", ioSlot)];
+
+                            if(inputPort != null)
+                            {
+                                var port = inputPort.Port;
+
+                                if (port is DMInputPortWithCec)
+                                {
+                                    Debug.Console(1, "Port is DMInputPortWithCec");
+
+                                    var dmInPortWCec = port as DMInputPortWithCec;
+
+                                    if (dmInPortWCec != null)
+                                    {
+                                        SetHdcpStateAction(dmChassis.PropertiesConfig.InputSlotSupportsHdcp2[ioSlot], dmInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                    var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                    if (inputPort != null)
+                    {
+                        var hdmiPort = inputPort.Port as EndpointHdmiInput;
+
+                        if (hdmiPort != null)
+                        {
+                            SetHdcpStateAction(true, hdmiPort, joinMap.HdcpSupportState + ioSlot, trilist);
+                            dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + 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;
+                    var hdBaseTDevice = DeviceManager.GetDeviceForKey(rxKey) as DmHdBaseTControllerBase;
+                    if (dmChassis.Chassis is DmMd8x8Cpu3 || dmChassis.Chassis is DmMd8x8Cpu3rps
+                        || dmChassis.Chassis is DmMd16x16Cpu3 || dmChassis.Chassis is DmMd16x16Cpu3rps
+                        || dmChassis.Chassis is DmMd32x32Cpu3 || dmChassis.Chassis is DmMd32x32Cpu3rps || hdBaseTDevice != null)
+                    {
+                        dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    }
+                    else if (rxDevice != null)
+                    {
+                        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.UsbOutputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputUsb + ioSlot]);
+                dmChassis.UsbInputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.InputUsb + 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]);
+            }
+        }
+
+        static void SetHdcpStateAction(bool hdcpTypeSimple, HdmiInputWithCEC 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>(u =>
+                        {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(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>(u =>
+                        {
+                            port.HdcpCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(bool supportsHdcp2, DMInputPortWithCec port, uint join, BasicTriList trilist)
+        {
+            if (!supportsHdcp2)
+            {
+                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>(u =>
+                        {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+    }
+}

PepperDashEssentials/Bridges/DmRmcControllerBridge.cs

@@ -0,0 +1,44 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmRmcControllerApiExtensions
+    {
+        public static void LinkToApi(this DmRmcControllerBase rmc, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DmRmcControllerJoinMap joinMap = new DmRmcControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmRmcControllerJoinMap>(joinMapSerialized);
+
+            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]);
+        }
+    }
+}

PepperDashEssentials/Bridges/DmTxControllerBridge.cs

@@ -0,0 +1,137 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmTxControllerApiExtensions
+    {
+        public static void LinkToApi(this DmTxControllerBase tx, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DmTxControllerJoinMap joinMap = new DmTxControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmTxControllerJoinMap>(joinMapSerialized);
+
+            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]);
+            trilist.UShortInput[joinMap.HdcpSupportCapability].UShortValue = (ushort)tx.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;
+                        }));
+            }
+        }
+
+
+    }
+}

PepperDashEssentials/Bridges/DmpsAudioOutputControllerBridge.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 Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmpsAudioOutputControllerApiExtensions
+    {
+        public static void LinkToApi(this DmpsAudioOutputController dmAudioOutputController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DmpsAudioOutputControllerJoinMap joinMap = new DmpsAudioOutputControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmpsAudioOutputControllerJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmAudioOutputController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            if (dmAudioOutputController.MasterVolumeLevel != null)
+            {
+                SetUpDmpsAudioOutputJoins(trilist, dmAudioOutputController.MasterVolumeLevel, joinMap.MasterVolume);
+            }
+
+            if (dmAudioOutputController.SourceVolumeLevel != null)
+            {
+                SetUpDmpsAudioOutputJoins(trilist, dmAudioOutputController.SourceVolumeLevel, joinMap.SourceVolume);
+            }
+
+            if (dmAudioOutputController.Codec1VolumeLevel != null)
+            {
+                SetUpDmpsAudioOutputJoins(trilist, dmAudioOutputController.Codec1VolumeLevel, joinMap.Codec1Volume);
+            }
+
+            if (dmAudioOutputController.Codec2VolumeLevel != null)
+            {
+                SetUpDmpsAudioOutputJoins(trilist, dmAudioOutputController.Codec2VolumeLevel, joinMap.Codec2Volume);
+            }
+
+        }
+
+        static void SetUpDmpsAudioOutputJoins(BasicTriList trilist, DmpsAudioOutput output, uint joinStart)
+        {
+            var volumeLevelJoin = joinStart;
+            var muteOnJoin = joinStart;
+            var muteOffJoin = joinStart + 1;
+            var volumeUpJoin = joinStart + 2;
+            var volumeDownJoin = joinStart + 3;
+
+
+            trilist.SetUShortSigAction(volumeLevelJoin, new Action<ushort>(o => output.SetVolume(o)));
+            output.VolumeLevelFeedback.LinkInputSig(trilist.UShortInput[volumeLevelJoin]);
+
+            trilist.SetSigTrueAction(muteOnJoin, new Action(output.MuteOn));
+            output.MuteFeedback.LinkInputSig(trilist.BooleanInput[muteOnJoin]);
+            trilist.SetSigTrueAction(muteOffJoin, new Action(output.MuteOff));
+            output.MuteFeedback.LinkComplementInputSig(trilist.BooleanInput[muteOffJoin]);
+
+            trilist.SetBoolSigAction(volumeUpJoin, new Action<bool>(b => output.VolumeUp(b)));
+            trilist.SetBoolSigAction(volumeDownJoin, new Action<bool>(b => output.VolumeDown(b)));
+        }
+    }
+}

PepperDashEssentials/Bridges/DmpsRoutingControllerBridge.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmpsRoutingControllerApiExtentions 
+    {
+        public static void LinkToApi(this DmpsRoutingController dmpsRouter, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            DmpsRoutingControllerJoinMap joinMap = new DmpsRoutingControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmpsRoutingControllerJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmpsRouter, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            // Link up outputs
+            for (uint i = 1; i <= dmpsRouter.Dmps.NumberOfSwitcherInputs; i++)
+            {
+                Debug.Console(2, dmpsRouter, "Linking Input Card {0}", i);
+
+                var ioSlot = i;
+
+                //if (dmpsRouter.TxDictionary.ContainsKey(ioSlot))
+                //{
+                //    Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
+                //    var TxKey = dmpsRouter.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(dmpsRouter.VideoInputSyncFeedbacks[ioSlot] != null)
+                    dmpsRouter.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                if (dmpsRouter.InputNameFeedbacks[ioSlot] != null)
+                    dmpsRouter.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
+
+                trilist.SetStringSigAction(joinMap.InputNames + ioSlot, new Action<string>(s => 
+                    {
+                        var inputCard = dmpsRouter.Dmps.SwitcherInputs[ioSlot] as DMInput;
+
+                        if (inputCard != null)
+                        {
+                            if (inputCard.NameFeedback != null && !string.IsNullOrEmpty(inputCard.NameFeedback.StringValue) && inputCard.NameFeedback.StringValue != s)
+                                if(inputCard.Name != null)
+                                    inputCard.Name.StringValue = s;
+                        }
+                    }));
+
+
+                if(dmpsRouter.InputEndpointOnlineFeedbacks[ioSlot] != null)
+                    dmpsRouter.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+            }
+
+            for (uint i = 1; i <= dmpsRouter.Dmps.NumberOfSwitcherOutputs; i++)
+            {
+                Debug.Console(2, dmpsRouter, "Linking Output Card {0}", i);
+
+                var ioSlot = i;
+                // Control
+                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmpsRouter.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
+                trilist.SetUShortSigAction(joinMap.OutputAudio + ioSlot, new Action<ushort>(o => dmpsRouter.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Audio)));
+
+                trilist.SetStringSigAction(joinMap.OutputNames + ioSlot, new Action<string>(s =>
+                {
+                    var outputCard = dmpsRouter.Dmps.SwitcherOutputs[ioSlot] as DMOutput;
+
+                    //Debug.Console(2, dmpsRouter, "Output Name String Sig Action for Output Card  {0}", ioSlot);
+
+                    if (outputCard != null)
+                    {
+                        //Debug.Console(2, dmpsRouter, "Card Type: {0}", outputCard.CardInputOutputType);
+
+                        if (!(outputCard is Crestron.SimplSharpPro.DM.Cards.Card.Dmps3CodecOutput) && outputCard.NameFeedback != null)
+                        {
+                            if (!string.IsNullOrEmpty(outputCard.NameFeedback.StringValue))
+                            {
+                                //Debug.Console(2, dmpsRouter, "NameFeedabck: {0}", outputCard.NameFeedback.StringValue);
+
+                                if (outputCard.NameFeedback.StringValue != s && outputCard.Name != null)
+                                {
+                                    outputCard.Name.StringValue = s;
+                                }
+                            }
+                        }
+                    }
+                }));
+
+                // Feedback
+                if(dmpsRouter.VideoOutputFeedbacks[ioSlot] != null)
+                    dmpsRouter.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + ioSlot]);
+                if (dmpsRouter.AudioOutputFeedbacks[ioSlot] != null)
+                    dmpsRouter.AudioOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputAudio + ioSlot]);
+                if (dmpsRouter.OutputNameFeedbacks[ioSlot] != null)
+                    dmpsRouter.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
+                if (dmpsRouter.OutputVideoRouteNameFeedbacks[ioSlot] != null)
+                    dmpsRouter.OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames + ioSlot]);
+                if (dmpsRouter.OutputAudioRouteNameFeedbacks[ioSlot] != null)
+                    dmpsRouter.OutputAudioRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentAudioInputNames + ioSlot]);
+                if (dmpsRouter.OutputEndpointOnlineFeedbacks[ioSlot] != null)
+                    dmpsRouter.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+            }
+        }
+    }
+}

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,74 @@
+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;
+
+using Newtonsoft.Json;
+
+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)
+        {
+            GenericLightingJoinMap joinMap = new GenericLightingJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<GenericLightingJoinMap>(joinMapSerialized);
+
+            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));
+
+            }
+             */
+        }
+    }
+}

PepperDashEssentials/Bridges/GenericRelayDeviceBridge.cs

@@ -0,0 +1,51 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class GenericRelayDeviceApiExtensions
+    {
+        public static void LinkToApi(this GenericRelayDevice relay, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            GenericRelayControllerJoinMap joinMap = new GenericRelayControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<GenericRelayControllerJoinMap>(joinMapSerialized);
+
+            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]);
+        }
+
+    }
+}

PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Essentials.Devices.Common.Occupancy;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Core;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class GlsOccupancySensorBaseControllerApiExtensions
+    {
+        public static void LinkToApi(this GlsOccupancySensorBaseController occController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            GlsOccupancySensorBaseJoinMap joinMap = new GlsOccupancySensorBaseJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<GlsOccupancySensorBaseJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            #region Single and Dual Sensor Stuff
+            occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+            // Occupied status
+            trilist.SetSigTrueAction(joinMap.ForceOccupied, new Action(() => occController.ForceOccupied()));
+            trilist.SetSigTrueAction(joinMap.ForceVacant, new Action(() => occController.ForceVacant()));
+            occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback]);
+            occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback]);
+            occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback]);
+
+            // Timouts
+            trilist.SetUShortSigAction(joinMap.Timeout, new Action<ushort>((u) => occController.SetRemoteTimeout(u)));
+            occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout]);
+            occController.LocalTimoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback]);
+
+            // LED Flash
+            trilist.SetSigTrueAction(joinMap.EnableLedFlash, new Action(() => occController.SetLedFlashEnable(true)));
+            trilist.SetSigTrueAction(joinMap.DisableLedFlash, new Action(() => occController.SetLedFlashEnable(false)));
+            occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash]);
+
+            // Short Timeout
+            trilist.SetSigTrueAction(joinMap.EnableShortTimeout, new Action(() => occController.SetShortTimeoutState(true)));
+            trilist.SetSigTrueAction(joinMap.DisableShortTimeout, new Action(() => occController.SetShortTimeoutState(false)));
+            occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout]);
+
+            // PIR Sensor
+            trilist.SetSigTrueAction(joinMap.EnablePir, new Action(() => occController.SetPirEnable(true)));
+            trilist.SetSigTrueAction(joinMap.DisablePir, new Action(() => occController.SetPirEnable(false)));
+            occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir]);
+            
+            // PIR Sensitivity in Occupied State
+            trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState, new Action<bool>((b) => occController.IncrementPirSensitivityInOccupiedState(b)));
+            trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState, new Action<bool>((b) => occController.DecrementPirSensitivityInOccupiedState(b)));
+            occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInOccupiedState]);
+
+            // PIR Sensitivity in Vacant State
+            trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState, new Action<bool>((b) => occController.IncrementPirSensitivityInVacantState(b)));
+            trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState, new Action<bool>((b) => occController.DecrementPirSensitivityInVacantState(b)));
+            occController.PirSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInVacantState]);
+            #endregion
+
+            #region Dual Technology Sensor Stuff
+            var odtOccController = occController as GlsOdtOccupancySensorController;
+
+            if (odtOccController != null)
+            {
+                // OR When Vacated
+                trilist.SetBoolSigAction(joinMap.OrWhenVacated, new Action<bool>((b) => odtOccController.SetOrWhenVacatedState(b)));
+                odtOccController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated]);
+
+                // AND When Vacated
+                trilist.SetBoolSigAction(joinMap.AndWhenVacated, new Action<bool>((b) => odtOccController.SetAndWhenVacatedState(b)));
+                odtOccController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated]);
+
+                // Ultrasonic A Sensor
+                trilist.SetSigTrueAction(joinMap.EnableUsA, new Action(() => odtOccController.SetUsAEnable(true)));
+                trilist.SetSigTrueAction(joinMap.DisableUsA, new Action(() => odtOccController.SetUsAEnable(false)));
+                odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA]);
+
+                // Ultrasonic B Sensor
+                trilist.SetSigTrueAction(joinMap.EnableUsB, new Action(() => odtOccController.SetUsBEnable(true)));
+                trilist.SetSigTrueAction(joinMap.DisableUsB, new Action(() => odtOccController.SetUsBEnable(false)));
+                odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB]);
+
+                // US Sensitivity in Occupied State
+                trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState, new Action<bool>((b) => odtOccController.IncrementUsSensitivityInOccupiedState(b)));
+                trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState, new Action<bool>((b) => odtOccController.DecrementUsSensitivityInOccupiedState(b)));
+                odtOccController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInOccupiedState]);
+
+                // US Sensitivity in Vacant State
+                trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState, new Action<bool>((b) => odtOccController.IncrementUsSensitivityInVacantState(b)));
+                trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState, new Action<bool>((b) => odtOccController.DecrementUsSensitivityInVacantState(b)));
+                odtOccController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInVacantState]);
+
+            }
+            #endregion
+        }
+    }
+}

PepperDashEssentials/Bridges/HdMdxxxCEControllerBridge.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 Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class HdMdxxxCEControllerApiExtensions
+    {
+        public static void LinkToApi(this HdMdxxxCEController hdMdPair, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            HdMdxxxCEControllerJoinMap joinMap = new HdMdxxxCEControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<HdMdxxxCEControllerJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, hdMdPair, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            hdMdPair.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            hdMdPair.RemoteEndDetectedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RemoteEndDetected]);
+
+            trilist.SetSigTrueAction(joinMap.AutoRouteOn, new Action(() => hdMdPair.AutoRouteOn()));
+            hdMdPair.AutoRouteOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AutoRouteOn]);
+            trilist.SetSigTrueAction(joinMap.AutoRouteOff, new Action(() => hdMdPair.AutoRouteOff()));
+            hdMdPair.AutoRouteOnFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.AutoRouteOff]);
+
+            trilist.SetSigTrueAction(joinMap.PriorityRoutingOn, new Action(() => hdMdPair.PriorityRouteOn()));
+            hdMdPair.PriorityRoutingOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PriorityRoutingOn]);
+            trilist.SetSigTrueAction(joinMap.PriorityRoutingOff, new Action(() => hdMdPair.PriorityRouteOff()));
+            hdMdPair.PriorityRoutingOnFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.PriorityRoutingOff]);
+
+            trilist.SetSigTrueAction(joinMap.InputOnScreenDisplayEnabled, new Action(() => hdMdPair.OnScreenDisplayEnable()));
+            hdMdPair.InputOnScreenDisplayEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputOnScreenDisplayEnabled]);
+            trilist.SetSigTrueAction(joinMap.AutoRouteOff, new Action(() => hdMdPair.OnScreenDisplayDisable()));
+            hdMdPair.InputOnScreenDisplayEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.InputOnScreenDisplayDisabled]);
+
+            trilist.SetUShortSigAction(joinMap.VideoSource, new Action<ushort>((i) => hdMdPair.ExecuteSwitch(i, null, eRoutingSignalType.Video | eRoutingSignalType.Audio)));
+            hdMdPair.VideoSourceFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoSource]);
+
+            trilist.UShortInput[joinMap.SourceCount].UShortValue = (ushort)hdMdPair.InputPorts.Count;
+
+            foreach (var input in hdMdPair.InputPorts)
+            {
+                var number = Convert.ToUInt16(input.Selector);
+                hdMdPair.SyncDetectedFeedbacks[number].LinkInputSig(trilist.BooleanInput[joinMap.SyncDetected + number]);
+                trilist.StringInput[joinMap.SourceNames + number].StringValue = input.Key;
+            }
+
+        } 
+    }
+}

PepperDashEssentials/Bridges/IBasicCommunicationBridge.cs

@@ -0,0 +1,69 @@
+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 Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IBasicCommunicationApiExtensions
+    {
+        public static void LinkToApi(this GenericComm comm, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            IBasicCommunicationJoinMap joinMap = new IBasicCommunicationJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IBasicCommunicationJoinMap>(joinMapSerialized);
+            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, 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();
+                    }
+                }));
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/IBridge.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public interface IBridge
+    {
+        void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey);
+    }
+}

PepperDashEssentials/Bridges/IDigitalInputBridge.cs

@@ -0,0 +1,44 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IDigitalInputApiExtenstions
+    {
+        public static void LinkToApi(this IDigitalInput input, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            IDigitalInputJoinMap joinMap = new IDigitalInputJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IDigitalInputJoinMap>(joinMapSerialized);
+
+            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;
+            }
+        }
+    } 
+}

PepperDashEssentials/Bridges/JoinMaps/AirMediaControllerJoinMap.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class AirMediaControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Indicates that the device is online when high
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Indicates that the device is in session when high
+        /// </summary>
+        public uint IsInSession { get; set; }
+        /// <summary>
+        /// Indicates sync detected on HDMI input when high
+        /// </summary>
+        public uint HdmiVideoSync { get; set; }
+        /// <summary>
+        /// Set High to enable automatic input routing and low to disable.  Feedback high when enabled
+        /// </summary>
+        public uint AutomaticInputRoutingEnabled { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Selects source and provides feedback
+        /// </summary>
+        public uint VideoOut { get; set; }
+        /// <summary>
+        /// Provided error feedback
+        /// </summary>
+        public uint ErrorFB { get; set; }
+        /// <summary>
+        /// Indicates the number of connected users as feedback
+        /// </summary>
+        public uint NumberOfUsersConnectedFB { get; set; }
+        /// <summary>
+        /// Sets the login code and provides the current code as feedback
+        /// </summary>
+        public uint LoginCode { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Provides the name defined in config as feedback
+        /// </summary>
+        public uint Name { get; set; }
+        /// <summary>
+        /// Provides the connection address as feedback
+        /// </summary>
+        public uint ConnectionAddressFB { get; set; }
+        /// <summary>
+        /// Provides the hostname as feedback
+        /// </summary>
+        public uint HostnameFB { get; set; }
+        /// <summary>
+        /// Provides the serial number as feedback
+        /// </summary>
+        public uint SerialNumberFeedback { get; set; }
+        #endregion
+
+        public AirMediaControllerJoinMap()
+        {
+            // Digital
+            IsOnline = 1;
+            IsInSession = 2;
+            HdmiVideoSync = 3;
+            AutomaticInputRoutingEnabled = 4;
+
+            // Analog
+            VideoOut = 1;
+            ErrorFB = 2;
+            NumberOfUsersConnectedFB = 3;
+            LoginCode = 4;
+
+            // Serial
+            Name = 1;
+            ConnectionAddressFB = 2;
+            HostnameFB = 3;
+            SerialNumberFeedback = 4;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            IsInSession = IsInSession + joinOffset;
+            HdmiVideoSync = HdmiVideoSync + joinOffset;
+            AutomaticInputRoutingEnabled = AutomaticInputRoutingEnabled + joinOffset;
+
+            VideoOut = VideoOut + joinOffset;
+            ErrorFB = ErrorFB + joinOffset;
+            NumberOfUsersConnectedFB = NumberOfUsersConnectedFB + joinOffset;
+            LoginCode = LoginCode + joinOffset;
+
+            Name = Name + joinOffset;
+            ConnectionAddressFB = ConnectionAddressFB + joinOffset;
+            HostnameFB = HostnameFB + joinOffset;
+            SerialNumberFeedback = SerialNumberFeedback + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/AppleTvJoinMap.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class AppleTvJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Sends up arrow command while high
+        /// </summary>
+        public uint UpArrow { get; set; }
+        /// <summary>
+        /// Sends down arrow command while high
+        /// </summary>
+        public uint DnArrow { get; set; }
+        /// <summary>
+        /// Sends left arrow command while high
+        /// </summary>
+        public uint LeftArrow { get; set; }
+        /// <summary>
+        /// Sends right arrow command while high
+        /// </summary>
+        public uint RightArrow { get; set; }
+        /// <summary>
+        /// Sends menu command
+        /// </summary>
+        public uint Menu { get; set; }
+        /// <summary>
+        /// Sends select command
+        /// </summary>
+        public uint Select { get; set; }
+        /// <summary>
+        /// Sends play/pause command
+        /// </summary>
+        public uint PlayPause { get; set; }
+        #endregion
+
+        public AppleTvJoinMap()
+        {
+            UpArrow = 1;
+            DnArrow = 2;
+            LeftArrow = 3;
+            RightArrow = 4;
+            Menu = 5;
+            Select = 6;
+            PlayPause = 7;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            UpArrow = UpArrow + joinOffset;
+            DnArrow = DnArrow + joinOffset;
+            LeftArrow = LeftArrow + joinOffset;
+            RightArrow = RightArrow + joinOffset;
+            Menu = Menu + joinOffset;
+            Select = Select + joinOffset;
+            PlayPause = PlayPause + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/CameraControllerJoinMap.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    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/JoinMaps/DigitalLoggerJoinMap.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    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/JoinMaps/DisplayControllerJoinMap.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DisplayControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Turns the display off and reports power off feedback
+        /// </summary>
+        public uint PowerOff { get; set; }
+        /// <summary>
+        /// Turns the display on and repots power on feedback
+        /// </summary>
+        public uint PowerOn { get; set; }
+        /// <summary>
+        /// Indicates that the display device supports two way communication when high
+        /// </summary>
+        public uint IsTwoWayDisplay { get; set; }
+        /// <summary>
+        /// Increments the volume while high
+        /// </summary>
+        public uint VolumeUp { get; set; }
+        /// <summary>
+        /// Decrements teh volume while high
+        /// </summary>
+        public uint VolumeDown { get; set; }
+        /// <summary>
+        /// Toggles the mute state.  Feedback is high when volume is muted
+        /// </summary>
+        public uint VolumeMute { get; set; }
+        /// <summary>
+        /// Range of digital joins to select inputs and report current input as feedback
+        /// </summary>
+        public uint InputSelectOffset { get; set; }
+        /// <summary>
+        /// Range of digital joins to report visibility for input buttons
+        /// </summary>
+        public uint ButtonVisibilityOffset { get; set; }
+        /// <summary>
+        /// High if the device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Analog join to set the input and report current input as feedback
+        /// </summary>
+        public uint InputSelect { get; set; }
+        /// <summary>
+        /// Sets the volume level and reports the current level as feedback 
+        /// </summary>
+        public uint VolumeLevel { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Reports the name of the display as defined in config as feedback
+        /// </summary>
+        public uint Name { get; set; }
+        /// <summary>
+        /// Range of serial joins that reports the names of the inputs as feedback
+        /// </summary>
+        public uint InputNamesOffset { get; set; }
+        #endregion
+
+        public DisplayControllerJoinMap()
+        {
+            // Digital
+            IsOnline = 50;
+            PowerOff = 1;
+            PowerOn = 2;
+            IsTwoWayDisplay = 3;
+            VolumeUp = 5;
+            VolumeDown = 6;
+            VolumeMute = 7;
+
+            ButtonVisibilityOffset = 40;
+            InputSelectOffset = 10;
+
+            // Analog
+            InputSelect = 11;
+            VolumeLevel = 5;
+
+            // Serial
+            Name = 1;
+            InputNamesOffset = 10;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            PowerOff = PowerOff + joinOffset;
+            PowerOn = PowerOn + joinOffset;
+            IsTwoWayDisplay = IsTwoWayDisplay + joinOffset;
+            ButtonVisibilityOffset = ButtonVisibilityOffset + joinOffset;
+            Name = Name + joinOffset;
+            InputNamesOffset = InputNamesOffset + joinOffset;
+            InputSelectOffset = InputSelectOffset + joinOffset;
+
+            InputSelect = InputSelect + joinOffset;
+
+            VolumeUp = VolumeUp + joinOffset;
+            VolumeDown = VolumeDown + joinOffset;
+            VolumeMute = VolumeMute + joinOffset;
+            VolumeLevel = VolumeLevel + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmBladeChassisControllerJoinMap.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges {
+    public class DmBladeChassisControllerJoinMap : JoinMapBase {
+        #region Digital/Analogs
+        #endregion
+
+        #region Digitals
+        /// <summary>
+        /// High when device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Range reports video sync feedback for each input
+        /// </summary>
+        public uint VideoSyncStatus { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's endpoint is online
+        /// </summary>
+        public uint InputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding output's endpoint is online
+        /// </summary>
+        public uint OutputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's transmitter supports bridging as a separate device for detailed AV switching, HDCP control, etc.
+        /// </summary>
+        public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Range sets and reports the current video source for the corresponding output
+        /// </summary>
+        public uint OutputVideo { get; set; }
+        /// <summary>
+        /// Range sets and reports the current HDCP state for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportState { get; set; }
+        /// <summary>
+        /// Range reports the highest supported HDCP state level for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportCapability { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Range sets and reports the name for the corresponding input card
+        /// </summary>
+        public uint InputNames { get; set; }
+        /// <summary>
+        /// Range sets and reports the name for the corresponding output card
+        /// </summary>
+        public uint OutputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current video source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentVideoInputNames { get; set; }
+        /// <summary>
+        /// Range reports the current input resolution for each corresponding input card
+        /// </summary>
+        public uint InputCurrentResolution { get; set; }
+        #endregion
+
+        public DmBladeChassisControllerJoinMap() {
+            //Digital/Analog
+
+            //Digital 
+            IsOnline = 11;
+            VideoSyncStatus = 100; //101-299
+            InputEndpointOnline = 500; //501-699
+            OutputEndpointOnline = 700; //701-899
+            TxAdvancedIsPresent = 1000; //1001-1199
+
+            //Analog
+            OutputVideo = 100; //101-299
+            HdcpSupportState = 1000; //1001-1199
+            HdcpSupportCapability = 1200; //1201-1399
+
+
+            //Serial
+            InputNames = 100; //101-299
+            OutputNames = 300; //301-499
+            OutputCurrentVideoInputNames = 2000; //2001-2199
+            InputCurrentResolution = 2400; // 2401-2599
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart) {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            OutputVideo = OutputVideo + joinOffset;
+            VideoSyncStatus = VideoSyncStatus + joinOffset;
+            InputNames = InputNames + joinOffset;
+            OutputNames = OutputNames + joinOffset;
+            OutputCurrentVideoInputNames = OutputCurrentVideoInputNames + joinOffset;
+            InputCurrentResolution = InputCurrentResolution + joinOffset;
+            InputEndpointOnline = InputEndpointOnline + joinOffset;
+            OutputEndpointOnline = OutputEndpointOnline + joinOffset;
+            HdcpSupportState = HdcpSupportState + joinOffset;
+            HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmChassisControllerJoinMap.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DmChassisControllerJoinMap : JoinMapBase
+        {
+#region Digital/Analogs
+        /// <summary>
+        /// Analog input sets System ID, output reports current ID as feedback.
+        /// Digital input applies System ID, output is high when applying busy.
+        /// </summary>
+        public uint SystemId { get; set; }
+#endregion
+
+#region Digitals
+        /// <summary>
+        /// High when device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Range reports video sync feedback for each input
+        /// </summary>
+        public uint VideoSyncStatus { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's endpoint is online
+        /// </summary>
+        public uint InputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding output's endpoint is online
+        /// </summary>
+        public uint OutputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's transmitter supports bridging as a separate device for detailed AV switching, HDCP control, etc.
+        /// </summary>
+        public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+#endregion
+
+#region Analogs
+        /// <summary>
+        /// Range sets and reports the current video source for the corresponding output
+        /// </summary>
+        public uint OutputVideo { get; set; }
+        /// <summary>
+        /// Range sets and reports the current audio source for the corresponding output
+        /// </summary>
+        public uint OutputAudio { get; set; }
+        /// <summary>
+        /// Range sets and reports the current Usb source for the corresponding output
+        /// </summary>
+        public uint OutputUsb { get; set; }
+        /// <summary>
+        /// Range sets and reports the current Usb source for the corresponding input
+        /// </summary>
+        public uint InputUsb { get; set; }
+        /// <summary>
+        /// Range sets and reports the current HDCP state for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportState { get; set; }
+        /// <summary>
+        /// Range reports the highest supported HDCP state level for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportCapability { get; set; }
+#endregion
+
+#region Serials
+        /// <summary>
+        /// Range sets and reports the name for the corresponding input card
+        /// </summary>
+        public uint InputNames { get; set; }
+        /// <summary>
+        /// Range sets and reports the name for the corresponding output card
+        /// </summary>
+        public uint OutputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current video source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentVideoInputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current audio source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentAudioInputNames { get; set; }
+        /// <summary>
+        /// Range reports the current input resolution for each corresponding input card
+        /// </summary>
+        public uint InputCurrentResolution { get; set; }
+#endregion
+
+        public DmChassisControllerJoinMap()
+        {
+            //Digital/Analog
+            SystemId = 10; // Analog sets/gets SystemId, digital input applies and provides feedback of ID change busy
+
+            //Digital 
+            IsOnline = 11;
+            VideoSyncStatus = 100; //101-299
+            InputEndpointOnline = 500; //501-699
+            OutputEndpointOnline = 700; //701-899
+            TxAdvancedIsPresent = 1000; //1001-1199
+
+            //Analog
+            OutputVideo = 100; //101-299
+            OutputAudio = 300; //301-499
+            OutputUsb = 500; //501-699
+            InputUsb = 700; //701-899
+            HdcpSupportState = 1000; //1001-1199
+            HdcpSupportCapability = 1200; //1201-1399
+
+
+            //Serial
+            InputNames = 100; //101-299
+            OutputNames = 300; //301-499
+            OutputCurrentVideoInputNames = 2000; //2001-2199
+            OutputCurrentAudioInputNames = 2200; //2201-2399
+            InputCurrentResolution = 2400; // 2401-2599
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            SystemId = SystemId + joinOffset;
+            IsOnline = IsOnline + joinOffset;
+            OutputVideo = OutputVideo + joinOffset;
+            OutputAudio = OutputAudio + joinOffset;
+            OutputUsb = OutputUsb + joinOffset;
+            InputUsb = InputUsb + 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;
+            HdcpSupportState = HdcpSupportState + joinOffset;
+            HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmRmcControllerJoinMap.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DmRmcControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// High when device is online (if not attached to a DMP3 or DM chassis with a CPU3 card
+        /// </summary>
+        public uint IsOnline { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Reports the current output resolution
+        /// </summary>
+        public uint CurrentOutputResolution { get; set; }
+        /// <summary>
+        /// Reports the EDID manufacturer value
+        /// </summary>
+        public uint EdidManufacturer { get; set; }
+        /// <summary>
+        /// Reports the EDID Name value
+        /// </summary>
+        public uint EdidName { get; set; }
+        /// <summary>
+        /// Reports the EDID preffered timing value
+        /// </summary>
+        public uint EdidPrefferedTiming { get; set; }
+        /// <summary>
+        /// Reports the EDID serial number value
+        /// </summary>
+        public uint EdidSerialNumber { get; set; }
+        #endregion
+
+        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/JoinMaps/DmTxControllerJoinMap.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DmTxControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// High when device is online (if not attached to a DMP3 or DM chassis with a CPU3 card
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// High when video sync is detected
+        /// </summary>
+        public uint VideoSyncStatus { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Sets and reports the video source
+        /// </summary>
+        public uint VideoInput { get; set; }
+        /// <summary>
+        /// Sets and reports the audio source
+        /// </summary>
+        public uint AudioInput { get; set; }
+        /// <summary>
+        /// Reports the highest supported HDCP state level for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportCapability { get; set; }
+        /// <summary>
+        /// Sets and reports the current HDCP state for the corresponding input port
+        /// </summary>
+        public uint Port1HdcpState { get; set; }
+        /// <summary>
+        /// Sets and reports the current HDCP state for the corresponding input port
+        /// </summary>
+        public uint Port2HdcpState { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Reports the current input resolution
+        /// </summary>
+        public uint CurrentInputResolution { get; set; }
+        #endregion
+
+
+        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/JoinMaps/DmpsAudioOutputControllerJoinMap.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DmpsAudioOutputControllerJoinMap : JoinMapBase
+    {
+        #region Digital/Analog
+        /// <summary>
+        /// Range of joins for Master Volume 
+        /// Analog join 1 is volume level and feedback
+        /// Digital join 1 is Mute on and feedback
+        /// Digital join 2 is Mute off and feedback
+        /// Digital join 3 is volume up
+        /// Digital join 4 is volume down
+        /// </summary>
+        public uint MasterVolume { get; set; }
+        /// <summary>
+        /// Range of joins for Source Volume 
+        /// Analog join 11 is volume level and feedback
+        /// Digital join 11 is Mute on and feedback
+        /// Digital join 12 is Mute off and feedback
+        /// Digital join 13 is volume up
+        /// Digital join 14 is volume down
+        /// </summary>
+        public uint SourceVolume { get; set; }
+        /// <summary>
+        /// Range of joins for Codec1 Volume (if applicable)
+        /// Analog join 21 is volume level and feedback
+        /// Digital join 21 is Mute on and feedback
+        /// Digital join 22 is Mute off and feedback
+        /// Digital join 23 is volume up
+        /// Digital join 24 is volume down
+        /// </summary>
+        public uint Codec1Volume { get; set; }
+        /// <summary>
+        /// Range of joins for Codec2 Volume (if applicable)
+        /// Analog join 31 is volume level and feedback
+        /// Digital join 31 is Mute on and feedback
+        /// Digital join 32 is Mute off and feedback
+        /// Digital join 33 is volume up
+        /// Digital join 34 is volume down
+        /// </summary>
+        public uint Codec2Volume { get; set; }
+        #endregion
+
+        public DmpsAudioOutputControllerJoinMap()
+        {
+            MasterVolume = 1; // 1-10
+            SourceVolume = 11; // 11-20
+            Codec1Volume = 21; // 21-30
+            Codec2Volume = 31; // 31-40
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart;
+
+            MasterVolume = MasterVolume + joinOffset;
+            SourceVolume = SourceVolume + joinOffset;
+            Codec1Volume = Codec1Volume + joinOffset;
+            Codec2Volume = Codec2Volume + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmpsRoutingControllerJoinMap.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class DmpsRoutingControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Range reports video sync feedback for each input
+        /// </summary>
+        public uint VideoSyncStatus { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's endpoint is online
+        /// </summary>
+        public uint InputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding output's endpoint is online
+        /// </summary>
+        public uint OutputEndpointOnline { get; set; }       
+        #endregion
+
+
+        #region Analogs
+        /// <summary>
+        /// Range sets and reports the current video source for the corresponding output
+        /// </summary>
+        public uint OutputVideo { get; set; }
+        /// <summary>
+        /// Range sets and reports the current audio source for the corresponding output
+        /// </summary>
+        public uint OutputAudio { get; set; }
+        /// <summary>
+        /// Range sets and reports the current Usb source for the corresponding output
+        /// </summary>
+        //public uint OutputUsb { get; set; }
+        ///// <summary>
+        ///// Range sets and reports the current Usb source for the corresponding input
+        ///// </summary>
+        //public uint InputUsb { get; set; }
+        ///// <summary>
+        ///// Range sets and reports the current HDCP state for the corresponding input card
+        ///// </summary>
+        //public uint HdcpSupportState { get; set; }
+        ///// <summary>
+        ///// Range reports the highest supported HDCP state level for the corresponding input card
+        ///// </summary>
+        //public uint HdcpSupportCapability { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Range sets and reports the name for the corresponding input card
+        /// </summary>
+        public uint InputNames { get; set; }
+        /// <summary>
+        /// Range sets and reports the name for the corresponding output card
+        /// </summary>
+        public uint OutputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current video source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentVideoInputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current audio source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentAudioInputNames { get; set; }
+        /// <summary>
+        /// Range reports the current input resolution for each corresponding input card
+        /// </summary>
+        public uint InputCurrentResolution { get; set; }
+        #endregion
+
+
+        public DmpsRoutingControllerJoinMap()
+        {
+            //Digital 
+            VideoSyncStatus = 100; //101-299
+            InputEndpointOnline = 500; //501-699
+            OutputEndpointOnline = 700; //701-899
+
+            //Analog
+            OutputVideo = 100; //101-299
+            OutputAudio = 300; //301-499
+            //OutputUsb = 500; //501-699
+            //InputUsb = 700; //701-899
+            VideoSyncStatus = 100; //101-299
+            //HdcpSupportState = 1000; //1001-1199
+            //HdcpSupportCapability = 1200; //1201-1399
+
+
+            //Serial
+            InputNames = 100; //101-299
+            OutputNames = 300; //301-499
+            OutputCurrentVideoInputNames = 2000; //2001-2199
+            OutputCurrentAudioInputNames = 2200; //2201-2399
+            InputCurrentResolution = 2400; // 2401-2599
+            InputEndpointOnline = 500; //501-699
+            OutputEndpointOnline = 700; //701-899
+
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            OutputVideo = OutputVideo + joinOffset;
+            OutputAudio = OutputAudio + joinOffset;
+            //OutputUsb = OutputUsb + joinOffset;
+            //InputUsb = InputUsb + 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;
+            //HdcpSupportState = HdcpSupportState + joinOffset;
+            //HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/GenericLightingJoinMap.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+
+namespace PepperDash.Essentials.Bridges
+{
+    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/JoinMaps/GenericRelayControllerJoinMap.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class GenericRelayControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Sets and reports the state of the relay (High = closed, Low = Open)
+        /// </summary>
+        public uint Relay { get; set; }
+        #endregion
+
+        public GenericRelayControllerJoinMap()
+        {
+            Relay = 1;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            Relay = Relay + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class GlsOccupancySensorBaseJoinMap : JoinMapBase
+    {
+        #region Digitals
+
+        /// <summary>
+        /// High when device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Forces the device to report occupied status
+        /// </summary>
+        public uint ForceOccupied { get; set; }
+        /// <summary>
+        /// Forces the device to report vacant status
+        /// </summary>
+        public uint ForceVacant { get; set; }
+        /// <summary>
+        /// Enables raw status reporting
+        /// </summary>
+        public uint EnableRawStates { get; set; }
+        /// <summary>
+        /// High when raw occupancy is detected
+        /// </summary>
+        public uint RawOccupancyFeedback { get; set; }
+        /// <summary>
+        /// High when occupancy is detected
+        /// </summary>
+        public uint RoomOccupiedFeedback { get; set; }
+        /// <summary>
+        /// Hich when occupancy is detected in the grace period
+        /// </summary>
+        public uint GraceOccupancyDetectedFeedback { get; set; }
+        /// <summary>
+        /// High when vacancy is detected
+        /// </summary>
+        public uint RoomVacantFeedback { get; set; }
+
+        /// <summary>
+        /// Enables the LED Flash when set high
+        /// </summary>
+        public uint EnableLedFlash { get; set; }
+        /// <summary>
+        /// Disables the LED flash when set high
+        /// </summary>
+        public uint DisableLedFlash { get; set; }
+        /// <summary>
+        /// Enables the Short Timeout
+        /// </summary>
+        public uint EnableShortTimeout { get; set; }
+        /// <summary>
+        /// Disables the Short Timout
+        /// </summary>
+        public uint DisableShortTimeout { get; set; }
+        /// <summary>
+        /// Set high to enable one technology to trigger occupancy
+        /// </summary>
+        public uint OrWhenVacated { get; set; }
+        /// <summary>
+        /// Set high to require both technologies to trigger occupancy
+        /// </summary>
+        public uint AndWhenVacated { get; set; }
+        /// <summary>
+        /// Enables Ultrasonic Sensor A
+        /// </summary>
+        public uint EnableUsA { get; set; }
+        /// <summary>
+        /// Disables Ultrasonic Sensor A
+        /// </summary>
+        public uint DisableUsA { get; set; }
+        /// <summary>
+        /// Enables Ultrasonic Sensor B
+        /// </summary>
+        public uint EnableUsB { get; set; }
+        /// <summary>
+        /// Disables Ultrasonic Sensor B
+        /// </summary>
+        public uint DisableUsB { get; set; }
+        /// <summary>
+        /// Enables Pir
+        /// </summary>
+        public uint EnablePir { get; set; }
+        /// <summary>
+        /// Disables Pir
+        /// </summary>
+        public uint DisablePir { get; set; }
+        public uint IncrementUsInOccupiedState { get; set; }
+        public uint DecrementUsInOccupiedState { get; set; }
+        public uint IncrementUsInVacantState { get; set; }
+        public uint DecrementUsInVacantState { get; set; }
+        public uint IncrementPirInOccupiedState { get; set; }
+        public uint DecrementPirInOccupiedState { get; set; }
+        public uint IncrementPirInVacantState { get; set; }
+        public uint DecrementPirInVacantState { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Sets adn reports the remote timeout value
+        /// </summary>
+        public uint Timeout { get; set; }
+        /// <summary>
+        /// Reports the local timeout value
+        /// </summary>
+        public uint TimeoutLocalFeedback { get; set; }
+        /// <summary>
+        /// Sets the minimum internal photo sensor value and reports the current level
+        /// </summary>
+        public uint InternalPhotoSensorValue { get; set; }
+        /// <summary>
+        /// Sets the minimum external photo sensor value and reports the current level
+        /// </summary>
+        public uint ExternalPhotoSensorValue { get; set; }
+
+        public uint UsSensitivityInOccupiedState { get; set; }
+
+        public uint UsSensitivityInVacantState { get; set; }
+
+        public uint PirSensitivityInOccupiedState { get; set; }
+
+        public uint PirSensitivityInVacantState { get; set; }
+        #endregion
+
+        public GlsOccupancySensorBaseJoinMap()
+        {
+            IsOnline = 1;
+            ForceOccupied = 2;
+            ForceVacant = 3;
+            EnableRawStates = 4;
+            RoomOccupiedFeedback = 2;
+            GraceOccupancyDetectedFeedback = 3;
+            RoomVacantFeedback = 4;
+            RawOccupancyFeedback = 5;
+            EnableLedFlash = 11;
+            DisableLedFlash = 12;
+            EnableShortTimeout = 13;
+            DisableShortTimeout = 14;
+            OrWhenVacated = 15;
+            AndWhenVacated = 16;
+            EnableUsA = 17;
+            DisableUsA = 18;
+            EnableUsB = 19;
+            DisableUsB = 20;
+            EnablePir = 21;
+            DisablePir = 22;
+            DisablePir = 23;
+            IncrementUsInOccupiedState = 24;
+            DecrementUsInOccupiedState = 25;
+            IncrementUsInVacantState = 26;
+            DecrementUsInVacantState = 27;
+            IncrementPirInOccupiedState = 28;
+            DecrementPirInOccupiedState = 29;
+            IncrementPirInVacantState = 30;
+            DecrementPirInVacantState = 31;
+
+            Timeout = 1;
+            TimeoutLocalFeedback = 2;
+            InternalPhotoSensorValue = 3;
+            ExternalPhotoSensorValue = 4;
+            UsSensitivityInOccupiedState = 5;
+            UsSensitivityInVacantState = 6;
+            PirSensitivityInOccupiedState = 7;
+            PirSensitivityInVacantState = 8;           
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline =                          IsOnline + joinOffset; 
+            ForceOccupied =                     ForceOccupied + joinOffset; 
+            ForceVacant =                       ForceVacant + joinOffset; 
+            EnableRawStates =                   EnableRawStates + joinOffset; 
+            RoomOccupiedFeedback =              RoomOccupiedFeedback + joinOffset; 
+            GraceOccupancyDetectedFeedback =    GraceOccupancyDetectedFeedback + joinOffset;
+            RoomVacantFeedback =                RoomVacantFeedback + joinOffset; 
+            RawOccupancyFeedback =              RawOccupancyFeedback + joinOffset; 
+            EnableLedFlash =                    EnableLedFlash + joinOffset; 
+            DisableLedFlash =                   DisableLedFlash + joinOffset; 
+            EnableShortTimeout =                EnableShortTimeout + joinOffset; 
+            DisableShortTimeout =               DisableShortTimeout + joinOffset; 
+            OrWhenVacated =                     OrWhenVacated + joinOffset; 
+            AndWhenVacated =                    AndWhenVacated + joinOffset; 
+            EnableUsA =                         EnableUsA + joinOffset; 
+            DisableUsA =                        DisableUsA + joinOffset; 
+            EnableUsB =                         EnableUsB + joinOffset; 
+            DisableUsB =                        DisableUsB + joinOffset; 
+            EnablePir =                         EnablePir + joinOffset; 
+            DisablePir =                        DisablePir + joinOffset; 
+            DisablePir =                        DisablePir + joinOffset; 
+            IncrementUsInOccupiedState =        IncrementUsInOccupiedState + joinOffset; 
+            DecrementUsInOccupiedState =        DecrementUsInOccupiedState + joinOffset; 
+            IncrementUsInVacantState =          IncrementUsInVacantState + joinOffset; 
+            DecrementUsInVacantState =          DecrementUsInVacantState + joinOffset; 
+            IncrementPirInOccupiedState =       IncrementPirInOccupiedState + joinOffset;
+            DecrementPirInOccupiedState =       DecrementPirInOccupiedState + joinOffset;
+            IncrementPirInVacantState =         IncrementPirInVacantState + joinOffset; 
+            DecrementPirInVacantState =         DecrementPirInVacantState + joinOffset; 
+                                                
+            Timeout =                           Timeout + joinOffset; 
+            TimeoutLocalFeedback =              TimeoutLocalFeedback + joinOffset; 
+            InternalPhotoSensorValue =          InternalPhotoSensorValue + joinOffset; 
+            ExternalPhotoSensorValue =          ExternalPhotoSensorValue + joinOffset; 
+            UsSensitivityInOccupiedState =      UsSensitivityInOccupiedState + joinOffset;
+            UsSensitivityInVacantState =        UsSensitivityInVacantState + joinOffset; 
+            PirSensitivityInOccupiedState =     PirSensitivityInOccupiedState + joinOffset;
+            PirSensitivityInVacantState =       PirSensitivityInVacantState + joinOffset;
+        }
+    }    
+         
+}        

PepperDashEssentials/Bridges/JoinMaps/HdMdxxxCEControllerJoinMap.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class HdMdxxxCEControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// High when the pair is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+
+        /// <summary>
+        /// High when the remote end device is online
+        /// </summary>
+        public uint RemoteEndDetected { get; set; }
+
+        /// <summary>
+        /// Sets Auto Route On and provides feedback
+        /// </summary>
+        public uint AutoRouteOn { get; set; }
+
+        /// <summary>
+        /// Sets Auto Route Off and provides feedback
+        /// </summary>
+        public uint AutoRouteOff { get; set; }
+
+        /// <summary>
+        /// Sets Priority Routing On and provides feedback
+        /// </summary>
+        public uint PriorityRoutingOn { get; set; }
+
+        /// <summary>
+        /// Sets Priority Routing Off and provides feedback
+        /// </summary>
+        public uint PriorityRoutingOff { get; set; }
+
+        /// <summary>
+        /// Enables OSD and provides feedback
+        /// </summary>
+        public uint InputOnScreenDisplayEnabled { get; set; }
+
+        /// <summary>
+        /// Disables OSD and provides feedback
+        /// </summary>
+        public uint InputOnScreenDisplayDisabled { get; set; }
+
+        /// <summary>
+        /// Provides Video Sync Detected feedback for each input
+        /// </summary>
+        public uint SyncDetected { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Sets the video source for the receiver's HDMI out and provides feedback
+        /// </summary>
+        public uint VideoSource { get; set; }
+
+        /// <summary>
+        /// Indicates the number of sources supported by the Tx/Rx pair
+        /// </summary>
+        public uint SourceCount { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Indicates the name of each input port
+        /// </summary>
+        public uint SourceNames { get; set; }
+        #endregion
+
+        public HdMdxxxCEControllerJoinMap()
+        {
+            //Digital
+            IsOnline = 1;
+            RemoteEndDetected = 2;
+            AutoRouteOn = 3;
+            AutoRouteOff = 4;
+            PriorityRoutingOn = 5;
+            PriorityRoutingOff = 6;
+            InputOnScreenDisplayEnabled = 7;
+            InputOnScreenDisplayDisabled = 8;
+            SyncDetected = 10; // 11-15
+
+            //Analog
+            VideoSource = 1;
+            SourceCount = 2;
+
+            //Serials
+            SourceNames = 10; // 11-15
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            RemoteEndDetected = RemoteEndDetected + joinOffset;
+            AutoRouteOn = AutoRouteOn + joinOffset;
+            AutoRouteOff = AutoRouteOff + joinOffset;
+            PriorityRoutingOn = PriorityRoutingOn + joinOffset;
+            PriorityRoutingOff = PriorityRoutingOff + joinOffset;
+            InputOnScreenDisplayEnabled = InputOnScreenDisplayEnabled + joinOffset;
+            InputOnScreenDisplayDisabled = InputOnScreenDisplayDisabled + joinOffset;
+            SyncDetected = SyncDetected + joinOffset;
+
+            VideoSource = VideoSource + joinOffset;
+            SourceCount = SourceCount + joinOffset;
+
+            SourceNames = SourceNames + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/IBasicCommunicationJoinMap.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class IBasicCommunicationJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Set High to connect, Low to disconnect
+        /// </summary>
+        public uint Connect { get; set; }
+        /// <summary>
+        /// Reports Connected State (High = Connected)
+        /// </summary>
+        public uint Connected { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Reports the connections status value
+        /// </summary>
+        public uint Status { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Data back from port
+        /// </summary>
+        public uint TextReceived { get; set; }
+        /// <summary>
+        /// Sends data to the port
+        /// </summary>
+        public uint SendText { get; set; }
+        /// <summary>
+        /// Takes a JSON serialized string that sets a COM port's parameters
+        /// </summary>
+        public uint SetPortConfig { get; set; }
+        #endregion
+
+        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/JoinMaps/IDigitalInputJoinMap.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class IDigitalInputJoinMap : JoinMapBase
+    {
+        #region Digitals
+        /// <summary>
+        /// Reports the state of the digital input
+        /// </summary>
+        public uint InputState { get; set; }
+        #endregion
+
+        public IDigitalInputJoinMap()
+        {
+            InputState = 1;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            InputState = InputState + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/SystemMonitorJoinMap.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    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; }
+
+        #region Digitals
+        /// <summary>
+        /// Range Sets and reports whether the corresponding program slot is started
+        /// </summary>
+        public uint ProgramStart { get; set; }
+        /// <summary>
+        /// Range Sets and reports whether the corresponding program slot is stopped
+        /// </summary>
+        public uint ProgramStop { get; set; }
+        /// <summary>
+        /// Range Sets and reports whether the corresponding program is registered
+        /// </summary>
+        public uint ProgramRegister { get; set; }
+        /// <summary>
+        /// Range Sets and reports whether the corresponding program is unregistered
+        /// </summary>
+        public uint ProgramUnregister { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Sets and reports the time zone
+        /// </summary>
+        public uint TimeZone { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Reports the time zone name
+        /// </summary>
+        public uint TimeZoneName { get; set; }
+        /// <summary>
+        /// Reports the IO Controller Version
+        /// </summary>
+        public uint IOControllerVersion { get; set; }
+        /// <summary>
+        /// Reports the SNMP App Version
+        /// </summary>
+        public uint SnmpAppVersion { get; set; }
+        /// <summary>
+        /// Reports the BACnet App Version
+        /// </summary>
+        public uint BACnetAppVersion { get; set; }
+        /// <summary>
+        /// Reports the firmware version
+        /// </summary>
+        public uint ControllerVersion { get; set; }
+
+        /// <summary>
+        /// Reports the name of the corresponding program
+        /// </summary>
+        public uint ProgramName { get; set; }
+        /// <summary>
+        /// Reports the compile time of the corresponding program
+        /// </summary>
+        public uint ProgramCompiledTime { get; set; }
+        /// <summary>
+        /// Reports the Crestron Database version of the corresponding program
+        /// </summary>
+        public uint ProgramCrestronDatabaseVersion { get; set; }
+        /// <summary>
+        /// Reports the Environment Version of the corresponding program
+        /// </summary>
+        public uint ProgramEnvironmentVersion { get; set; }
+        /// <summary>
+        /// Serialized JSON output that aggregates the program info of the corresponding program
+        /// </summary>
+        public uint AggregatedProgramInfo { get; set; }
+        #endregion
+
+        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/Bridges/SystemMonitorBridge.cs

@@ -0,0 +1,68 @@
+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;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class SystemMonitorBridge
+    {
+        public static void LinkToApi(this SystemMonitorController systemMonitorController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            SystemMonitorJoinMap joinMap = new SystemMonitorJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if(!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<SystemMonitorJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+            Debug.Console(2, 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)
+            {
+                var programNumber = p.Value.Program.Number;
+
+                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;
+            }
+        }
+    }
+}

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/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/Configuration Original/Factories/MAYBE SetTopBoxFactory.cs

@@ -1,52 +0,0 @@
-//using System;
-//using Crestron.SimplSharpPro;
-
-//using Newtonsoft.Json.Linq;
-
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Devices;
-
-//using PepperDash.Core;
-
-//namespace PepperDash.Essentials
-//{
-//    public class SetTopBoxFactory
-//    {
-//        public static Device Create(JToken devToken)
-//        {
-//            Device dev = null;
-//            try
-//            {
-//                var devType = devToken.Value<string>("type");
-//                var devKey = devToken.Value<string>("key");
-//                var devName = devToken.Value<string>("name");
-//                var props = devToken["properties"];
-//                var portConfig = FactoryHelper.GetIrPort(props);
-//                if (portConfig != null)
-//                {
-//                    if (devType.EndsWith("-generic"))
-//                    {
-//                        var stb = new IrSetTopBoxBase(devKey, devName, portConfig.Port, portConfig.FileName);
-//                        // Do this a better way?
-//                        stb.HasDpad = props["hasDpad"].Value<bool>();
-//                        stb.HasDvr = props["hasDvr"].Value<bool>();
-//                        stb.HasNumbers = props["hasNumbers"].Value<bool>();
-//                        stb.HasPreset = props["hasPresets"].Value<bool>();
-//                        dev = stb;
-//                    }
-//                    else
-//                        FactoryHelper.HandleUnknownType(devToken, devType);
-
-//                    var preDev = dev as IHasSetTopBoxProperties;
-//                    if(preDev.HasPreset)
-//                        preDev.LoadPresets(props["presetListName"].Value<string>());					
-//                }			
-//            }
-//            catch (Exception e)
-//            {
-//                FactoryHelper.HandleDeviceCreationError(devToken, e);
-//            }
-//            return dev;
-//        }
-//    }
-//}

PepperDashEssentials/Configuration Original/Factories/REMOVE DiscPlayerFactory.cs

@@ -1,46 +0,0 @@
-//using System;
-//using Crestron.SimplSharpPro;
-
-//using Newtonsoft.Json.Linq;
-
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Devices;
-//using PepperDash.Core;
-
-//namespace PepperDash.Essentials
-//{
-//    public class DiscPlayerFactory
-//    {
-//        public static Device Create(JToken devToken)
-//        {
-//            Device dev = null;
-//            try
-//            {
-//                var devType = devToken.Value<string>("type");
-//                var devKey = devToken.Value<string>("key");
-//                var devName = devToken.Value<string>("name");
-
-//                // Filter out special (Pioneer
-//                //(devType.Equals("genericIr", StringComparison.OrdinalIgnoreCase))
-
-//                var props = devToken["properties"];
-//                var portConfig = FactoryHelper.GetIrPort(props);
-//                if (portConfig != null)
-//                {
-//                    if (devType.EndsWith("-generic"))
-//                        dev = new IrDvdBase(devKey, devName, portConfig.Port, portConfig.FileName);
-//                    else
-//                        FactoryHelper.HandleUnknownType(devToken, devType);
-//                }	
-
-//                // NO PORT ERROR HERE??
-
-//            }
-//            catch (Exception e)
-//            {
-//                FactoryHelper.HandleDeviceCreationError(devToken, e);
-//            }
-//            return dev;
-//        }
-//    }
-//}

PepperDashEssentials/ControlSystem.cs

@@ -1,39 +1,56 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.CrestronThread;
+using Crestron.SimplSharpPro.Diagnostics;
+using Crestron.SimplSharp.Reflection;
+
 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.Cotija;
+using PepperDash.Essentials.Room.Config;
+using PepperDash.Essentials.Room.MobileControl;
+
+using Newtonsoft.Json;
 
 namespace PepperDash.Essentials
 {
-	public class ControlSystem : CrestronControlSystem
-	{
+    public class ControlSystem : CrestronControlSystem
+    {
         HttpLogoServer LogoServer;
 
-		public ControlSystem()
-			: base()
-		{
-			Thread.MaxNumberOfUserThreads = 400;
-			Global.ControlSystem = this;
-			DeviceManager.Initialize(this);        
-		}
+        public ControlSystem()
+            : base()
+        {
+            Thread.MaxNumberOfUserThreads = 400;
+            Global.ControlSystem = this;
+            DeviceManager.Initialize(this);
+        }
 
-		/// <summary>
-		/// Git 'er goin'
-		/// </summary>
-		public override void InitializeSystem()
-		{
+        /// <summary>
+        /// Entry point for the program
+        /// </summary>
+        public override void InitializeSystem()
+        {
             DeterminePlatform();
 
-            //CrestronConsole.AddNewConsoleCommand(s => GoWithLoad(), "go", "Loads configuration file",
-            //    ConsoleAccessLevelEnum.AccessOperator);
+            if (Debug.DoNotLoadOnNextBoot)
+            {
+                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);
+            }, "appdebugmessage", "Writes message to log", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
             {
@@ -42,139 +59,284 @@ namespace PepperDash.Essentials
             },
             "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
+                    ("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);
+            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();
-		}
+            if (!Debug.DoNotLoadOnNextBoot)
+                GoWithLoad();
+        }
 
         /// <summary>
-        /// Determines if the program is running on a processor (appliance) or server (XiO Edge).
+        /// Determines if the program is running on a processor (appliance) or server (VC-4).
         /// 
         /// 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();
-
-            //directoryPrefix = "";
-
-            if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)
+            try
             {
-                filePathPrefix = directoryPrefix + dirSeparator + "NVRAM" 
-                    + dirSeparator + string.Format("program{0}", InitialParametersClass.ApplicationNumber) + dirSeparator;
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Determining Platform....");
 
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", versionString);
+                string filePathPrefix;
+
+                var dirSeparator = Global.DirectorySeparator;
+
+                string directoryPrefix;
+
+                directoryPrefix = Crestron.SimplSharp.CrestronIO.Directory.GetApplicationRootDirectory();
+
+                var version = Crestron.SimplSharp.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+
+                Global.SetAssemblyVersion(string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build));
+
+                if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)   // Handles 3-series running Windows CE OS
+                {
+                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", Global.AssemblyVersion);
+
+                    // 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", Global.AssemblyVersion);
+
+                    // Set path to User/
+                    filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
+                }
+
+                Global.SetFilePathPrefix(filePathPrefix);
             }
-            else
+            catch (Exception e)
             {
-                filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
-
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on XiO Edge Server", versionString);
+                Debug.Console(0, "Unable to Determine Platform due to Exception: {0}", e.Message);
             }
-
-            Global.SetFilePathPrefix(filePathPrefix);
         }
 
-		/// <summary>
-		/// Do it, yo
-		/// </summary>
-		public void GoWithLoad()
-		{
-			try
-			{
-                CrestronConsole.AddNewConsoleCommand(EnablePortalSync, "portalsync", "Loads Portal Sync",
-                    ConsoleAccessLevelEnum.AccessOperator);
+        /// <summary>
+        /// Begins the process of loading resources including plugins and configuration data
+        /// </summary>
+        public void GoWithLoad()
+        {
+            try
+            {
+                Debug.SetDoNotLoadOnNextBoot(false);
 
-                //PortalSync = new PepperDashPortalSyncClient();
                 Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials load from configuration");
 
-				var filesReady = SetupFilesystem();
-				if (filesReady)
-				{
+                var filesReady = SetupFilesystem();
+                if (filesReady)
+                {
+                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Checking for plugins");
+                    LoadPlugins();
+
                     Debug.Console(0, Debug.ErrorLogLevel.Notice, "Folder structure verified. Loading config...");
-					if (!ConfigReader.LoadConfig2())
-						return;
+                    if (!ConfigReader.LoadConfig2())
+                        return;
 
-					Load();
+                    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" +
-						"------------------------------------------------");
-				}
+                        "-------------------------------------------------------------");
+                }
+                else
+                {
+                    Debug.Console(0,
+                        @"----------------------------------------------
+                        ------------------------------------------------
+                        ------------------------------------------------
+                        Essentials file structure setup completed.
+                        Please load config, sgd and ir files and
+                        restart program.
+                        ------------------------------------------------
+                        ------------------------------------------------
+                        ------------------------------------------------");
+                }
+
+            }
+            catch (Exception e)
+            {
+                Debug.Console(0, "FATAL INITIALIZE ERROR. System is in an inconsistent state:\r{0}", e);
             }
-			catch (Exception e)
-			{
-				Debug.Console(0, "FATAL INITIALIZE ERROR. System is in an inconsistent state:\r{0}", e);
-			}
 
-		}
+            // Notify the OS that the program intitialization has completed
+            SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
 
-		/// <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);
+        /// <summary>
+        /// Initial simple implementation.  Reads user/programXX/plugins folder and 
+        /// use
+        /// </summary>
+        void LoadPlugins()
+        {
+            var dir = Global.FilePathPrefix + "plugins";
+            if (Directory.Exists(dir))
+            {
+                // TODO Clear out or create localPlugins folder (maybe in program slot folder)
+
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Plugins directory found, checking for factory plugins");
+                var di = new DirectoryInfo(dir);
+                var zFiles = di.GetFiles("*.cplz");
+                foreach (var fi in zFiles)
+                {
+                    Debug.Console(0, "Found cplz: {0}. Unzipping into plugins directory", fi.Name);
+                    var result = CrestronZIP.Unzip(fi.FullName, di.FullName);
+                    Debug.Console(0, "UnZip Result: {0}", result.ToString());
+                    fi.Delete();
+                }
+                var files = di.GetFiles("*.dll");
+                Dictionary<string, Assembly> assyList = new Dictionary<string, Assembly>();
+                foreach (FileInfo fi in files)
+                {
+                    // TODO COPY plugin to loadedPlugins folder 
+                    // TODO LOAD that loadedPlugins dll file
+                    try
+                    {
+                        var assy = Assembly.LoadFrom(fi.FullName);
+                        var ver = assy.GetName().Version;
+                        var verStr = string.Format("{0}.{1}.{2}.{3}", ver.Major, ver.Minor, ver.Build, ver.Revision);
+                        assyList.Add(fi.FullName, assy);
+                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Loaded plugin file '{0}', version {1}", fi.FullName, verStr);
+                    }
+                    catch
+                    {
+                        Debug.Console(2, "Assembly {0} is not a custom assembly", fi.FullName);
+                        continue; //catching any load issues and continuing. There will be exceptions loading Crestron .dlls from the cplz Probably should do something different here
+                    }
+                }
+                foreach (var assy in assyList)
+                {
+                    // iteratate this assembly's classes, looking for "LoadPlugin()" methods
+                    try
+                    {
+                        var types = assy.Value.GetTypes();
+                        foreach (var type in types)
+                        {
+                            try
+                            {
+                                var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Static);
+                                var loadPlugin = methods.FirstOrDefault(m => m.Name.Equals("LoadPlugin"));
+                                if (loadPlugin != null)
+                                {
+                                    Debug.Console(2, "LoadPlugin method found in {0}", type.Name);
+
+                                    var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
+
+                                    var minimumVersion = fields.FirstOrDefault(p => p.Name.Equals("MinimumEssentialsFrameworkVersion"));
+                                    if (minimumVersion != null)
+                                    {
+                                        Debug.Console(2, "MinimumEssentialsFrameworkVersion found");
+
+                                        var minimumVersionString = minimumVersion.GetValue(null) as string;
+
+                                        if (!string.IsNullOrEmpty(minimumVersionString))
+                                        {
+                                            var passed = Global.IsRunningMinimumVersionOrHigher(minimumVersionString);
+
+                                            if (!passed)
+                                            {
+                                                Debug.Console(0, Debug.ErrorLogLevel.Error, "Plugin indicates minimum Essentials version {0}.  Dependency check failed.  Skipping Plugin", minimumVersionString);
+                                                continue;
+                                            }
+                                            else
+                                            {
+                                                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Passed plugin passed dependency check (required version {0})", minimumVersionString);
+                                            }
+                                        }
+                                        else
+                                        {
+                                            Debug.Console(0, Debug.ErrorLogLevel.Warning, "MinimumEssentialsFrameworkVersion found but not set.  Loading plugin, but your mileage may vary.");
+                                        }
+                                    }
+                                    else
+                                    {
+                                        Debug.Console(0, Debug.ErrorLogLevel.Warning, "MinimumEssentialsFrameworkVersion not found.  Loading plugin, but your mileage may vary.");
+                                    }
+
+                                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Adding plugin: {0}", assy.Key);
+                                    loadPlugin.Invoke(null, null);
+                                }
+                            }
+                            catch
+                            {
+                                Debug.Console(2, "Load Plugin not found. {0} is not a plugin assembly", assy.Value.FullName);
+                                continue;
+                            }
+
+                        }
+                    }
+                    catch
+                    {
+                        Debug.Console(2, "Assembly {0} is not a custom assembly. Types cannot be loaded.", assy.Value.FullName);
+                        continue;
+                    }
+                }
+                // plugin dll will be loaded.  Any classes in plugin should have a static constructor
+                // that registers that class with the Core.DeviceFactory
+            }
+        }
+
+        /// <summary>
+        /// Verifies filesystem is set up. IR, SGD, and programX 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);
 
+            var pluginDir = Global.FilePathPrefix + "plugins";
+            if (!Directory.Exists(pluginDir))
+                Directory.Create(pluginDir);
+
 			return configExists;
 		}
 
-        public void EnablePortalSync(string s)
-        {
-            if (s.ToLower() == "enable")
-            {
-                CrestronConsole.ConsoleCommandResponse("Portal Sync features enabled");
-            }
-        }
-
+		/// <summary>
+		/// 
+		/// </summary>
 		public void TearDown()
 		{
 			Debug.Console(0, "Tearing down existing system");
@@ -199,24 +361,50 @@ 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 MobileControlSystemController;
 
 
-		/// <summary>
-		/// Reads all devices from config and adds them to DeviceManager
-		/// </summary>
-		public void LoadDevices()
-		{
+            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
+
             DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
 
-			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
+
+            // Add global System Monitor device
+            DeviceManager.AddDevice(new PepperDash.Essentials.Core.Monitoring.SystemMonitorController("systemMonitor"));
+
+            foreach (var devConf in ConfigReader.ConfigObject.Devices)
+            {
+
+                try
+                {
+                    Debug.Console(0, Debug.ErrorLogLevel.Notice, "Creating device '{0}', type '{1}'", devConf.Key, devConf.Type);
+                    // Skip this to prevent unnecessary warnings
                     if (devConf.Key == "processor")
                     {
                         if (devConf.Type.ToLower() != Global.ControlSystem.ControllerPrompt.ToLower())
@@ -224,13 +412,37 @@ namespace PepperDash.Essentials
                                 "WARNING: Config file defines processor type as '{0}' but actual processor is '{1}'!  Some ports may not be available",
                                 devConf.Type.ToUpper(), Global.ControlSystem.ControllerPrompt.ToUpper());
 
+                        // Check if the processor is a DMPS model
+                        if (this.ControllerPrompt.IndexOf("dmps", StringComparison.OrdinalIgnoreCase) > -1)
+                        {
+                            Debug.Console(2, "Adding DmpsRoutingController for {0} to Device Manager.", this.ControllerPrompt);
+
+                            var propertiesConfig = JsonConvert.DeserializeObject<DM.Config.DmpsRoutingPropertiesConfig>(devConf.Properties.ToString());
+
+                            if(propertiesConfig == null)
+                                propertiesConfig =  new DM.Config.DmpsRoutingPropertiesConfig();
+
+                            var dmpsRoutingController = DmpsRoutingController.GetDmpsRoutingController("processor-avRouting", this.ControllerPrompt, propertiesConfig);
+
+                            DeviceManager.AddDevice(dmpsRoutingController);
+                        }
+                        else
+                        {
+                            Debug.Console(2, "************Processor is not DMPS type***************");
+                        }
+
                         continue;
                     }
 
-					// Try local factory first
-					var newDev = DeviceFactory.GetDevice(devConf);
+                    // Try local factories first
+                    var newDev = DeviceFactory.GetDevice(devConf);
 
-					// Then associated library factories
+                    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)
@@ -238,77 +450,91 @@ namespace PepperDash.Essentials
 					if (newDev == null)
 						newDev = PepperDash.Essentials.Devices.Displays.DisplayDeviceFactory.GetDevice(devConf);
 
+					//if (newDev == null) // might want to consider the ability to override an essentials "type"
+					//{
+					//    // iterate plugin factories
+					//    foreach (var f in FactoryObjects)
+					//    {
+					//        var cresFactory = f as IGetCrestronDevice;
+					//        if (cresFactory != null)
+					//        {
+					//            newDev = cresFactory.GetDevice(devConf, this);
+					//        }
+					//    }
+					//}
+
 					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)
-				{
+                }
+                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;
-			}
+        /// <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
 
-			foreach (var tieLineConfig in ConfigReader.ConfigObject.TieLines)
-			{
-				var newTL = tieLineConfig.GetTieLine();
-				if (newTL != null)
-					tlc.Add(newTL);
-			}
+            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;
-			}
+        /// <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)
-				{
+            foreach (var roomConfig in ConfigReader.ConfigObject.Rooms)
+            {
+                var room = EssentialsRoomConfigHelper.GetRoomObject(roomConfig) as EssentialsRoomBase;
+                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));
+                        DeviceManager.AddDevice(new Core.Fusion.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, "Attempting to build Mobile Control Bridge...");
+                        // Mobile Control bridge
+                        var bridge = new MobileConrolEssentialsHuddleSpaceRoomBridge(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...");
+                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Mobile Control Bridge Added...");
                     }
                     else if (room is EssentialsHuddleVtc1Room)
                     {
@@ -316,54 +542,61 @@ namespace PepperDash.Essentials
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion");
                         DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((EssentialsHuddleVtc1Room)room, 0xf1));
-                    }					
+
+                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Mobile Control Bridge...");
+                        // Mobile Control bridge
+                        var bridge = new MobileConrolEssentialsHuddleSpaceRoomBridge(room);
+                        AddBridgePostActivationHelper(bridge); // Lets things happen later when all devices are present
+                        DeviceManager.AddDevice(bridge);
+                    }
                     else
                     {
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is NOT EssentialsHuddleSpaceRoom, attempting to add to DeviceManager w/o Fusion");
+                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is NOT EssentialsRoom, attempting to add to DeviceManager w/o Fusion");
                         DeviceManager.AddDevice(room);
                     }
 
-				}
-				else
+                }
+                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>
+        /// Helps add the post activation steps that link bridges to main controller
+        /// </summary>
+        /// <param name="bridge"></param>
+        void AddBridgePostActivationHelper(MobileControlBridgeBase bridge)
+        {
+            bridge.AddPostActivationAction(() =>
+            {
+                var parent = DeviceManager.AllDevices.FirstOrDefault(d => d.Key == "appServer") as MobileControlSystemController;
+                if (parent == null)
+                {
+                    Debug.Console(0, bridge, "ERROR: Cannot connect app server room bridge. System controller not present");
+                    return;
+                }
+                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
-			{
+        /// <summary>
+        /// Fires up a logo server if not already running
+        /// </summary>
+        void LoadLogoServer()
+        {
+            try
+            {
                 LogoServer = new HttpLogoServer(8080, Global.DirectorySeparator + "html" + Global.DirectorySeparator + "logo");
             }
-			catch (Exception)
-			{
-				Debug.Console(0, Debug.ErrorLogLevel.Notice, "NOTICE: Logo server cannot be started. Likely already running in another program");
-			}
-		}
-	}
+            catch (Exception)
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "NOTICE: Logo server cannot be started. Likely already running in another program");
+            }
+        }
+    }
 }

PepperDashEssentials/Devices/Amplifier.cs

@@ -12,6 +12,32 @@ namespace PepperDash.Essentials
 {
     public class Amplifier : Device, IRoutingSinkNoSwitching
     {
+        public event SourceInfoChangeHandler CurrentSourceChange;
+
+        public string CurrentSourceInfoKey { get; set; }
+        public SourceListItem CurrentSourceInfo
+        {
+            get
+            {
+                return _CurrentSourceInfo;
+            }
+            set
+            {
+                if (value == _CurrentSourceInfo) return;
+
+                var handler = CurrentSourceChange;
+
+                if (handler != null)
+                    handler(_CurrentSourceInfo, ChangeType.WillChange);
+
+                _CurrentSourceInfo = value;
+
+                if (handler != null)
+                    handler(_CurrentSourceInfo, ChangeType.DidChange);
+            }
+        }
+        SourceListItem _CurrentSourceInfo;
+
         public RoutingInputPort AudioIn { get; private set; }
 
         public Amplifier(string key, string name)

PepperDashEssentials/Devices/DiscPlayer/OppoExtendedBdp.cs

@@ -1,42 +0,0 @@
-using System;
-using System.Linq;
-using System.Collections.Generic;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-
-using PepperDash.Essentials.Core;
-
-namespace PepperDash.Essentials.Devices
-{
-	///// <summary>
-	///// This DVD class should cover most IR, one-way DVD and Bluray fuctions
-	///// </summary>
-	//public class OppoBluray : IrDvdBase, IDvdControls, IExtendedOutputs
-	//{
-	//    public OppoBluray(string key, string name, IROutputPort port, string irDriverFilepath) : base(key, name, port, irDriverFilepath) { }
-
-
-
-	//    public OutputsToTriListBridge GetExtendedOutputsToTriListBridge()
-	//    {
-	//        return new ExtendedDvdTriListBridge();
-	//    }
-
-
-	//}
-
-	//public class ExtendedDvdTriListBridge : OutputsToTriListBridge
-	//{
-
-	//    public override void Link()
-	//    {
-	//        throw new NotImplementedException();
-	//    }
-
-	//    public override void UnLink()
-	//    {
-	//        throw new NotImplementedException();
-	//    }
-	//}
-}

PepperDashEssentials/Devices/NUMERIC AppleTV.cs

@@ -1,45 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-//using PepperDash.Essentials.Core;
-
-//namespace PepperDash.Essentials.Devices
-//{
-//    public class AppleTV : Device, IHasCueActionList
-//    {
-//        public IrOutputPortController IrPort { get; private set; }
-
-//        public AppleTV(string key, string name, IROutputPort port, string irDriverFilepath)
-//            : base(key, name) 
-//        {
-//            IrPort = new IrOutputPortController("ir" + key, port, irDriverFilepath);
-//        }
-
-//        #region IFunctionList Members
-//        public List<CueActionPair> CueActionList
-//        {
-//            get 
-//            {
-//                var numToIr = new Dictionary<Cue, string>
-//                {
-//                    { CommonBoolCue.Menu, IROutputStandardCommands.IROut_MENU },
-//                    { CommonBoolCue.Up, IROutputStandardCommands.IROut_UP_ARROW },
-//                    { CommonBoolCue.Down, IROutputStandardCommands.IROut_DN_ARROW },
-//                    { CommonBoolCue.Left, IROutputStandardCommands.IROut_LEFT_ARROW },
-//                    { CommonBoolCue.Right, IROutputStandardCommands.IROut_RIGHT_ARROW },
-//                    { CommonBoolCue.Select, IROutputStandardCommands.IROut_ENTER }
-//                };
-//                var funcs = new List<CueActionPair>(numToIr.Count);
-
-//                foreach (var kvp in numToIr)
-//                    funcs.Add(new BoolCueActionPair(kvp.Key, b => IrPort.PressRelease(kvp.Value, b)));
-//                return funcs;
-//            }
-//        }
-//        #endregion
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/PageControllers/DevicePageControllerBase.cs

@@ -1,47 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-//using PepperDash.Core;
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Core.Presets;
-
-//namespace PepperDash.Essentials
-//{
-//    /// <summary>
-//    /// 
-//    /// </summary>
-//    public abstract class DevicePageControllerBase
-//    {
-
-//        protected BasicTriListWithSmartObject TriList;
-//        protected List<BoolInputSig> FixedObjectSigs;
-
-//        public DevicePageControllerBase(BasicTriListWithSmartObject triList)
-//        {
-//            TriList = triList;
-//        }
-
-//        public void SetVisible(bool state)
-//        {
-//            foreach (var sig in FixedObjectSigs)
-//            {
-//                Debug.Console(2, "set visible {0}={1}", sig.Number, state);
-//                sig.BoolValue = state;
-//            }
-//            CustomSetVisible(state);
-//        }
-
-//        /// <summary>
-//        /// Add any specialized show/hide logic here - beyond FixedObjectSigs. Overriding
-//        /// methods do not need to call this base method
-//        /// </summary>
-//        protected virtual void CustomSetVisible(bool state)
-//        {
-//        }
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/PageControllers/LargeTouchpanelControllerBase.cs

@@ -1,308 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-//using Crestron.SimplSharpPro.UI;
-
-//using PepperDash.Core;
-
-
-//namespace PepperDash.Essentials.Core
-//{
-//    /// <summary>
-//    /// 
-//    /// </summary>
-//    public class LargeTouchpanelControllerBase : SmartGraphicsTouchpanelControllerBase
-//    {
-//        public string PresentationShareButtonInVideoText = "Share";
-//        public string PresentationShareButtonNotInVideoText = "Presentation";
-
-//        SourceListSubpageReferenceList SourceSelectSRL;
-//        DevicePageControllerBase CurrentPresentationSourcePageController;
-
-//        public LargeTouchpanelControllerBase(string key, string name,
-//            BasicTriListWithSmartObject triList, string sgdFilePath)
-//            : base(key, name, triList, sgdFilePath)
-//        {
-//        }
-
-//        /// <summary>
-//        /// Static factory method
-//        /// </summary>
-//        public static LargeTouchpanelControllerBase GetController(string key, string name,
-//            string type, CrestronTswPropertiesConfig props)
-//        {
-//            var id = Convert.ToUInt32(props.IpId, 16);
-//            type = type.ToLower();
-//            Tswx52ButtonVoiceControl tsw = null;
-//            if (type == "tsw752")
-//                tsw = new Tsw752(id, Global.ControlSystem);
-//            else if (type == "tsw1052")
-//                tsw = new Tsw1052(id, Global.ControlSystem);
-//            else
-//            {
-//                Debug.Console(0, "WARNING: Cannot create TSW controller with type '{0}'", type);
-//                return null;
-//            }
-
-//            var sgdPath = string.Format(@"\NVRAM\Program{0}\SGD\{1}", 
-//                InitialParametersClass.ApplicationNumber, props.SgdFile);
-//            var controller = new LargeTouchpanelControllerBase(key, name, tsw, sgdPath);
-//            controller.UsesSplashPage = props.UsesSplashPage;
-			
-//            // Get the room and add it after everthing is ready
-//            var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey) as EssentialsRoom;
-//            controller.AddPostActivationAction(() =>
-//                {
-//                    controller.SetCurrentRoom(room);
-
-//                });
-
-//            return controller;
-//        }
-
-//        public override bool CustomActivate()
-//        {
-//            var baseSuccess = base.CustomActivate();
-//            if (!baseSuccess) return false;
-
-//            SourceSelectSRL = new SourceListSubpageReferenceList(this.TriList, n =>
-//                { if (CurrentRoom != null) CurrentRoom.SelectSource(n); });
-
-//            var lm = Global.LicenseManager;
-//            if (lm != null)
-//            {
-//                lm.LicenseIsValid.LinkInputSig(TriList.BooleanInput[UiCue.ShowLicensed.Number]);
-//                //others
-//            }
-
-//            // Wire up buttons
-//            TriList.SetSigFalseAction(15003, () => SetMainMode(eMainModeType.Presentation));
-//            TriList.SetSigFalseAction(15008, PowerOffWithConfirmPressed);
-//            TriList.SetSigFalseAction(15101, () => SetMainMode(eMainModeType.Presentation));
-//            TriList.SetSigFalseAction(15013, ShowHelp);
-//            TriList.SetSigFalseAction(15014, () => SetMainMode(eMainModeType.Tech));
-
-//            // Temp things -----------------------------------------------------------------------
-//            TriList.StringInput[UiCue.SplashMessage.Number].StringValue = SplashMessage;
-//            //------------------------------------------------------------------------------------
-
-//            // Initialize initial view
-//            ShowSplashOrMain();
-//            return true;
-//        }
-
-//        /// <summary>
-//        /// In Essentials, this should NEVER be called, since it's a one-room solution
-//        /// </summary>
-//        protected override void HideRoomUI()
-//        {
-//            // UI Cleanup here????
-
-//            //SwapAudioDeviceControls(CurrentRoom.CurrentAudioDevice, null);
-//            //CurrentRoom.AudioDeviceWillChange -= CurrentRoom_AudioDeviceWillChange;
-
-//            CurrentRoom.IsCoolingDownFeedback.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
-//            CurrentRoom.IsWarmingUpFeedback.OutputChange -= CurrentRoom_IsWarmingUp_OutputChange;
-
-//            SourceSelectSRL.DetachFromCurrentRoom();
-//        }
-
-//        /// <summary>
-//        /// Ties this panel controller to the Room and gets updates.
-//        /// </summary>
-//        protected override void ShowRoomUI()
-//        {
-//            Debug.Console(1, this, "connecting to system '{0}'", CurrentRoom.Key);
-
-//            TriList.StringInput[RoomCue.Name.Number].StringValue = CurrentRoom.Name;
-//            TriList.StringInput[RoomCue.Description.Number].StringValue = CurrentRoom.Description;
-
-//            CurrentRoom.IsCoolingDownFeedback.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
-//            CurrentRoom.IsWarmingUpFeedback.OutputChange -= CurrentRoom_IsWarmingUp_OutputChange;
-//            CurrentRoom.IsCoolingDownFeedback.OutputChange += CurrentRoom_IsCoolingDown_OutputChange;
-//            CurrentRoom.IsWarmingUpFeedback.OutputChange += CurrentRoom_IsWarmingUp_OutputChange;
-
-//            SourceSelectSRL.AttachToRoom(CurrentRoom);
-//        }
-
-//        void CurrentRoom_IsCoolingDown_OutputChange(object sender, EventArgs e)
-//        {
-//            Debug.Console(2, this, "Received room in cooldown={0}", CurrentRoom.IsCoolingDownFeedback.BoolValue);
-//            if (CurrentRoom.IsCoolingDownFeedback.BoolValue) // When entering cooldown
-//            {
-//                // Do we need to check for an already-running cooldown - like in the case of room switches?
-//                new ModalDialog(TriList).PresentModalTimerDialog(0, "Power Off", "Power", "Please wait, shutting down",
-//                    "", "", CurrentRoom.CooldownTime, true, b =>
-//                    {
-//                        ShowSplashOrMain();
-//                    });
-//            }
-//        }
-
-//        void CurrentRoom_IsWarmingUp_OutputChange(object sender, EventArgs e)
-//        {
-//            Debug.Console(2, this, "Received room in warmup={0}", CurrentRoom.IsWarmingUpFeedback.BoolValue);
-//            if (CurrentRoom.IsWarmingUpFeedback.BoolValue) // When entering warmup
-//            {
-//                // Do we need to check for an already-running cooldown - like in the case of room switches?
-//                new ModalDialog(TriList).PresentModalTimerDialog(0, "Power On", "Power", "Please wait, powering on",
-//                    "", "", CurrentRoom.WarmupTime, false, b =>
-//                    {
-//                        // Reveal sources - or has already been done behind modal
-//                    });
-//            }
-//        }
-
-//        // Handler for source change events.
-//        void CurrentRoom_PresentationSourceChange(object sender, EssentialsRoomSourceChangeEventArgs args)
-//        {
-//            // Put away the old source and set up the new source.
-//            Debug.Console(2, this, "Received source change={0}", args.NewSource != null ? args.NewSource.SourceKey : "none");
-
-//            // If we're in tech, don't switch screen modes.  Add any other modes we may want to switch away from
-//            // inside the if below.
-//            if (MainMode == eMainModeType.Splash)
-//                SetMainMode(eMainModeType.Presentation);
-//            SetControlSource(args.NewSource);
-//        }
-
-//        //***********************************************************************
-//        //** UI Manipulation
-//        //***********************************************************************
-
-//        /// <summary>
-//        /// Shows the splash page or the main presentation page, depending on config setting
-//        /// </summary>
-//        void ShowSplashOrMain()
-//        {
-//            if (UsesSplashPage)
-//                SetMainMode(eMainModeType.Splash);
-//            else
-//                SetMainMode(eMainModeType.Presentation);
-//        }
-
-//        /// <summary>
-//        /// Switches between main modes
-//        /// </summary>
-//        void SetMainMode(eMainModeType mode)
-//        {
-//            MainMode = mode;
-//            switch (mode)
-//            {
-//                case eMainModeType.Presentation:
-//                    TriList.BooleanInput[UiCue.VisibleCommonFooter.Number].BoolValue = true;
-//                    TriList.BooleanInput[UiCue.VisibleCommonHeader.Number].BoolValue = true;
-//                    TriList.BooleanInput[UiCue.VisibleSplash.Number].BoolValue = false;
-//                    TriList.BooleanInput[UiCue.VisiblePresentationSourceList.Number].BoolValue = true;
-//                    ShowCurrentPresentationSourceUi();
-//                    break;
-//                case eMainModeType.Splash:
-//                    TriList.BooleanInput[UiCue.VisibleCommonFooter.Number].BoolValue = false;
-//                    TriList.BooleanInput[UiCue.VisibleCommonHeader.Number].BoolValue = false;
-//                    TriList.BooleanInput[UiCue.VisiblePresentationSourceList.Number].BoolValue = false;
-//                    TriList.BooleanInput[UiCue.VisibleSplash.Number].BoolValue = true;
-//                    HideCurrentPresentationSourceUi();
-//                    break;
-//                case eMainModeType.Tech:
-//                    new ModalDialog(TriList).PresentModalTimerDialog(1, "Tech page", "Info",
-//                        "Tech page will be here soon!<br>I promise",
-//                        "Bueno!", "", 0, false, null);
-//                    MainMode = eMainModeType.Presentation;
-//                    break;
-//                default:
-//                    break;
-//            }
-//        }
-
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        void PowerOffWithConfirmPressed()
-//        {
-//            if (CurrentRoom == null)
-//                return;
-//            if (!CurrentRoom.RoomIsOnFeedback.BoolValue) 
-//                return;
-//            // Timeout or button 1 press will shut down
-//            var modal = new ModalDialog(TriList);
-//            uint seconds = CurrentRoom.UnattendedShutdownTimeMs / 1000;
-//            var message = string.Format("Meeting will end in {0} seconds", seconds);
-//            modal.PresentModalTimerDialog(2, "End Meeting", "Info", message,
-//                "End Meeting Now", "Cancel", CurrentRoom.UnattendedShutdownTimeMs, true,
-//                but => { if (but != 2) CurrentRoom.RoomOff(); });
-//        }
-
-//        /// <summary>
-//        /// Reveals the basic UI for the current device
-//        /// </summary>
-//        protected override void ShowCurrentPresentationSourceUi()
-//        {
-//            if (MainMode == eMainModeType.Splash && CurrentRoom.RoomIsOnFeedback.BoolValue)
-//                SetMainMode(eMainModeType.Presentation);
-
-//            if (CurrentPresentationControlDevice == null)
-//            {
-//                // If system is off, do one thing
-
-//                // Otherwise, do something else - shouldn't be in this condition
-
-//                return;
-//            }
-
-//            // If a controller is already loaded, use it
-//            if (LoadedPageControllers.ContainsKey(CurrentPresentationControlDevice))
-//                CurrentPresentationSourcePageController = LoadedPageControllers[CurrentPresentationControlDevice];
-//            else
-//            {
-//                // This is by no means optimal, but for now....
-//                if (CurrentPresentationControlDevice.Type == PresentationSourceType.SetTopBox
-//                    && CurrentPresentationControlDevice is ISetTopBoxControls)
-//                    CurrentPresentationSourcePageController = new PageControllerLargeSetTopBoxGeneric(TriList,
-//                        CurrentPresentationControlDevice as ISetTopBoxControls);
-
-//                else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Laptop)
-//                    CurrentPresentationSourcePageController = new PageControllerLaptop(TriList);
-
-//                // separate these...
-//                else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Dvd)
-//                    CurrentPresentationSourcePageController =
-//                        new PageControllerLargeDvd(TriList, CurrentPresentationControlDevice as IDiscPlayerControls);
-
-//                else
-//                    CurrentPresentationSourcePageController = null;
-
-//                // Save it.
-//                if (CurrentPresentationSourcePageController != null)
-//                    LoadedPageControllers[CurrentPresentationControlDevice] = CurrentPresentationSourcePageController;
-//            }
-
-//            if (CurrentPresentationSourcePageController != null)
-//                CurrentPresentationSourcePageController.SetVisible(true);
-//        }
-
-//        protected override void HideCurrentPresentationSourceUi()
-//        {
-//            if (CurrentPresentationControlDevice != null && CurrentPresentationSourcePageController != null)
-//                CurrentPresentationSourcePageController.SetVisible(false);
-//        }
-
-
-
-//        void ShowHelp()
-//        {
-//            new ModalDialog(TriList).PresentModalTimerDialog(1, "Help", "Help", CurrentRoom.HelpMessage,
-//                    "OK", "", 0, false, null);
-//        }
-
-//        protected void ListSmartObjects()
-//        {
-//            Debug.Console(0, this, "Smart objects IDs:");
-//            var list = TriList.SmartObjects.OrderBy(s => s.Key);
-//            foreach (var kvp in list)
-//                Debug.Console(0, "  {0}", kvp.Key);
-//        }
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLaptop.cs

@@ -1,28 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-//using PepperDash.Core;
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Core.Presets;
-
-
-//namespace PepperDash.Essentials
-//{
-//    public class PageControllerLaptop : DevicePageControllerBase
-//    {
-//        public PageControllerLaptop(BasicTriListWithSmartObject tl)
-//            : base(tl)
-//        {
-//            FixedObjectSigs = new List<BoolInputSig> 
-//            {
-//                tl.BooleanInput[10092], // well
-//                tl.BooleanInput[11001] // Laptop info
-//            };
-//        }
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLargeDvd.cs

@@ -1,46 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-//using PepperDash.Core;
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Core.Presets;
-
-//namespace PepperDash.Essentials
-//{
-//    /// <summary>
-//    /// 
-//    /// </summary>
-//    public class PageControllerLargeDvd : DevicePageControllerBase
-//    {
-//        IDiscPlayerControls Device;
-
-//        public PageControllerLargeDvd(BasicTriListWithSmartObject tl, IDiscPlayerControls device)
-//            : base(tl)
-//        {
-
-//            Device = device;
-//            FixedObjectSigs = new List<BoolInputSig>
-//            {
-//                tl.BooleanInput[10093],		// well
-//                tl.BooleanInput[10411],		// DVD Dpad
-//                tl.BooleanInput[10412]		// everything else
-//            };
-//        }
-
-//        protected override void CustomSetVisible(bool state)
-//        {
-//            // Hook up smart objects if applicable
-//            if (Device != null)
-//            {
-//#warning rewire this
-//                //var uos = (Device as IHasCueActionList).CueActionList;
-//                //SmartObjectHelper.LinkDpadWithUserObjects(TriList, 10411, uos, state);
-//            }
-//        }
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLargeSetTopBoxGeneric.cs

@@ -1,139 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-//using PepperDash.Essentials.Core.Presets;
-
-//using PepperDash.Core;
-//using PepperDash.Essentials.Core;
-
-//namespace PepperDash.Essentials
-//{
-
-//    public class PageControllerLargeSetTopBoxGeneric : DevicePageControllerBase
-//    {
-//        // To-DO: Add properties for component subpage names. DpadPos1, DpadPos2...
-//        // Derived classes can then insert special subpages for variations on given
-//        // device types.  Like DirecTV vs Comcast
-
-//        public uint DpadSmartObjectId { get; set; }
-//        public uint NumberPadSmartObjectId { get; set; }
-//        public uint PresetsSmartObjectId { get; set; }
-//        public uint Position5TabsId { get; set; }
-
-//        ISetTopBoxControls Device;
-//        DevicePresetsView PresetsView;
-
-
-//        bool ShowPosition5Tabs;
-//        uint CurrentVisiblePosition5Item = 1;
-//        Dictionary<uint, uint> Position5SubpageJoins = new Dictionary<uint, uint>
-//        {
-//            { 1, 10053 },
-//            { 2, 10054 }
-//        };
-
-//        public PageControllerLargeSetTopBoxGeneric(BasicTriListWithSmartObject tl, ISetTopBoxControls device)
-//            : base(tl)
-//        {
-//            Device = device;
-//            DpadSmartObjectId = 10011;
-//            NumberPadSmartObjectId = 10014;
-//            PresetsSmartObjectId = 10012;
-//            Position5TabsId = 10081;
-
-//            bool dpad = device is IDPad;
-//            bool preset = device.HasPresets;
-//            bool dvr = device.HasDvr;
-//            bool numbers = device is INumericKeypad;
-//            uint[] joins = null;
-
-//            if (dpad && !preset && !dvr && !numbers) joins = new uint[] { 10031, 10091 };
-//            else if (!dpad && preset && !dvr && !numbers) joins = new uint[] { 10032, 10091 };
-//            else if (!dpad && !preset && dvr && !numbers) joins = new uint[] { 10033, 10091 };
-//            else if (!dpad && !preset && !dvr && numbers) joins = new uint[] { 10034, 10091 };
-
-//            else if (dpad && preset && !dvr && !numbers) joins = new uint[] { 10042, 10021, 10092 };
-//            else if (dpad && !preset && dvr && !numbers) joins = new uint[] { 10043, 10021, 10092 };
-//            else if (dpad && !preset && !dvr && numbers) joins = new uint[] { 10044, 10021, 10092 };
-//            else if (!dpad && preset && dvr && !numbers) joins = new uint[] { 10043, 10022, 10092 };
-//            else if (!dpad && preset && !dvr && numbers) joins = new uint[] { 10044, 10022, 10092 };
-//            else if (!dpad && !preset && dvr && numbers) joins = new uint[] { 10044, 10023, 10092 };
-
-//            else if (dpad && preset && dvr && !numbers) joins = new uint[] { 10053, 10032, 10011, 10093 };
-//            else if (dpad && preset && !dvr && numbers) joins = new uint[] { 10054, 10032, 10011, 10093 };
-//            else if (dpad && !preset && dvr && numbers) joins = new uint[] { 10054, 10033, 10011, 10093 };
-//            else if (!dpad && preset && dvr && numbers) joins = new uint[] { 10054, 10033, 10012, 10093 };
-
-//            else if (dpad && preset && dvr && numbers)
-//            {
-//                joins = new uint[] { 10081, 10032, 10011, 10093 }; // special case
-//                ShowPosition5Tabs = true;
-//            }
-//            // Project the joins into corresponding sigs.
-//            FixedObjectSigs = joins.Select(u => TriList.BooleanInput[u]).ToList();
-
-//            // Build presets
-//            if (device.HasPresets)
-//            {
-//                PresetsView = new DevicePresetsView(tl, device.PresetsModel);
-//            }
-//        }
-
-//        protected override void CustomSetVisible(bool state)
-//        {
-//            if (ShowPosition5Tabs)
-//            {
-//                // Show selected tab
-//                TriList.BooleanInput[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = state;
-
-//                var tabSo = TriList.SmartObjects[Position5TabsId];
-//                if (state) // Link up the tab object
-//                {
-//                    tabSo.BooleanOutput["Tab Button 1 Press"].UserObject = new Action<bool>(b => ShowTab(1));
-//                    tabSo.BooleanOutput["Tab Button 2 Press"].UserObject = new Action<bool>(b => ShowTab(2));
-//                }
-//                else // Disco tab object
-//                {
-//                    tabSo.BooleanOutput["Tab Button 1 Press"].UserObject = null;
-//                    tabSo.BooleanOutput["Tab Button 2 Press"].UserObject = null;
-//                }
-//            }
-
-//            // Hook up smart objects if applicable
-//#warning hook these up
-//            //if (Device is IHasCueActionList)
-//            //{
-//            //    var uos = (Device as IHasCueActionList).CueActionList;
-//            //    SmartObjectHelper.LinkDpadWithUserObjects(TriList, DpadSmartObjectId, uos, state);
-//            //    SmartObjectHelper.LinkNumpadWithUserObjects(TriList, NumberPadSmartObjectId,
-//            //        uos, CommonBoolCue.Dash, CommonBoolCue.Last, state);
-//            //}
-
-
-//            // Link, unlink presets
-//            if (Device.HasPresets && state)
-//                PresetsView.Attach();
-//            else if (Device.HasPresets && !state)
-//                PresetsView.Detach();
-//        }
-
-//        void ShowTab(uint number)
-//        {
-//            // Ignore re-presses
-//            if (CurrentVisiblePosition5Item == number) return;
-//            // Swap subpage
-//            var bi = TriList.BooleanInput;
-//            if (CurrentVisiblePosition5Item > 0)
-//                bi[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = false;
-//            CurrentVisiblePosition5Item = number;
-//            bi[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = true;
-
-//            // Show feedback on buttons
-//        }
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/Panels/REMOVE UiCue.cs

@@ -1,43 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Crestron.SimplSharp;
-
-//namespace PepperDash.Essentials.Core
-//{
-//    public class UiCue
-//    {
-//        public static readonly Cue VisibleSystemInit = Cue.BoolCue("VisibleSystemInit", 15001);
-//        public static readonly Cue VisibleSplash = Cue.BoolCue("VisibleSplash", 15002);
-//        public static readonly Cue PressSplash = Cue.BoolCue("PressSplash", 15003);
-//        public static readonly Cue PressRoomOn = Cue.BoolCue("PressRoomOn", 15006);
-//        public static readonly Cue PressRoomOff = Cue.BoolCue("PressRoomOff", 15007);
-//        public static readonly Cue PressRoomOffWithConfirm = Cue.BoolCue("PressRoomOffWithConfirm", 15008);
-//        public static readonly Cue VisibleCommonHeader = Cue.BoolCue("PressPowerOffConfirm", 15011);
-//        public static readonly Cue VisibleCommonFooter = Cue.BoolCue("VisibleCommonFooter", 15012);
-//        public static readonly Cue PressHelp = Cue.BoolCue("PressHelp", 15013);
-//        public static readonly Cue PressSettings = Cue.BoolCue("PressSettings", 15014);
-
-//        public static readonly Cue ShowDate = Cue.BoolCue("PressSettings", 15015);
-//        public static readonly Cue ShowTime = Cue.BoolCue("PressSettings", 15016);
-//        public static readonly Cue ShowLicensed = Cue.BoolCue("PressSettings", 15017);
-//        public static readonly Cue ShowUnLicensed = Cue.BoolCue("PressSettings", 15018);
-
-//        public static readonly Cue PressModePresentationShare = Cue.BoolCue("PressModePresentationShare", 15101);
-//        public static readonly Cue PressModeVideoConf = Cue.BoolCue("PressModeVideoConf", 15102);
-//        public static readonly Cue PressModeAudioConf = Cue.BoolCue("PressModeAudioConf", 15103);
-
-//        public static readonly Cue VisiblePresentationSourceList = Cue.BoolCue("VisiblePresentationSourceList", 15111);
-//        public static readonly Cue VisibleSystemIsOff = Cue.BoolCue("VisibleSystemIsOff", 15112);
-
-//        public static readonly Cue VisibleAudioConfPopover = Cue.BoolCue("VisibleAudioConfPopover", 15201);
-
-//        public static readonly Cue VisibleVideoConfPopover = Cue.BoolCue("VisibleVideoConfPopover", 15251);
-
-//        public static readonly Cue TextRoomName = Cue.BoolCue("TextRoomName", 4001);
-//        public static readonly Cue TextPresentationShareButton = Cue.BoolCue("TextPresentationShareButton", 4011);
-
-//        public static readonly Cue SplashMessage = Cue.StringCue("SplashMessage", 2101);
-//    }
-//}

PepperDashEssentials/FOR REFERENCE UI/Panels/SmartGraphicsTouchpanelControllerBase.cs

@@ -1,318 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-
-
-//namespace PepperDash.Essentials.Core
-//{
-//    public abstract class SmartGraphicsTouchpanelControllerBase : CrestronGenericBaseDevice
-//    {
-//        public BasicTriListWithSmartObject TriList { get; protected set; }
-//        public bool UsesSplashPage { get; set; }
-//        public string SplashMessage { get; set; }
-//        public bool ShowDate
-//        {
-//            set { TriList.BooleanInput[UiCue.ShowDate.Number].BoolValue = value; }
-//        }
-//        public bool ShowTime
-//        {
-//            set { TriList.BooleanInput[UiCue.ShowTime.Number].BoolValue = value; }
-//        }
-
-//        //public abstract List<CueActionPair> FunctionList { get; }
-
-
-//        protected eMainModeType MainMode;
-//        protected SourceListItem CurrentPresentationControlDevice;
-
-//        /// <summary>
-//        /// Defines the signal offset for the presentation device.  Defaults to 100
-//        /// </summary>
-//        public uint PresentationControlDeviceJoinOffset { get { return 100; } }
-
-//        public enum eMainModeType
-//        {
-//            Presentation, Splash, Tech
-//        }
-
-//        protected string SgdFilePath;
-//        public EssentialsRoom CurrentRoom { get; protected set; }
-//        protected Dictionary<SourceListItem, DevicePageControllerBase> LoadedPageControllers
-//            = new Dictionary<SourceListItem, DevicePageControllerBase>();
-
-//        static object RoomChangeLock = new object();
-
-//        /// <summary>
-//        /// Constructor
-//        /// </summary>
-//        public SmartGraphicsTouchpanelControllerBase(string key, string name, BasicTriListWithSmartObject triList,
-//            string sgdFilePath)
-//            : base(key, name, triList)
-//        {
-//            TriList = triList;
-//            if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key");
-//            if (string.IsNullOrEmpty(sgdFilePath)) throw new ArgumentNullException("sgdFilePath");
-//            SgdFilePath = sgdFilePath;
-//            TriList.LoadSmartObjects(SgdFilePath);
-//            UsesSplashPage = true;
-//            SplashMessage = "Welcome";
-//            TriList.SigChange += Tsw_AnySigChange;
-//            foreach (var kvp in TriList.SmartObjects)
-//                kvp.Value.SigChange += this.Tsw_AnySigChange;
-//        }
-
-//#warning wire UI manipulating presses up here, typically in child classes...
-//        //public override bool CustomActivate()
-//        //{
-//        //    var baseSuccess = base.CustomActivate();
-//        //    if (!baseSuccess) return false;
-
-
-//        //    // Wiring up the buttons with UOs 
-//        //    foreach (var uo in this.FunctionList)
-//        //    {
-//        //        if (uo.Cue.Number == 0) continue;
-//        //        //if (uo is BoolCueActionPair)
-//        //        //    TriList.BooleanOutput[uo.Cue.Number].UserObject = uo;
-//        //        //else if (uo is UShortCueActionPair)
-//        //        //    TriList.UShortOutput[uo.Cue.Number].UserObject = uo;
-//        //        //else if (uo is StringCueActionPair)
-//        //        //    TriList.StringOutput[uo.Cue.Number].UserObject = uo;
-//        //    }
-
-//        //    return true;
-//        //}
-
-//        //public void SetCurrentRoom(EssentialsRoom room)
-//        //{
-//        //    if (CurrentRoom != null)
-//        //        HideRoomUI();
-//        //    CurrentRoom = room;
-//        //    ShowRoomUI();
-//        //}
-
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        /// <param name="room"></param>
-//        public void SetCurrentRoom(EssentialsRoom room)
-//        {
-//            if (CurrentRoom == room) return;
-
-//            IBasicVolumeControls oldAudio = null;
-//            //Disconnect current room and audio device
-//            if (CurrentRoom != null)
-//            {
-//                HideRoomUI();
-//                CurrentRoom.AudioDeviceWillChange -= CurrentRoom_AudioDeviceWillChange;
-//                CurrentRoom.PresentationSourceChange -= CurrentRoom_PresentationSourceChange;
-//                oldAudio = CurrentRoom.CurrentAudioDevice;
-//            }
-
-//            CurrentRoom = room;
-//            IBasicVolumeControls newAudio = null;
-//            if (CurrentRoom != null)
-//            {
-//                CurrentRoom.AudioDeviceWillChange += this.CurrentRoom_AudioDeviceWillChange;
-//                CurrentRoom.PresentationSourceChange += this.CurrentRoom_PresentationSourceChange;
-//                SetControlSource(CurrentRoom.CurrentPresentationSourceInfo);
-//                newAudio = CurrentRoom.CurrentAudioDevice;
-//                ShowRoomUI();
-//            }
-
-//            SwapAudioDeviceControls(oldAudio, newAudio);
-//        }
-
-//        /// <summary>
-//        /// Detaches and attaches an IVolumeFunctions device to the appropriate TP TriList signals.
-//        /// This will also add IVolumeNumeric if the device implements it.
-//        /// Overriding classes should call this. Overriding classes are responsible for
-//        /// linking up to hard keys, etc.
-//        /// </summary>
-//        /// <param name="oldDev">May be null</param>
-//        /// <param name="newDev">May be null</param>
-//        protected virtual void SwapAudioDeviceControls(IBasicVolumeControls oldDev, IBasicVolumeControls newDev)
-//        {
-//            // Disconnect
-//            if (oldDev != null)
-//            {
-//                TriList.BooleanOutput[CommonBoolCue.VolumeDown.Number].UserObject = null;
-//                TriList.BooleanOutput[CommonBoolCue.VolumeUp.Number].UserObject = null;
-//                TriList.BooleanOutput[CommonBoolCue.MuteToggle.Number].UserObject = null;
-//                TriList.BooleanInput[CommonBoolCue.ShowVolumeButtons.Number].BoolValue = false;
-//                TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = false;
-//                if (oldDev is IBasicVolumeWithFeedback)
-//                {
-//                    var fbDev = oldDev as IBasicVolumeWithFeedback;
-//                    TriList.UShortOutput[401].UserObject = null;
-//                    fbDev.MuteFeedback.UnlinkInputSig(TriList.BooleanInput[403]);
-//                    fbDev.VolumeLevelFeedback.UnlinkInputSig(TriList.UShortInput[401]);
-//                }
-//            }
-//            if (newDev != null)
-//            {
-//                TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = true;
-//                TriList.SetBoolSigAction(401, newDev.VolumeUp);
-//                TriList.SetBoolSigAction(402, newDev.VolumeDown);
-//                TriList.SetSigFalseAction(405, newDev.MuteToggle);
-
-//                if (newDev is IBasicVolumeWithFeedback) // Show slider
-//                {
-//                    var fbDev = newDev as IBasicVolumeWithFeedback;
-//                    TriList.BooleanInput[406].BoolValue = false;
-//                    TriList.BooleanInput[407].BoolValue = true;
-//                    TriList.UShortOutput[401].UserObject = new Action<ushort>(fbDev.SetVolume);
-//                    fbDev.VolumeLevelFeedback.LinkInputSig(TriList.UShortInput[401]);
-//                }
-//                else // Show buttons only
-//                {
-//                    TriList.BooleanInput[406].BoolValue = true;
-//                    TriList.BooleanInput[407].BoolValue = false;
-//                }
-
-//            }
-//        }
-
-
-//        /// <summary>
-//        /// Does nothing. Override to add functionality when calling SetCurrentRoom
-//        /// </summary>
-//        protected virtual void HideRoomUI() { }
-
-//        /// <summary>
-//        /// Does nothing. Override to add functionality when calling SetCurrentRoom
-//        /// </summary>		
-//        protected virtual void ShowRoomUI() { }
-
-//        /// <summary>
-//        /// Sets up the current presentation device and updates statuses if the device is capable.
-//        /// </summary>
-//        protected void SetControlSource(SourceListItem newSource)
-//        {
-//            if (CurrentPresentationControlDevice != null)
-//            {
-//                HideCurrentPresentationSourceUi();
-//#warning Get button methods from RESI, and find a more-well-defined way to wire up feedbacks
-
-//                // Unhook presses and things
-//                //if (CurrentPresentationControlDevice is IHasCueActionList)
-//                //{
-//                //    foreach (var uo in (CurrentPresentationControlDevice as IHasCueActionList).CueActionList)
-//                //    {
-//                //        if (uo.Cue.Number == 0) continue;
-//                //        if (uo is BoolCueActionPair)
-//                //        {
-//                //            var bSig = TriList.BooleanOutput[uo.Cue.Number];
-//                //            // Disconnection should also clear bool sigs in case they are pressed and
-//                //            // might be orphaned
-//                //            if (bSig.BoolValue)
-//                //                (bSig.UserObject as BoolCueActionPair).Invoke(false);
-//                //            bSig.UserObject = null;
-//                //        }
-//                //        else if (uo is UShortCueActionPair)
-//                //            TriList.UShortOutput[uo.Cue.Number].UserObject = null;
-//                //        else if (uo is StringCueActionPair)
-//                //            TriList.StringOutput[uo.Cue.Number].UserObject = null;
-//                //    }
-//                //}
-//                // unhook outputs
-//                if (CurrentPresentationControlDevice is IHasFeedback)
-//                {
-//                    foreach (var fb in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
-//                    {
-//                        if (fb.Cue.Number == 0) continue;
-//                        if (fb is BoolFeedback)
-//                            (fb as BoolFeedback).UnlinkInputSig(TriList.BooleanInput[fb.Cue.Number]);
-//                        else if (fb is IntFeedback)
-//                            (fb as IntFeedback).UnlinkInputSig(TriList.UShortInput[fb.Cue.Number]);
-//                        else if (fb is StringFeedback)
-//                            (fb as StringFeedback).UnlinkInputSig(TriList.StringInput[fb.Cue.Number]);
-//                    }
-//                }
-//            }
-//            CurrentPresentationControlDevice = newSource;
-//            //connect presses and things
-//            //if (newSource is IHasCueActionList) // This has functions, get 'em
-//            //{
-//            //    foreach (var ao in (newSource as IHasCueActionList).CueActionList)
-//            //    {
-//            //        if (ao.Cue.Number == 0) continue;
-//            //        if (ao is BoolCueActionPair)
-//            //            TriList.BooleanOutput[ao.Cue.Number].UserObject = ao;
-//            //        else if (ao is UShortCueActionPair)
-//            //            TriList.UShortOutput[ao.Cue.Number].UserObject = ao;
-//            //        else if (ao is StringCueActionPair)
-//            //            TriList.StringOutput[ao.Cue.Number].UserObject = ao;
-//            //    }
-//            //}
-//            // connect outputs (addInputSig should update sig)
-//            if (CurrentPresentationControlDevice is IHasFeedback)
-//            {
-//                foreach (var fb in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
-//                {
-//                    if (fb.Cue.Number == 0) continue;
-//                    if (fb is BoolFeedback)
-//                        (fb as BoolFeedback).LinkInputSig(TriList.BooleanInput[fb.Cue.Number]);
-//                    else if (fb is IntFeedback)
-//                        (fb as IntFeedback).LinkInputSig(TriList.UShortInput[fb.Cue.Number]);
-//                    else if (fb is StringFeedback)
-//                        (fb as StringFeedback).LinkInputSig(TriList.StringInput[fb.Cue.Number]);
-//                }
-//            }
-//            ShowCurrentPresentationSourceUi();
-//        }
-
-//        /// <summary>
-//        /// Reveals the basic UI for the current device
-//        /// </summary>
-//        protected virtual void ShowCurrentPresentationSourceUi()
-//        {
-//        }
-
-//        /// <summary>
-//        /// Hides the UI for the current device and calls for a feedback signal cleanup
-//        /// </summary>
-//        protected virtual void HideCurrentPresentationSourceUi()
-//        {
-//        }
-
-
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        void CurrentRoom_PresentationSourceChange(object sender, EssentialsRoomSourceChangeEventArgs args)
-//        {
-//            SetControlSource(args.NewSource);
-//        }
-
-
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        void CurrentRoom_AudioDeviceWillChange(object sender, EssentialsRoomAudioDeviceChangeEventArgs e)
-//        {
-//            SwapAudioDeviceControls(e.OldDevice, e.NewDevice);
-//        }
-
-
-
-//        /// <summary>
-//        /// Panel event handler
-//        /// </summary>
-//        void Tsw_AnySigChange(object currentDevice, SigEventArgs args)
-//        {
-//            // plugged in commands
-//            object 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/Factory/DeviceFactory.cs

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

PepperDashEssentials/Factory/UiDeviceFactory.cs

@@ -1,162 +1,191 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.UI;
-
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.PageManagers;
-
-
-namespace PepperDash.Essentials
-{
-    public class UiDeviceFactory
-    {
-        public static IKeyed GetUiDevice(DeviceConfig config)
-        {
-            var comm = CommFactory.GetControlPropertiesConfig(config);
-
-            var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(config.Properties.ToString());
-
-            EssentialsTouchpanelController panelController = new EssentialsTouchpanelController(config.Key, config.Name, config.Type, props, comm.IpIdInt);
-
-            panelController.AddPostActivationAction(() =>
-                {
-                     var mainDriver = new EssentialsPanelMainInterfaceDriver(panelController.Panel, props);
-                    // Then the sub drivers
-
-                    // spin up different room drivers depending on room type
-                    var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey);
-                    if (room is EssentialsHuddleSpaceRoom)
-                    {
-
-                        // Header Driver
-                        Debug.Console(0, panelController, "Adding header driver");
-                        mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
-                        
-                        // AV Driver
-                        Debug.Console(0, panelController, "Adding huddle space AV driver");
-                        var avDriver = new EssentialsHuddlePanelAvFunctionsDriver(mainDriver, props);
-                        avDriver.DefaultRoomKey = props.DefaultRoomKey;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.UI;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.PageManagers;
+using PepperDash.Essentials.DM.Endpoints.DGEs;
+
+
+namespace PepperDash.Essentials
+{
+    public class UiDeviceFactory
+    {
+        public static IKeyed GetUiDevice(DeviceConfig config)
+        {
+            var comm = CommFactory.GetControlPropertiesConfig(config);
+
+            var typeName = config.Type.ToLower();
+
+            EssentialsTouchpanelController panelController = null;
+
+            var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(config.Properties.ToString());
+
+            if (typeName.Contains("dge"))
+            {
+                Dge100 dgeDevice = null;
+                if (typeName == "dge100")
+                    dgeDevice = new Dge100(comm.IpIdInt, Global.ControlSystem);
+                else if (typeName == "dmdge200c")
+                    dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
+
+                if (dgeDevice == null)
+                {
+                    Debug.Console(1, "Unable to create DGE device");
+                    return null;
+                }
+
+                var dgeController = new DgeController(config.Key + "-comPorts", config.Name, dgeDevice, config, props);
+
+                DeviceManager.AddDevice(dgeController);
+
+                panelController = new EssentialsTouchpanelController(config.Key, config.Name, dgeController.DigitalGraphicsEngine,
+                    props.ProjectName, props.SgdFile);
+            }
+            else
+            {
+                panelController = new EssentialsTouchpanelController(config.Key, config.Name, config.Type, props, comm.IpIdInt);
+            }
+
+            panelController.AddPostActivationAction(() =>
+                {
+                     var mainDriver = new EssentialsPanelMainInterfaceDriver(panelController.Panel, props);
+                    // Then the sub drivers
+
+                    // spin up different room drivers depending on room type
+                    var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey);
+                    if (room is EssentialsHuddleSpaceRoom)
+                    {
+
+                        // Header Driver
+                        Debug.Console(0, panelController, "Adding header driver");
+                        mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
+                        
+                        // AV Driver
+                        Debug.Console(0, panelController, "Adding huddle space AV driver");
+                        var avDriver = new EssentialsHuddlePanelAvFunctionsDriver(mainDriver, props);
+                        avDriver.DefaultRoomKey = props.DefaultRoomKey;
                         mainDriver.AvDriver = avDriver;
                         avDriver.CurrentRoom = room as EssentialsHuddleSpaceRoom;
-                        
-                        // Environment Driver
-                        if (avDriver.CurrentRoom.Config.Environment != null && avDriver.CurrentRoom.Config.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.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
-
-                        panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
-
-                        if (panelController.Panel is TswFt5ButtonSystem)
-                        {
-                            var tsw = panelController.Panel as TswFt5ButtonSystem;
-                            // Wire up hard keys
-                            tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
-                            //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
-                            if(mainDriver.EnvironmentDriver != null)
-                                tsw.Lights.UserObject = new Action<bool>(b => 
-                                {
-                                    if (!b)
-                                    {
-                                        //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
-                                        mainDriver.EnvironmentDriver.Toggle();
-                                    }
-                                });
-                            tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
-                            tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
-                        }
-                    }
-                    //else if (room is EssentialsPresentationRoom)
-                    //{
-                    //    Debug.Console(0, panelController, "Adding presentation room driver");
-                    //    var avDriver = new EssentialsPresentationPanelAvFunctionsDriver(mainDriver, props);
-                    //    avDriver.CurrentRoom = room as EssentialsPresentationRoom;
-                    //    avDriver.DefaultRoomKey = props.DefaultRoomKey;
-                    //    mainDriver.AvDriver = avDriver ;
-                    //    mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
-                    //    panelController.LoadAndShowDriver(mainDriver);
-
-                    //    if (panelController.Panel is TswFt5ButtonSystem)
-                    //    {
-                    //        var tsw = panelController.Panel as TswFt5ButtonSystem;
-                    //        // Wire up hard keys
-                    //        tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
-                    //        //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
-                    //        tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
-                    //        tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
-                    //    }
-                    //}
-                    else if (room is EssentialsHuddleVtc1Room)
-                    {
-                        Debug.Console(0, panelController, "Adding huddle space VTC AV driver");
-
-                        // Header Driver
-                        mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
-
-                        // AV Driver
-                        var avDriver = new EssentialsHuddleVtc1PanelAvFunctionsDriver(mainDriver, props);
-
-                        var codecDriver = new PepperDash.Essentials.UIDrivers.VC.EssentialsVideoCodecUiDriver(panelController.Panel, avDriver,
-                            (room as EssentialsHuddleVtc1Room).VideoCodec, mainDriver.HeaderDriver);
-                        avDriver.SetVideoCodecDriver(codecDriver);
-                        avDriver.DefaultRoomKey = props.DefaultRoomKey;
+                        
+                        // Environment Driver
+                        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.PropertiesConfig.Environment);
+                        }
+
+                        mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
+
+                        panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
+
+                        if (panelController.Panel is TswFt5ButtonSystem)
+                        {
+                            var tsw = panelController.Panel as TswFt5ButtonSystem;
+                            // Wire up hard keys
+                            tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
+                            //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
+                            if(mainDriver.EnvironmentDriver != null)
+                                tsw.Lights.UserObject = new Action<bool>(b => 
+                                {
+                                    if (!b)
+                                    {
+                                        //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
+                                        mainDriver.EnvironmentDriver.Toggle();
+                                    }
+                                });
+                            tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
+                            tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
+                        }
+                    }
+                    //else if (room is EssentialsPresentationRoom)
+                    //{
+                    //    Debug.Console(0, panelController, "Adding presentation room driver");
+                    //    var avDriver = new EssentialsPresentationPanelAvFunctionsDriver(mainDriver, props);
+                    //    avDriver.CurrentRoom = room as EssentialsPresentationRoom;
+                    //    avDriver.DefaultRoomKey = props.DefaultRoomKey;
+                    //    mainDriver.AvDriver = avDriver ;
+                    //    mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
+                    //    panelController.LoadAndShowDriver(mainDriver);
+
+                    //    if (panelController.Panel is TswFt5ButtonSystem)
+                    //    {
+                    //        var tsw = panelController.Panel as TswFt5ButtonSystem;
+                    //        // Wire up hard keys
+                    //        tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
+                    //        //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
+                    //        tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
+                    //        tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
+                    //    }
+                    //}
+                    else if (room is EssentialsHuddleVtc1Room)
+                    {
+                        Debug.Console(0, panelController, "Adding huddle space VTC AV driver");
+
+                        // Header Driver
+                        mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
+
+                        // AV Driver
+                        var avDriver = new EssentialsHuddleVtc1PanelAvFunctionsDriver(mainDriver, props);
+
+                        var codecDriver = new PepperDash.Essentials.UIDrivers.VC.EssentialsVideoCodecUiDriver(panelController.Panel, avDriver,
+                            (room as EssentialsHuddleVtc1Room).VideoCodec, mainDriver.HeaderDriver);
+                        avDriver.SetVideoCodecDriver(codecDriver);
+                        avDriver.DefaultRoomKey = props.DefaultRoomKey;
                         mainDriver.AvDriver = avDriver;
-                        avDriver.CurrentRoom = room as EssentialsHuddleVtc1Room;
-
-                        // Environment Driver
-                        if (avDriver.CurrentRoom.Config.Environment != null && avDriver.CurrentRoom.Config.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.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
-
-                        panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
-
-                        if (panelController.Panel is TswFt5ButtonSystem)
-                        {
-                            var tsw = panelController.Panel as TswFt5ButtonSystem;
-                            // Wire up hard keys
-                            tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.EndMeetingPress(); });
-                            //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
-                            if (mainDriver.EnvironmentDriver != null)
-                                tsw.Lights.UserObject = new Action<bool>(b =>
-                                {
-                                    if (!b)
-                                    {
-                                        //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
-                                        mainDriver.EnvironmentDriver.Toggle();
-                                    }
-                                });
-                            tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
-                            tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
-                        }
-                    }
-                    else
-                    {
-                        Debug.Console(0, panelController, "ERROR: Cannot load AvFunctionsDriver for room '{0}'", props.DefaultRoomKey);
-                    }
-                });
-
-            return panelController;
-        }
-
-    }
+                        avDriver.CurrentRoom = room as EssentialsHuddleVtc1Room;
+
+                        // Environment Driver
+                        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.PropertiesConfig.Environment);
+                        }
+
+                        mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
+
+                        panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
+
+                        if (panelController.Panel is TswFt5ButtonSystem)
+                        {
+                            var tsw = panelController.Panel as TswFt5ButtonSystem;
+                            // Wire up hard keys
+                            tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.EndMeetingPress(); });
+                            //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
+                            if (mainDriver.EnvironmentDriver != null)
+                                tsw.Lights.UserObject = new Action<bool>(b =>
+                                {
+                                    if (!b)
+                                    {
+                                        //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
+                                        mainDriver.EnvironmentDriver.Toggle();
+                                    }
+                                });
+                            tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
+                            tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
+                        }
+                    }
+                    else
+                    {
+                        Debug.Console(0, panelController, "ERROR: Cannot load AvFunctionsDriver for room '{0}'", props.DefaultRoomKey);
+                    }
+                });
+
+            return panelController;
+        }
+
+    }
 }

PepperDashEssentials/Fusion/EssentialsHuddleVtc1FusionController.cs

@@ -13,6 +13,8 @@ using Crestron.SimplSharpPro.Fusion;
 using PepperDash.Core;
 using PepperDash.Essentials;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Fusion;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.Devices.Common.Occupancy;
 
@@ -180,20 +182,13 @@ namespace PepperDash.Essentials.Fusion
             // Moved to 
             CurrentRoomSourceNameSig = FusionRoom.CreateOffsetStringSig(84, "Display 1 - Current Source", eSigIoMask.InputSigOnly);
             // Don't think we need to get current status of this as nothing should be alive yet. 
-            (Room as EssentialsHuddleVtc1Room).CurrentSingleSourceChange += Room_CurrentSourceInfoChange;
+            (Room as EssentialsHuddleVtc1Room).CurrentSourceChange += Room_CurrentSourceInfoChange;
 
 
             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;";
-
-            GetProcessorEthernetValues();
-
-            GetSystemInfo();
-
-            GetProcessorInfo();
+ 
 
             CrestronEnvironment.EthernetEventHandler += CrestronEnvironment_EthernetEventHandler;
         }
@@ -226,7 +221,7 @@ namespace PepperDash.Essentials.Fusion
                         break;
                 }
 
-                var laptops = dict.Where(d => d.Value.SourceDevice is Laptop);
+                var laptops = dict.Where(d => d.Value.SourceDevice is Core.Devices.Laptop);
                 i = 1;
                 foreach (var kvp in laptops)
                 {

PepperDashEssentials/PepperDashEssentials.csproj

@@ -48,32 +48,32 @@
   <ItemGroup>
     <Reference Include="Crestron.SimplSharpPro.DeviceSupport, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DeviceSupport.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DeviceSupport.dll</HintPath>
     </Reference>
     <Reference Include="Crestron.SimplSharpPro.DM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DM.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DM.dll</HintPath>
     </Reference>
     <Reference Include="Crestron.SimplSharpPro.EthernetCommunications, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.EthernetCommunications.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.EthernetCommunications.dll</HintPath>
     </Reference>
     <Reference Include="Crestron.SimplSharpPro.Fusion, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Fusion.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Fusion.dll</HintPath>
     </Reference>
     <Reference Include="Crestron.SimplSharpPro.Remotes, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Remotes.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Remotes.dll</HintPath>
     </Reference>
     <Reference Include="Crestron.SimplSharpPro.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.3.27452, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.26.30384, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\essentials-framework\references\PepperDash_Core.dll</HintPath>
+      <HintPath>..\essentials-framework\pepperdashcore-builds\PepperDash_Core.dll</HintPath>
     </Reference>
     <Reference Include="PepperDash_Essentials_DM, Version=1.0.0.19343, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -81,30 +81,80 @@
     </Reference>
     <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
     </Reference>
     <Reference Include="SimplSharpHelperInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
     </Reference>
     <Reference Include="SimplSharpNewtonsoft, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpNewtonsoft.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpNewtonsoft.dll</HintPath>
     </Reference>
-    <Reference Include="SimplSharpPro, Version=1.5.2.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+    <Reference Include="SimplSharpPro, Version=1.5.3.17, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
     </Reference>
     <Reference Include="SimplSharpReflectionInterface, Version=1.0.5583.25238, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpReflectionInterface.dll</HintPath>
+      <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\ConfigMessenger.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\AppleTvBridge.cs" />
+    <Compile Include="Bridges\BridgeBase.cs" />
+    <Compile Include="Bridges\BridgeFactory.cs" />
+    <Compile Include="Bridges\CameraControllerBridge.cs" />
+    <Compile Include="Bridges\AirMediaControllerBridge.cs" />
+    <Compile Include="Bridges\DmBladeChassisControllerBridge.cs" />
+    <Compile Include="Bridges\JoinMaps\DmBladeChassisControllerJoinMap.cs" />
+    <Compile Include="Bridges\DmpsAudioOutputControllerBridge.cs" />
+    <Compile Include="Bridges\DmpsRoutingControllerBridge.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\GlsOccupancySensorBaseControllerBridge.cs" />
+    <Compile Include="Bridges\HdMdxxxCEControllerBridge.cs" />
+    <Compile Include="Bridges\IBasicCommunicationBridge.cs" />
+    <Compile Include="Bridges\DmRmcControllerBridge.cs" />
+    <Compile Include="Bridges\IBridge.cs" />
+    <Compile Include="Bridges\IDigitalInputBridge.cs" />
+    <Compile Include="Bridges\JoinMaps\AirMediaControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\AppleTvJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\CameraControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DigitalLoggerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DisplayControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DmChassisControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DmpsAudioOutputControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DmpsRoutingControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DmRmcControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\DmTxControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\GenericLightingJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\GenericRelayControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\HdMdxxxCEControllerJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\SystemMonitorJoinMap.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" />
@@ -115,56 +165,44 @@
     <Compile Include="Configuration ORIGINAL\Factories\DmFactory.cs" />
     <Compile Include="Configuration ORIGINAL\Factories\TouchpanelFactory.cs" />
     <Compile Include="Configuration ORIGINAL\Factories\PcFactory.cs" />
-    <Compile Include="Configuration ORIGINAL\Factories\REMOVE DiscPlayerFactory.cs" />
-    <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="OTHER\Fusion\FusionEventHandlers.cs" />
-    <Compile Include="OTHER\Fusion\FusionProcessorQueries.cs" />
-    <Compile Include="OTHER\Fusion\FusionRviDataClasses.cs" />
-    <Compile Include="REMOVE EssentialsApp.cs" />
-    <Compile Include="OTHER\Fusion\EssentialsHuddleSpaceFusionSystemControllerBase.cs" />
+    <Compile Include="Fusion\EssentialsHuddleVtc1FusionController.cs" />
     <Compile Include="HttpApiHandler.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Room\Config\EssentialsDualDisplayRoomPropertiesConfig.cs" />
+    <Compile Include="Room\Config\EssentialsNDisplayRoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\DDVC01RoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsPresentationPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsHuddleRoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsHuddleVtc1PropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsRoomEmergencyConfig.cs" />
-    <Compile Include="Room\Cotija\CotijaConfig.cs" />
-    <Compile Include="Room\Cotija\CotijaDdvc01DeviceBridge.cs" />
-    <Compile Include="Room\Cotija\Interfaces.cs" />
-    <Compile Include="Room\Cotija\RoomBridges\CotijaBridgeBase.cs" />
-    <Compile Include="Room\Cotija\RoomBridges\CotijaDdvc01RoomBridge.cs" />
-    <Compile Include="Room\Cotija\RoomBridges\CotijaEssentialsHuddleSpaceRoomBridge.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\IChannelExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\IColorExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\IDPadExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\IDvrExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\INumericExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\IPowerExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\ISetTopBoxControlsExtensions.cs" />
-    <Compile Include="Room\Cotija\DeviceTypeInterfaces\ITransportExtensions.cs" />
+    <Compile Include="AppServer\MobileControlConfig.cs" />
+    <Compile Include="AppServer\MobileControlDdvc01DeviceBridge.cs" />
+    <Compile Include="AppServer\Interfaces.cs" />
+    <Compile Include="AppServer\RoomBridges\MobileControlBridgeBase.cs" />
+    <Compile Include="AppServer\RoomBridges\MobileControlDdvc01RoomBridge.cs" />
+    <Compile Include="AppServer\RoomBridges\MobileControlEssentialsHuddleSpaceRoomBridge.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\IChannelExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\IColorExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\IDPadExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\IDvrExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\INumericExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\IPowerExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\ISetTopBoxControlsExtensions.cs" />
+    <Compile Include="AppServer\DeviceTypeInterfaces\ITransportExtensions.cs" />
+    <Compile Include="AppServer\RoomBridges\SourceDeviceMapDictionary.cs" />
+    <Compile Include="AppServer\Volumes.cs" />
     <Compile Include="Room\Emergency\EsentialsRoomEmergencyContactClosure.cs" />
+    <Compile Include="Room\Types\EssentialsDualDisplayRoom.cs" />
     <Compile Include="Room\Types\EssentialsHuddleVtc1Room.cs" />
+    <Compile Include="Room\Types\EssentialsNDisplayRoomBase.cs" />
     <Compile Include="Room\Types\EssentialsPresentationRoom.cs" />
-    <Compile Include="Room\Types\EssentialsRoomBase.cs" />
     <Compile Include="Room\Config\EssentialsRoomConfig.cs" />
-    <Compile Include="FOR REFERENCE UI\PageControllers\DevicePageControllerBase.cs" />
-    <Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLaptop.cs" />
-    <Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLargeDvd.cs" />
-    <Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLargeSetTopBoxGeneric.cs" />
-    <Compile Include="FOR REFERENCE UI\PageControllers\LargeTouchpanelControllerBase.cs" />
-    <Compile Include="FOR REFERENCE UI\Panels\SmartGraphicsTouchpanelControllerBase.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsEnvironmentDriver.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsLightingDriver.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsShadeDriver.cs" />
@@ -178,7 +216,7 @@
     <Compile Include="UI\SubpageReferenceListCallStagingItem.cs" />
     <Compile Include="UIDrivers\VC\EssentialsVideoCodecUiDriver.cs" />
     <Compile Include="UIDrivers\EssentialsHuddleVTC\EssentialsHuddleVtc1PanelAvFunctionsDriver.cs" />
-    <Compile Include="UIDrivers\VolumeAndSourceChangeArgs.cs" />
+    <Compile Include="UIDrivers\SourceChangeArgs.cs" />
     <Compile Include="UI\JoinConstants\UISmartObjectJoin.cs" />
     <Compile Include="UI\JoinConstants\UIStringlJoin.cs" />
     <Compile Include="UI\JoinConstants\UIUshortJoin.cs" />
@@ -191,20 +229,23 @@
     <Compile Include="UIDrivers\Page Drivers\SingleSubpageModalAndBackDriver.cs" />
     <Compile Include="UIDrivers\SmartObjectRoomsList.cs" />
     <Compile Include="UI\JoinConstants\UIBoolJoin.cs" />
-    <Compile Include="Room\Cotija\CotijaSystemController.cs" />
+    <Compile Include="AppServer\MobileControlSystemController.cs" />
     <Compile Include="UI\DualDisplaySourceSRLController.cs" />
     <Compile Include="UI\SubpageReferenceListActivityItem.cs" />
-    <Compile Include="UI\CrestronTouchpanelPropertiesConfig.cs" />
-    <Compile Include="FOR REFERENCE UI\Panels\REMOVE UiCue.cs" />
-    <Compile Include="FOR REFERENCE UI\SRL\SourceListSubpageReferenceList.cs" />
     <Compile Include="Room\Types\EssentialsHuddleSpaceRoom.cs" />
     <Compile Include="UI\EssentialsTouchpanelController.cs" />
     <Compile Include="UI\SubpageReferenceListSourceItem.cs" />
     <None Include="app.config" />
     <None Include="Properties\ControlSystem.cfg" />
-    <EmbeddedResource Include="SGD\PepperDash Essentials iPad.sgd" />
-    <EmbeddedResource Include="SGD\PepperDash Essentials TSW-560.sgd" />
-    <EmbeddedResource Include="SGD\PepperDash Essentials TSW-760.sgd" />
+    <EmbeddedResource Include="SGD\PepperDash Essentials iPad.sgd">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
+    <EmbeddedResource Include="SGD\PepperDash Essentials TSW-560.sgd">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
+    <EmbeddedResource Include="SGD\PepperDash Essentials TSW-760.sgd">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\essentials-framework\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj">

PepperDashEssentials/Properties/AssemblyInfo.cs

@@ -3,6 +3,6 @@
 [assembly: AssemblyTitle("PepperDashEssentials")]
 [assembly: AssemblyCompany("PepperDash Technology Corp")]
 [assembly: AssemblyProduct("PepperDashEssentials")]
-[assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2017")]
-[assembly: AssemblyVersion("1.2.4.*")]
+[assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2018")]
+[assembly: AssemblyVersion("1.4.0.*")]
 

PepperDashEssentials/Properties/ControlSystem.cfg

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

PepperDashEssentials/Properties/UpdateAssemblyVersion.ps1

@@ -0,0 +1,35 @@
+function Update-SourceVersion
+{
+    Param ([string]$Version)
+    $NewVersion = ‘AssemblyVersion("‘ + $Version + ‘.*")’;
+    foreach ($o in $input)
+    {
+        Write-output $o.FullName
+        $TmpFile = $o.FullName + “.tmp”
+        get-content $o.FullName |
+        %{$_ -replace ‘AssemblyVersion\("(\d+\.\d+\.\d+)\.\*"\)’, $NewVersion  }  > $TmpFile
+        move-item $TmpFile $o.FullName -force
+    }
+}
+
+function Update-AllAssemblyInfoFiles ( $version )
+{
+    foreach ($file in “AssemblyInfo.cs”, “AssemblyInfo.vb” )
+    {
+        get-childitem -recurse |? {$_.Name -eq $file} | Update-SourceVersion $version ;
+    }
+}
+
+# validate arguments
+$r= [System.Text.RegularExpressions.Regex]::Match($args[0], "^\d+\.\d+\.\d+$");
+if ($r.Success)
+{
+    Update-AllAssemblyInfoFiles $args[0];
+}
+else
+{
+    echo ” “;
+    echo “Error: Input version does not match x.y.z format!”
+    echo ” “;
+    echo "Unable to apply version to AssemblyInfo.cs files";
+}

PepperDashEssentials/REMOVE EssentialsApp.cs

@@ -1,69 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using Crestron.SimplSharp;
-//using Crestron.SimplSharp.CrestronIO;
-//using Crestron.SimplSharpPro;
-//using Crestron.SimplSharpPro.DeviceSupport;
-//using Crestron.SimplSharpPro.CrestronThread;
-//using Crestron.SimplSharpPro.Diagnostics;
-//using Crestron.SimplSharpPro.EthernetCommunication;
-//using Crestron.SimplSharpPro.UI;
-
-//using Crestron.SimplSharpPro.DM;
-//using Crestron.SimplSharpPro.DM.Cards;
-//using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-
-//using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.Core.Devices;
-////using PepperDash.Essentials.Core.Devices.Dm;
-
-//using PepperDash.Essentials.Displays;
-
-////using PepperDash.Essentials.Core.Http;
-//using PepperDash.Core;
-
-
-//namespace PepperDash.Essentials
-//{
-//    public class EssentialsApp
-//    {
-//        public string ConfigPath { get; set; }
-
-//        public Dictionary<string, Room> Rooms { get; private set; }
-
-//        //EssentialsHttpApiHandler ApiHandler; // MOVE ???????????????????
-
-//        public EssentialsApp(CrestronControlSystem cs)
-//        {
-//            // Use a fake license manager for now
-//            Global.LicenseManager = PepperDash.Essentials.License.MockEssentialsLicenseManager.Manager;
-			
-			
-//            // ---------------------------------- Make this configurable
-//            //var server = Global.HttpConfigServer;
-//            //server.Start(8081, "HttpConfigServer");
-//            //ConfigPath = string.Format(@"\NVRAM\Program{0}\EssentialsConfiguration.json",
-//            //    InitialParametersClass.ApplicationNumber);
-//            //ApiHandler = new EssentialsHttpApiHandler(server, ConfigPath, @"\HTML\presets\lists\");
-
-//            Debug.Console(0, "\r\r--------------------CONFIG BEGIN--------------------\r");
-//            Configuration.Initialize(cs);
-//            Configuration.ReadConfiguration(ConfigPath);
-//            Debug.Console(0, "\r--------------------CONFIG END----------------------\r\r");
-//        }
-//    }
-
-//    public class ResponseToken
-//    {
-//        public string Token { get; private set; }
-//        public DateTime Expires { get; private set; }
-//        public bool IsExpired { get { return Expires < DateTime.Now; } }
-
-//        public ResponseToken(int timeoutMinutes)
-//        {
-//            Expires = DateTime.Now.AddMinutes(timeoutMinutes);
-//            Token = Guid.NewGuid().ToString();
-//        }
-//    }
-//}

PepperDashEssentials/Room/Config/EssentialsDualDisplayRoomPropertiesConfig.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    public class EssentialsDualDisplayRoomPropertiesConfig : EssentialsNDisplayRoomPropertiesConfig
+    {
+
+    }
+}

PepperDashEssentials/Room/Config/EssentialsHuddleVtc1PropertiesConfig.cs

@@ -8,17 +8,10 @@ using Newtonsoft.Json;
 namespace PepperDash.Essentials.Room.Config
 {
 
-    public class EssentialsHuddleVtc1PropertiesConfig : EssentialsRoomPropertiesConfig
+    public class EssentialsHuddleVtc1PropertiesConfig : EssentialsConferenceRoomPropertiesConfig
     {
 		[JsonProperty("defaultDisplayKey")]
 		public string DefaultDisplayKey { get; set; }
-		[JsonProperty("defaultAudioKey")]
-		public string DefaultAudioKey { get; set; }
-		[JsonProperty("sourceListKey")]
-		public string SourceListKey { get; set; }
-		[JsonProperty("defaultSourceItem")]
-		public string DefaultSourceItem { get; set; }
-		[JsonProperty("videoCodecKey")]
-		public string VideoCodecKey { get; set; }
+
     }
 }