fix: adds condition to handle legacy and current portal URL structures and adds null check for getting list types in basic config helper methods

Feature 2.0.0/routing cooldown fixes

src/PepperDash.Essentials.Core/Bridges/BridgeBase.cs

@@ -3,7 +3,7 @@
 using System;
 using System.Collections.Generic;
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.EthernetCommunication;
@@ -168,7 +168,7 @@ namespace PepperDash.Essentials.Core.Bridges
 
                 Debug.LogMessage(LogEventLevel.Debug, this, "Linking Device: '{0}'", device.Key);
 
-                if (!typeof(IBridgeAdvanced).IsAssignableFrom(device.GetType().GetCType()))
+                if (!typeof(IBridgeAdvanced).IsAssignableFrom(device.GetType().GetType()))
                 {
                     Debug.LogMessage(LogEventLevel.Information, this,
                         "{0} is not compatible with this bridge type. Please use 'eiscapi' instead, or updae the device.",

src/PepperDash.Essentials.Core/Comm and IR/ComPortController.cs

@@ -101,6 +101,7 @@ namespace PepperDash.Essentials.Core
 				if (StreamDebugging.RxStreamDebuggingIsEnabled)
 					Debug.LogMessage(LogEventLevel.Information, this, "Received: '{0}'", ComTextHelper.GetEscapedText(bytes));
                 bytesHandler(this, new GenericCommMethodReceiveBytesArgs(bytes));
+				return;
             }
             var textHandler = TextReceived;
             if (textHandler != null)
@@ -108,7 +109,10 @@ namespace PepperDash.Essentials.Core
 				if (StreamDebugging.RxStreamDebuggingIsEnabled)
 					Debug.LogMessage(LogEventLevel.Information, this, "Received: '{0}'", s);
                 textHandler(this, new GenericCommMethodReceiveTextArgs(s));
+				return;
             }
+
+			Debug.LogMessage(LogEventLevel.Warning, this, "Received data but no handler is registered");
         }
 
 		public override bool Deactivate()

src/PepperDash.Essentials.Core/Comm and IR/ComSpecJsonConverter.cs

@@ -23,12 +23,12 @@ namespace PepperDash.Essentials.Core
     {
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
-            if (objectType == typeof(ComPort.ComPortSpec))
+            if (objectType == typeof(ComPort.ComPortSpec?))
             {
                 var newSer = new JsonSerializer();
                 newSer.Converters.Add(new ComSpecPropsJsonConverter());
                 newSer.ObjectCreationHandling = ObjectCreationHandling.Replace;
-                return newSer.Deserialize<ComPort.ComPortSpec>(reader);
+                return newSer.Deserialize<ComPort.ComPortSpec?>(reader);
             }
             return null;
         }
@@ -38,7 +38,7 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public override bool CanConvert(Type objectType)
         {
-            return objectType == typeof(ComPort.ComPortSpec);
+            return objectType == typeof(ComPort.ComPortSpec?);
         }
 
         public override bool CanRead { get { return true; } }

src/PepperDash.Essentials.Core/Comm and IR/CommFactory.cs

@@ -51,7 +51,7 @@ namespace PepperDash.Essentials.Core
 				switch (controlConfig.Method)
 				{
 					case eControlMethod.Com:
-						comm = new ComPortController(deviceConfig.Key + "-com", GetComPort, controlConfig.ComParams, controlConfig);
+						comm = new ComPortController(deviceConfig.Key + "-com", GetComPort, controlConfig.ComParams.Value, controlConfig);
 						break;
                     case eControlMethod.Cec:
                         comm = new CecPortController(deviceConfig.Key + "-cec", GetCecPort, controlConfig);
@@ -115,7 +115,7 @@ namespace PepperDash.Essentials.Core
 			var comPar = config.ComParams;
 			var dev = GetIComPortsDeviceFromManagedDevice(config.ControlPortDevKey);
 			if (dev != null && config.ControlPortNumber <= dev.NumberOfComPorts)
-				return dev.ComPorts[config.ControlPortNumber];
+				return dev.ComPorts[config.ControlPortNumber.Value];
 			Debug.LogMessage(LogEventLevel.Information, "GetComPort: Device '{0}' does not have com port {1}", config.ControlPortDevKey, config.ControlPortNumber);
 			return null;
 		}
@@ -201,23 +201,26 @@ namespace PepperDash.Essentials.Core
     /// <summary>
     /// 
     /// </summary>
-    public class EssentialsControlPropertiesConfig : 
-        PepperDash.Core.ControlPropertiesConfig
+    public class EssentialsControlPropertiesConfig :
+        ControlPropertiesConfig
     {
 
+        [JsonProperty("comParams", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(ComSpecJsonConverter))]
-        public ComPort.ComPortSpec ComParams { get; set; }		
+        public ComPort.ComPortSpec? ComParams { get; set; }
 
-		public string CresnetId { get; set; }
+        [JsonProperty("cresnetId", NullValueHandling = NullValueHandling.Ignore)]
+        public string CresnetId { get; set; }
 
         /// <summary>
         /// Attempts to provide uint conversion of string CresnetId
         /// </summary>
+        [JsonIgnore]
         public uint CresnetIdInt
         {
             get
             {
-                try 
+                try
                 {
                     return Convert.ToUInt32(CresnetId, 16);
                 }
@@ -228,11 +231,13 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        [JsonProperty("infinetId", NullValueHandling = NullValueHandling.Ignore)]
         public string InfinetId { get; set; }
 
         /// <summary>
         /// Attepmts to provide uiont conversion of string InifinetId
         /// </summary>
+        [JsonIgnore]
         public uint InfinetIdInt
         {
             get

src/PepperDash.Essentials.Core/Config/AudioControlPointListItem.cs

@@ -0,0 +1,20 @@
+using Crestron.SimplSharpPro;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.Config
+{
+    public class AudioControlPointListItem
+    {
+        [JsonProperty("levelControls")]
+        public Dictionary<string, LevelControlListItem> LevelControls { get; set; } = new Dictionary<string, LevelControlListItem>();
+
+        [JsonProperty("presets")]
+        public Dictionary<string, PresetListItem> Presets { get; set; } = new Dictionary<string, PresetListItem>();
+
+    }
+}

src/PepperDash.Essentials.Core/Config/BasicConfig.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using Newtonsoft.Json;
 
 using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core.Devices;
 
 namespace PepperDash.Essentials.Core.Config
 {
@@ -25,8 +26,11 @@ namespace PepperDash.Essentials.Core.Config
         [JsonProperty("destinationLists")]
         public Dictionary<string, Dictionary<string, DestinationListItem>> DestinationLists { get; set; }
 
-        [JsonProperty("levelControlLists")]
-        public Dictionary<string, Dictionary<string, LevelControlListItem>> LevelControlLists { get; set; }
+        [JsonProperty("audioControlPointLists")]
+        public Dictionary<string, AudioControlPointListItem> AudioControlPointLists { get; set; }
+
+        [JsonProperty("cameraLists")]
+        public Dictionary<string, Dictionary<string, CameraListItem>> CameraLists { get; set; }
 
         [JsonProperty("tieLines")]
 		public List<TieLineConfig> TieLines { get; set; }
@@ -40,7 +44,8 @@ namespace PepperDash.Essentials.Core.Config
             Devices = new List<DeviceConfig>();
             SourceLists = new Dictionary<string, Dictionary<string, SourceListItem>>();
             DestinationLists = new Dictionary<string, Dictionary<string, DestinationListItem>>();
-            LevelControlLists = new Dictionary<string, Dictionary<string, LevelControlListItem>>();
+            AudioControlPointLists = new Dictionary<string, AudioControlPointListItem>();
+            CameraLists = new Dictionary<string, Dictionary<string, CameraListItem>>();
             TieLines = new List<TieLineConfig>();
             JoinMaps = new Dictionary<string, JObject>();
         }
@@ -50,7 +55,7 @@ namespace PepperDash.Essentials.Core.Config
 		/// </summary>
 		public Dictionary<string, SourceListItem> GetSourceListForKey(string key)
 		{
-			if (string.IsNullOrEmpty(key) || !SourceLists.ContainsKey(key))
+			if (SourceLists == null || string.IsNullOrEmpty(key) || !SourceLists.ContainsKey(key))
 				return null;
 			
 			return SourceLists[key];
@@ -63,25 +68,36 @@ namespace PepperDash.Essentials.Core.Config
         /// <returns>DestinationList if the key exists, null otherwise</returns>
 	    public Dictionary<string, DestinationListItem> GetDestinationListForKey(string key)
 	    {
-	        if (string.IsNullOrEmpty(key) || !DestinationLists.ContainsKey(key))
+	        if (DestinationLists == null || string.IsNullOrEmpty(key) || !DestinationLists.ContainsKey(key))
 	        {
 	            return null;
 	        }
 
 	        return DestinationLists[key];
-	    } 
+	    }
 
         /// <summary>
-        /// Retrieves a LevelControlList based on the key
+        /// Retrieves a AudioControlPointList based on the key
         /// </summary>
         /// <param name="key">key of the list to retrieve</param>
-        /// <returns>LevelControlList if the key exists, null otherwise</returns>
-        public Dictionary<string, LevelControlListItem> GetLevelControlListForKey(string key)
+        /// <returns>AudioControlPointList if the key exists, null otherwise</returns>
+        public AudioControlPointListItem GetAudioControlPointListForKey(string key)
         {
-            if (string.IsNullOrEmpty(key) || !LevelControlLists.ContainsKey(key))
+            if (AudioControlPointLists == null ||  string.IsNullOrEmpty(key) || !AudioControlPointLists.ContainsKey(key))
                 return null;
 
-            return LevelControlLists[key];
+            return AudioControlPointLists[key];
+        }
+
+        /// <summary>
+        /// Checks CameraLists for a given list and returns it if found. Otherwise, returns null
+        /// </summary>
+        public Dictionary<string, CameraListItem> GetCameraListForKey(string key)
+        {
+            if (CameraLists == null || string.IsNullOrEmpty(key) || !CameraLists.ContainsKey(key))
+                return null;
+
+            return CameraLists[key];
         }
 
         /// <summary>

src/PepperDash.Essentials.Core/Config/Essentials/EssentialsConfig.cs

@@ -31,9 +31,17 @@ namespace PepperDash.Essentials.Core.Config
 				if (string.IsNullOrEmpty(SystemUrl))
 					return "missing url";
 
-                var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
+				if (SystemUrl.Contains("#"))
+				{
+					var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
+					string uuid = result.Groups[1].Value;
+					return uuid;
+				} else
+				{
+                    var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/.*");
+                    string uuid = result.Groups[1].Value;
+                    return uuid;
+                }
             }
         }
 
@@ -44,10 +52,18 @@ namespace PepperDash.Essentials.Core.Config
             {
 				if (string.IsNullOrEmpty(TemplateUrl))
 					return "missing template url";
-       
-				var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
+
+				if (TemplateUrl.Contains("#"))
+				{
+					var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
+					string uuid = result.Groups[1].Value;
+					return uuid;
+				} else
+				{
+                    var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/system-templates\/(.*)\/system-template-versions\/(.*)\/.*");
+                    string uuid = result.Groups[2].Value;
+                    return uuid;
+                }
             }
         }
 

src/PepperDash.Essentials.Core/Config/InfoConfig.cs

@@ -1,18 +1,16 @@
 
 
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-
-using Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.Config
 {
-	/// <summary>
-	/// Represents the info section of a Config file
-	/// </summary>
-	public class InfoConfig
+    /// <summary>
+    /// Represents the info section of a Config file
+    /// </summary>
+    public class InfoConfig
 	{
 		[JsonProperty("name")]
 		public string Name { get; set; }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IHasInputs.cs

@@ -15,8 +15,22 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// <example>
     /// See MockDisplay for example implemntation
     /// </example>
+    [Obsolete("Use IHasInputs<T> instead.  Will be removed for 2.0 release")]
     public interface IHasInputs<T, TSelector>: IKeyName
     {
         ISelectableItems<T> Inputs { get; }
     }
+
+
+    /// <summary>
+    /// Describes a device that has selectable inputs
+    /// </summary>
+    /// <typeparam name="T">the type to use as the key for each input item. Most likely an enum or string</typeparam>\
+    /// <example>
+    /// See MockDisplay for example implemntation
+    /// </example>
+    public interface IHasInputs<T> : IKeyName
+    {
+        ISelectableItems<T> Inputs { get; }
+    }
 }

src/PepperDash.Essentials.Core/Devices/AudioControlListItemBase.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core
+{
+    public abstract class AudioControlListItemBase
+    {
+        [JsonProperty("parentDeviceKey")]
+        public string ParentDeviceKey { get; set; }
+
+        [JsonProperty("itemKey")]
+        public string ItemKey { get; set; }
+
+        /// <summary>
+        /// A name that will override the items's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Indicates if the item should be included in the user accessible list
+        /// </summary>
+        [JsonProperty("includeInUserList")]
+        public bool IncludeInUserList { get; set; }
+
+        /// <summary>
+        /// Used to specify the order of the items in the source list when displayed
+        /// </summary>
+        [JsonProperty("order")]
+        public int Order { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/Devices/CameraListItem.cs

@@ -0,0 +1,76 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    public class CameraListItem
+    {
+        [JsonProperty("deviceKey")]
+        public string DeviceKey { get; set; }
+
+        /// <summary>
+        /// Returns the source Device for this, if it exists in DeviceManager
+        /// </summary>
+        [JsonIgnore]
+        public Device CameraDevice
+        {
+            get
+            {
+                if (_cameraDevice == null)
+                    _cameraDevice = DeviceManager.GetDeviceForKey(DeviceKey) as Device;
+                return _cameraDevice;
+            }
+        }
+        Device _cameraDevice;
+
+        /// <summary>
+        /// Gets either the source's Name or this AlternateName property, if 
+        /// defined.  If source doesn't exist, returns "Missing source"
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(Name))
+                {
+                    if (CameraDevice == null)
+                        return "---";
+                    return CameraDevice.Name;
+                }
+                return Name;
+            }
+        }
+
+        /// <summary>
+        /// A name that will override the source's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+
+        /// <summary>
+        /// Specifies and icon for the source list item
+        /// </summary>
+        [JsonProperty("icon")]
+        public string Icon { get; set; }
+
+        /// <summary>
+        /// Alternate icon
+        /// </summary>
+		[JsonProperty("altIcon", NullValueHandling = NullValueHandling.Ignore)]
+        public string AltIcon { get; set; }
+
+        /// <summary>
+        /// Indicates if the item should be included in the user facing list
+        /// </summary>
+		[JsonProperty("includeInUserList")]
+        public bool IncludeInUserList { get; set; }
+
+        /// <summary>
+        /// Used to specify the order of the items in the source list when displayed
+        /// </summary>
+		[JsonProperty("order")]
+        public int Order { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/Devices/DeviceJsonApi.cs

@@ -1,131 +1,198 @@
 
 
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using Serilog.Events;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-using Newtonsoft.Json;
-
-using PepperDash.Core;
-using Serilog.Events;
+using System.Reflection;
+using System.Threading.Tasks;
 
 
 namespace PepperDash.Essentials.Core
 {
-	public class DeviceJsonApi
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="json"></param>
-		public static void DoDeviceActionWithJson(string json)
-		{
-		    if (String.IsNullOrEmpty(json))
-		    {
-		        CrestronConsole.ConsoleCommandResponse(
-		            "Please provide a JSON object matching the format {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}.\r\nIf the method has no parameters, the \"params\" object may be omitted.");
-		        return;
-		    }
-		    try
-		    {
-		        var action = JsonConvert.DeserializeObject<DeviceActionWrapper>(json);
+    public class DeviceJsonApi
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="json"></param>
+        public static void DoDeviceActionWithJson(string json)
+        {
+            if (String.IsNullOrEmpty(json))
+            {
+                CrestronConsole.ConsoleCommandResponse(
+                    "Please provide a JSON object matching the format {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}.\r\nIf the method has no parameters, the \"params\" object may be omitted.");
+                return;
+            }
+            try
+            {
+                var action = JsonConvert.DeserializeObject<DeviceActionWrapper>(json);
 
-		        DoDeviceAction(action);
-		    }
-		    catch (Exception ex)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Incorrect format for JSON. Please check that the format matches {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}");
-		    }
-		    
-		}
+                DoDeviceAction(action);
+            }
+            catch (Exception)
+            {
+                CrestronConsole.ConsoleCommandResponse("Incorrect format for JSON. Please check that the format matches {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}");
+            }
+
+        }
 
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="action"></param>
-		public static void DoDeviceAction(DeviceActionWrapper action)
-		{
-			var key = action.DeviceKey;
-			var obj = FindObjectOnPath(key);
-		    if (obj == null)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Unable to find object at path {0}", key);
-		        return;
-		    }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="action"></param>
+        public static void DoDeviceAction(DeviceActionWrapper action)
+        {
+            var key = action.DeviceKey;
+            var obj = FindObjectOnPath(key);
+            if (obj == null)
+            {
+                CrestronConsole.ConsoleCommandResponse("Unable to find object at path {0}", key);
+                return;
+            }
 
-		    if (action.Params == null)
-		    {
+            if (action.Params == null)
+            {
                 //no params, so setting action.Params to empty array
-		        action.Params = new object[0];
-		    }
+                action.Params = new object[0];
+            }
 
-		    CType t = obj.GetType();
-		    try
-		    {
-		        var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
+            Type t = obj.GetType();
+            try
+            {
+                var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
 
-		        var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
+                var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
 
-		        if (method == null)
-		        {
-		            CrestronConsole.ConsoleCommandResponse(
-		                "Unable to find method with name {0} and that matches parameters {1}", action.MethodName,
-		                action.Params);
-		            return;
-		        }
+                if (method == null)
+                {
+                    CrestronConsole.ConsoleCommandResponse(
+                        "Unable to find method with name {0} and that matches parameters {1}", action.MethodName,
+                        action.Params);
+                    return;
+                }
                 var mParams = method.GetParameters();
 
                 var convertedParams = mParams
                                     .Select((p, i) => ConvertType(action.Params[i], p.ParameterType))
                                     .ToArray();
-                method.Invoke(obj, convertedParams);
 
-		        CrestronConsole.ConsoleCommandResponse("Method {0} successfully called on device {1}", method.Name,
-		            action.DeviceKey);
-		    }
-		    catch (Exception ex)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Unable to call method with name {0}. {1}", action.MethodName,
-		            ex.Message);}
-		}
+                Task.Run(() =>
+                    {
+                        try
+                        {
+                            Debug.LogMessage(LogEventLevel.Verbose, "Calling method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                            method.Invoke(obj, convertedParams);
+                        }
+                        catch (Exception e)
+                        {
+                            Debug.LogMessage(e, "Error invoking method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                        }
+                    });
 
-	    private static object ConvertType(object value, Type conversionType)
-	    {
-	        if (!conversionType.IsEnum)
-	        {
-	            return Convert.ChangeType(value, conversionType, System.Globalization.CultureInfo.InvariantCulture);
-	        }
+                CrestronConsole.ConsoleCommandResponse("Method {0} successfully called on device {1}", method.Name,
+                    action.DeviceKey);
+            }
+            catch (Exception ex)
+            {
+                CrestronConsole.ConsoleCommandResponse("Unable to call method with name {0}. {1}", action.MethodName,
+                    ex.Message);
+            }
+        }
 
-	        var stringValue = Convert.ToString(value);
+        public static async Task DoDeviceActionAsync(DeviceActionWrapper action)
+        {
+            var key = action.DeviceKey;
+            var obj = FindObjectOnPath(key);
+            if (obj == null)
+            {
+                Debug.LogMessage(LogEventLevel.Warning, "Unable to find object at path {deviceKey}", null, key);
+                return;
+            }
 
-	        if (String.IsNullOrEmpty(stringValue))
-	        {
-	            throw new InvalidCastException(
-	                String.Format("{0} cannot be converted to a string prior to conversion to enum"));
-	        }
-	        return Enum.Parse(conversionType, stringValue, true);
-	    }
+            if (action.Params == null)
+            {
+                //no params, so setting action.Params to empty array
+                action.Params = new object[0];
+            }
 
-		/// <summary>
-		/// Gets the properties on a device
-		/// </summary>
-		/// <param name="key"></param>
-		/// <returns></returns>
-		public static string GetProperties(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+            Type t = obj.GetType();
+            try
+            {
+                var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
 
-			CType t = obj.GetType();
-			// get the properties and set them into a new collection of NameType wrappers
-			var props = t.GetProperties().Select(p => new PropertyNameType(p, obj));
-			return JsonConvert.SerializeObject(props, Formatting.Indented);
-		}
+                var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
+
+                if (method == null)
+                {
+                    Debug.LogMessage(LogEventLevel.Warning,
+                        "Unable to find method with name {methodName} and that matches parameters {@parameters}", null, action.MethodName,
+                        action.Params);
+                    return;
+                }
+                var mParams = method.GetParameters();
+
+                var convertedParams = mParams
+                                    .Select((p, i) => ConvertType(action.Params[i], p.ParameterType))
+                                    .ToArray();
+
+                await Task.Run(() =>
+                {
+                    try
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Calling method {methodName} on device {deviceKey} with {@params}", null, method.Name, action.DeviceKey, action.Params);
+                        method.Invoke(obj, convertedParams);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogMessage(e, "Error invoking method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                    }
+                });
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Unable to call method with name {methodName} with {@parameters}", null, action.MethodName, action.Params);
+            }
+        }
+
+        private static object ConvertType(object value, Type conversionType)
+        {
+            if (!conversionType.IsEnum)
+            {
+                return Convert.ChangeType(value, conversionType, System.Globalization.CultureInfo.InvariantCulture);
+            }
+
+            var stringValue = Convert.ToString(value);
+
+            if (String.IsNullOrEmpty(stringValue))
+            {
+                throw new InvalidCastException(
+                    String.Format("{0} cannot be converted to a string prior to conversion to enum"));
+            }
+            return Enum.Parse(conversionType, stringValue, true);
+        }
+
+        /// <summary>
+        /// Gets the properties on a device
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetProperties(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
+
+            Type t = obj.GetType();
+            // get the properties and set them into a new collection of NameType wrappers
+            var props = t.GetProperties().Select(p => new PropertyNameType(p, obj));
+            return JsonConvert.SerializeObject(props, Formatting.Indented);
+        }
 
         /// <summary>
         /// Gets a property from a device path by name
@@ -136,10 +203,10 @@ namespace PepperDash.Essentials.Core
         public static object GetPropertyByName(string deviceObjectPath, string propertyName)
         {
             var dev = FindObjectOnPath(deviceObjectPath);
-            if(dev == null)
+            if (dev == null)
                 return "{ \"error\":\"No Device\"}";
-	
-            object prop = dev.GetType().GetCType().GetProperty(propertyName).GetValue(dev, null);
+
+            object prop = dev.GetType().GetType().GetProperty(propertyName).GetValue(dev, null);
 
             // var prop = t.GetProperty(propertyName);
             if (prop != null)
@@ -153,126 +220,126 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-		/// <summary>
-		/// Gets the methods on a device
-		/// </summary>
-		/// <param name="key"></param>
-		/// <returns></returns>
-		public static string GetMethods(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+        /// <summary>
+        /// Gets the methods on a device
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetMethods(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
 
-			// Package up method names using helper objects
-			CType t = obj.GetType();
-			var methods = t.GetMethods()
-				.Where(m => !m.IsSpecialName)
-				.Select(p => new MethodNameParams(p));
-			return JsonConvert.SerializeObject(methods, Formatting.Indented);
-		}
+            // Package up method names using helper objects
+            Type t = obj.GetType();
+            var methods = t.GetMethods()
+                .Where(m => !m.IsSpecialName)
+                .Select(p => new MethodNameParams(p));
+            return JsonConvert.SerializeObject(methods, Formatting.Indented);
+        }
 
-		public static string GetApiMethods(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+        public static string GetApiMethods(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
 
-			// Package up method names using helper objects
-			CType t = obj.GetType();
-			var methods = t.GetMethods()
-				.Where(m => !m.IsSpecialName)
-				.Where(m => m.GetCustomAttributes(typeof(ApiAttribute), true).Any())
-				.Select(p => new MethodNameParams(p));
-			return JsonConvert.SerializeObject(methods, Formatting.Indented);
-		}
-			
+            // Package up method names using helper objects
+            Type t = obj.GetType();
+            var methods = t.GetMethods()
+                .Where(m => !m.IsSpecialName)
+                .Where(m => m.GetCustomAttributes(typeof(ApiAttribute), true).Any())
+                .Select(p => new MethodNameParams(p));
+            return JsonConvert.SerializeObject(methods, Formatting.Indented);
+        }
 
-		/// <summary>
-		///  Walks down a dotted object path, starting with a Device, and returns the object
-		///  at the end of the path
-		/// </summary>
-		public static object FindObjectOnPath(string deviceObjectPath)
-		{
-			var path = deviceObjectPath.Split('.');
 
-			var dev = DeviceManager.GetDeviceForKey(path[0]);
-			if (dev == null)
-			{
-				Debug.LogMessage(LogEventLevel.Information, "Device {0} not found", path[0]);
-				return null;
-			}
+        /// <summary>
+        ///  Walks down a dotted object path, starting with a Device, and returns the object
+        ///  at the end of the path
+        /// </summary>
+        public static object FindObjectOnPath(string deviceObjectPath)
+        {
+            var path = deviceObjectPath.Split('.');
 
-			// loop through any dotted properties
-			object obj = dev;
-			if (path.Length > 1)
-			{
-				for (int i = 1; i < path.Length; i++)
-				{
-					var objName = path[i];
-					string indexStr = null;
-					var indexOpen = objName.IndexOf('[');
-					if (indexOpen != -1)
-					{
-						var indexClose = objName.IndexOf(']');
-						if (indexClose == -1)
-						{
-							Debug.LogMessage(LogEventLevel.Information, dev, "ERROR Unmatched index brackets");
-							return null;
-						}
-						// Get the index and strip quotes if any
-						indexStr = objName.Substring(indexOpen + 1, indexClose - indexOpen - 1).Replace("\"", "");
-						objName = objName.Substring(0, indexOpen);
-						Debug.LogMessage(LogEventLevel.Information, dev, "  Checking for collection '{0}', index '{1}'", objName, indexStr);
-					}
+            var dev = DeviceManager.GetDeviceForKey(path[0]);
+            if (dev == null)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device {0} not found", path[0]);
+                return null;
+            }
 
-					CType oType = obj.GetType();
-					var prop = oType.GetProperty(objName);
-					if (prop == null)
-					{
-						Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} not found on {1}", objName, path[i - 1]);
-						return null;
-					}
-					// if there's an index, try to get the property
-					if (indexStr != null)
-					{
-						if (!typeof(ICollection).IsAssignableFrom(prop.PropertyType))
-						{
-							Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} is not collection", objName);
-							return null;
-						}
-						var collection = prop.GetValue(obj, null) as ICollection;
-						// Get the indexed items "property"
-						var indexedPropInfo = prop.PropertyType.GetProperty("Item");
-						// These are the parameters for the indexing. Only care about one
-						var indexParams = indexedPropInfo.GetIndexParameters();
-						if (indexParams.Length > 0)
-						{
-							Debug.LogMessage(LogEventLevel.Information, "  Indexed, param type: {0}", indexParams[0].ParameterType.Name);
-							var properParam = Convert.ChangeType(indexStr, indexParams[0].ParameterType,
-								System.Globalization.CultureInfo.InvariantCulture);
-							try
-							{
-								obj = indexedPropInfo.GetValue(collection, new object[] { properParam });
-							}
-							// if the index is bad, catch it here.
-							catch (Crestron.SimplSharp.Reflection.TargetInvocationException e)
-							{
-								if (e.InnerException is ArgumentOutOfRangeException)
-									Debug.LogMessage(LogEventLevel.Information, "  Index Out of range");
-								else if (e.InnerException is KeyNotFoundException)
-									Debug.LogMessage(LogEventLevel.Information, "  Key not found");
-								return null;
-							}
-						}
+            // loop through any dotted properties
+            object obj = dev;
+            if (path.Length > 1)
+            {
+                for (int i = 1; i < path.Length; i++)
+                {
+                    var objName = path[i];
+                    string indexStr = null;
+                    var indexOpen = objName.IndexOf('[');
+                    if (indexOpen != -1)
+                    {
+                        var indexClose = objName.IndexOf(']');
+                        if (indexClose == -1)
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, dev, "ERROR Unmatched index brackets");
+                            return null;
+                        }
+                        // Get the index and strip quotes if any
+                        indexStr = objName.Substring(indexOpen + 1, indexClose - indexOpen - 1).Replace("\"", "");
+                        objName = objName.Substring(0, indexOpen);
+                        Debug.LogMessage(LogEventLevel.Information, dev, "  Checking for collection '{0}', index '{1}'", objName, indexStr);
+                    }
 
-					}
-					else
-						obj = prop.GetValue(obj, null);
-				}
-			}
-			return obj;
-		}
+                    Type oType = obj.GetType();
+                    var prop = oType.GetProperty(objName);
+                    if (prop == null)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} not found on {1}", objName, path[i - 1]);
+                        return null;
+                    }
+                    // if there's an index, try to get the property
+                    if (indexStr != null)
+                    {
+                        if (!typeof(ICollection).IsAssignableFrom(prop.PropertyType))
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} is not collection", objName);
+                            return null;
+                        }
+                        var collection = prop.GetValue(obj, null) as ICollection;
+                        // Get the indexed items "property"
+                        var indexedPropInfo = prop.PropertyType.GetProperty("Item");
+                        // These are the parameters for the indexing. Only care about one
+                        var indexParams = indexedPropInfo.GetIndexParameters();
+                        if (indexParams.Length > 0)
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, "  Indexed, param type: {0}", indexParams[0].ParameterType.Name);
+                            var properParam = Convert.ChangeType(indexStr, indexParams[0].ParameterType,
+                                System.Globalization.CultureInfo.InvariantCulture);
+                            try
+                            {
+                                obj = indexedPropInfo.GetValue(collection, new object[] { properParam });
+                            }
+                            // if the index is bad, catch it here.
+                            catch (TargetInvocationException e)
+                            {
+                                if (e.InnerException is ArgumentOutOfRangeException)
+                                    Debug.LogMessage(LogEventLevel.Information, "  Index Out of range");
+                                else if (e.InnerException is KeyNotFoundException)
+                                    Debug.LogMessage(LogEventLevel.Information, "  Key not found");
+                                return null;
+                            }
+                        }
+
+                    }
+                    else
+                        obj = prop.GetValue(obj, null);
+                }
+            }
+            return obj;
+        }
 
         /// <summary>
         /// Sets a property on an object.
@@ -287,7 +354,7 @@ namespace PepperDash.Essentials.Core
             //if (obj == null)
             //    return "{\"error\":\"No object found\"}";
 
-            //CType t = obj.GetType();
+            //Type t = obj.GetType();
 
 
             //// get the properties and set them into a new collection of NameType wrappers
@@ -295,78 +362,85 @@ namespace PepperDash.Essentials.Core
             //return JsonConvert.SerializeObject(props, Formatting.Indented);
         }
 
-        
-	}
 
-	public class DeviceActionWrapper
-	{
-		public string DeviceKey { get; set; }
-		public string MethodName { get; set; }
-		public object[] Params { get; set; }
-	}
+    }
 
-	public class PropertyNameType
-	{
-        object Parent;
+    public class DeviceActionWrapper
+    {
+        public string DeviceKey { get; set; }
+        public string MethodName { get; set; }
+        public object[] Params { get; set; }
+    }
 
-		[JsonIgnore]
-		public PropertyInfo PropInfo { get; private set; }
-		public string Name { get { return PropInfo.Name; } }
-		public string Type { get { return PropInfo.PropertyType.Name; } }
-        public string Value { get 
+    public class PropertyNameType
+    {
+        private object Parent;
+
+        [JsonIgnore]
+        public PropertyInfo PropInfo { get; private set; }
+        public string Name { get { return PropInfo.Name; } }
+        public string Type { get { return PropInfo.PropertyType.Name; } }
+        public string Value
         {
-            if (PropInfo.CanRead)
+            get
             {
-                try
+                if (PropInfo.CanRead)
                 {
-                    return PropInfo.GetValue(Parent, null).ToString();
+                    try
+                    {
+                        return PropInfo.GetValue(Parent, null).ToString();
+                    }
+                    catch (Exception)
+                    {
+                        return null;
+                    }
                 }
-                catch (Exception)
-                {
+                else
                     return null;
-                }
             }
-            else
-                return null;    
-        } }
+        }
 
         public bool CanRead { get { return PropInfo.CanRead; } }
         public bool CanWrite { get { return PropInfo.CanWrite; } }
 
 
-		public PropertyNameType(PropertyInfo info, object parent)
-		{
-			PropInfo = info;
+        public PropertyNameType(PropertyInfo info, object parent)
+        {
+            PropInfo = info;
             Parent = parent;
-		}
-	}
+        }
+    }
 
-	public class MethodNameParams
-	{
-		[JsonIgnore]
-		public MethodInfo MethodInfo { get; private set; }
+    public class MethodNameParams
+    {
+        [JsonIgnore]
+        public MethodInfo MethodInfo { get; private set; }
 
-		public string Name { get { return MethodInfo.Name; } }
-		public IEnumerable<NameType> Params { get {
-			return MethodInfo.GetParameters().Select(p => 
-				new NameType { Name = p.Name, Type = p.ParameterType.Name });
-		} }
+        public string Name { get { return MethodInfo.Name; } }
+        public IEnumerable<NameType> Params
+        {
+            get
+            {
+                return MethodInfo.GetParameters().Select(p =>
+                    new NameType { Name = p.Name, Type = p.ParameterType.Name });
+            }
+        }
 
-		public MethodNameParams(MethodInfo info)
-		{
-			MethodInfo = info;
-		}
-	}
+        public MethodNameParams(MethodInfo info)
+        {
+            MethodInfo = info;
+        }
+    }
 
-	public class NameType
-	{
-		public string Name { get; set; }
-		public string Type { get; set; }
-	}
+    public class NameType
+    {
+        public string Name { get; set; }
+        public string Type { get; set; }
+    }
 
-	[AttributeUsage(AttributeTargets.All)]
-	public class ApiAttribute : CAttribute
-	{
+    [AttributeUsage(AttributeTargets.All)]
+    public class ApiAttribute : Attribute
+    {
 
-	}
+    }
 }

src/PepperDash.Essentials.Core/Devices/DeviceManager.cs

@@ -1,50 +1,49 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-
 using PepperDash.Core;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
 
 
 namespace PepperDash.Essentials.Core
 {
-	public static class DeviceManager
-	{
+    public static class DeviceManager
+    {
         public static event EventHandler<EventArgs> AllDevicesActivated;
         public static event EventHandler<EventArgs> AllDevicesRegistered;
 
-	    private static readonly CCriticalSection DeviceCriticalSection = new CCriticalSection();
-	    private static readonly CEvent AllowAddDevicesCEvent = new CEvent(false, true);
-		//public static List<Device> Devices { get { return _Devices; } }
-		//static List<Device> _Devices = new List<Device>();
+        private static readonly CCriticalSection DeviceCriticalSection = new CCriticalSection();
+        private static readonly CEvent AllowAddDevicesCEvent = new CEvent(false, true);
 
-		static readonly Dictionary<string, IKeyed> Devices = new Dictionary<string, IKeyed>(StringComparer.OrdinalIgnoreCase);
+        //public static List<Device> Devices { get { return _Devices; } }
+        //static List<Device> _Devices = new List<Device>();
 
-		/// <summary>
-		/// Returns a copy of all the devices in a list
-		/// </summary>
-		public static List<IKeyed> AllDevices { get { return new List<IKeyed>(Devices.Values); } }
+        private static readonly Dictionary<string, IKeyed> Devices = new Dictionary<string, IKeyed>(StringComparer.OrdinalIgnoreCase);
 
-	    public static bool AddDeviceEnabled;
+        /// <summary>
+        /// Returns a copy of all the devices in a list
+        /// </summary>
+        public static List<IKeyed> AllDevices { get { return new List<IKeyed>(Devices.Values); } }
 
-		public static void Initialize(CrestronControlSystem cs)
-		{
-		    AddDeviceEnabled = true;
-			CrestronConsole.AddNewConsoleCommand(ListDeviceCommStatuses, "devcommstatus", "Lists the communication status of all devices",
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(ListDeviceFeedbacks, "devfb", "Lists current feedbacks", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(ListDevices, "devlist", "Lists current managed devices", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(DeviceJsonApi.DoDeviceActionWithJson, "devjson", "", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetProperties(s)), "devprops", "", ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetMethods(s)), "devmethods", "", ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetApiMethods(s)), "apimethods", "", ConsoleAccessLevelEnum.AccessOperator);
+        public static bool AddDeviceEnabled;
+
+        public static void Initialize(CrestronControlSystem cs)
+        {
+            AddDeviceEnabled = true;
+            CrestronConsole.AddNewConsoleCommand(ListDeviceCommStatuses, "devcommstatus", "Lists the communication status of all devices",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(ListDeviceFeedbacks, "devfb", "Lists current feedbacks",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(ListDevices, "devlist", "Lists current managed devices",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(DeviceJsonApi.DoDeviceActionWithJson, "devjson", "",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetProperties(s)), "devprops", "", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetMethods(s)), "devmethods", "", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetApiMethods(s)), "apimethods", "", ConsoleAccessLevelEnum.AccessOperator);
             CrestronConsole.AddNewConsoleCommand(SimulateComReceiveOnDevice, "devsimreceive",
                 "Simulates incoming data on a com device", ConsoleAccessLevelEnum.AccessOperator);
 
@@ -52,77 +51,77 @@ namespace PepperDash.Essentials.Core
             CrestronConsole.AddNewConsoleCommand(s => DisableAllDeviceStreamDebugging(), "disableallstreamdebug", "disables stream debugging on all devices", ConsoleAccessLevelEnum.AccessOperator);
         }
 
-		/// <summary>
-		/// Calls activate steps on all Device class items
-		/// </summary>
-		public static void ActivateAll()
-		{
-		    try
-		    {
+        /// <summary>
+        /// Calls activate steps on all Device class items
+        /// </summary>
+        public static void ActivateAll()
+        {
+            try
+            {
                 OnAllDevicesRegistered();
 
-		        DeviceCriticalSection.Enter();
+                DeviceCriticalSection.Enter();
                 AddDeviceEnabled = false;
-		        // PreActivate all devices
-                Debug.LogMessage(LogEventLevel.Information,"****PreActivation starting...****");
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).PreActivate();
-		            }
-		            catch (Exception e)
-		            {
+                // PreActivate all devices
+                Debug.LogMessage(LogEventLevel.Information, "****PreActivation starting...****");
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    {
+                        if (d is Device)
+                            (d as Device).PreActivate();
+                    }
+                    catch (Exception e)
+                    {
                         Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PreActivation failure: {0}", e.Message, d.Key);
                         Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                    }
+                }
                 Debug.LogMessage(LogEventLevel.Information, "****PreActivation complete****");
-		        Debug.LogMessage(LogEventLevel.Information, "****Activation starting...****");
+                Debug.LogMessage(LogEventLevel.Information, "****Activation starting...****");
 
-		        // Activate all devices
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).Activate();
-		            }
-		            catch (Exception e)
-		            {
+                // Activate all devices
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    {
+                        if (d is Device)
+                            (d as Device).Activate();
+                    }
+                    catch (Exception e)
+                    {
                         Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} Activation failure: {0}", e.Message, d.Key);
                         Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                    }
+                }
 
                 Debug.LogMessage(LogEventLevel.Information, "****Activation complete****");
                 Debug.LogMessage(LogEventLevel.Information, "****PostActivation starting...****");
 
-		        // PostActivate all devices
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).PostActivate();
-		            }
-		            catch (Exception e)
-		            {
-		                Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PostActivation failure: {0}", e.Message, d.Key);
-		                Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                // PostActivate all devices
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    {
+                        if (d is Device)
+                            (d as Device).PostActivate();
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PostActivation failure: {0}", e.Message, d.Key);
+                        Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
+                    }
+                }
 
                 Debug.LogMessage(LogEventLevel.Information, "****PostActivation complete****");
 
                 OnAllDevicesActivated();
-		    }
-		    finally
-		    {
+            }
+            finally
+            {
                 DeviceCriticalSection.Leave();
-		    }
-		}
+            }
+        }
 
         private static void OnAllDevicesActivated()
         {
@@ -142,77 +141,76 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-		/// <summary>
-		/// Calls activate on all Device class items
-		/// </summary>
-		public static void DeactivateAll()
-		{
-		    try
-		    {
-		        DeviceCriticalSection.Enter();
-		        foreach (var d in Devices.Values.OfType<Device>())
-		        {
-		            d.Deactivate();
-		        }
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+        /// <summary>
+        /// Calls activate on all Device class items
+        /// </summary>
+        public static void DeactivateAll()
+        {
+            try
+            {
+                DeviceCriticalSection.Enter();
+                foreach (var d in Devices.Values.OfType<Device>())
+                {
+                    d.Deactivate();
+                }
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-		//static void ListMethods(string devKey)
-		//{
-		//    var dev = GetDeviceForKey(devKey);
-		//    if(dev != null)
-		//    {
-		//        var type = dev.GetType().GetCType();
-		//        var methods = type.GetMethods(BindingFlags.Public|BindingFlags.Instance);
-		//        var sb = new StringBuilder();
-		//        sb.AppendLine(string.Format("{2} methods on [{0}] ({1}):", dev.Key, type.Name, methods.Length));
-		//        foreach (var m in methods)
-		//        {
-		//            sb.Append(string.Format("{0}(", m.Name));
-		//            var pars = m.GetParameters();
-		//            foreach (var p in pars)
-		//                sb.Append(string.Format("({1}){0} ", p.Name, p.ParameterType.Name));
-		//            sb.AppendLine(")");
-		//        }
-		//        CrestronConsole.ConsoleCommandResponse(sb.ToString());
-		//    }
-		//}
+        //static void ListMethods(string devKey)
+        //{
+        //    var dev = GetDeviceForKey(devKey);
+        //    if(dev != null)
+        //    {
+        //        var type = dev.GetType().GetType();
+        //        var methods = type.GetMethods(BindingFlags.Public|BindingFlags.Instance);
+        //        var sb = new StringBuilder();
+        //        sb.AppendLine(string.Format("{2} methods on [{0}] ({1}):", dev.Key, type.Name, methods.Length));
+        //        foreach (var m in methods)
+        //        {
+        //            sb.Append(string.Format("{0}(", m.Name));
+        //            var pars = m.GetParameters();
+        //            foreach (var p in pars)
+        //                sb.Append(string.Format("({1}){0} ", p.Name, p.ParameterType.Name));
+        //            sb.AppendLine(")");
+        //        }
+        //        CrestronConsole.ConsoleCommandResponse(sb.ToString());
+        //    }
+        //}
 
-	    private static void ListDevices(string s)
-	    {
-	        Debug.LogMessage(LogEventLevel.Information, "{0} Devices registered with Device Manager:", Devices.Count);
-	        var sorted = Devices.Values.ToList();
-	        sorted.Sort((a, b) => a.Key.CompareTo(b.Key));
+        private static void ListDevices(string s)
+        {
+            Debug.LogMessage(LogEventLevel.Information, "{0} Devices registered with Device Manager:", Devices.Count);
+            var sorted = Devices.Values.ToList();
+            sorted.Sort((a, b) => a.Key.CompareTo(b.Key));
 
-	        foreach (var d in sorted)
-	        {
-	            var name = d is IKeyName ? (d as IKeyName).Name : "---";
-	            Debug.LogMessage(LogEventLevel.Information, "  [{0}] {1}", d.Key, name);
-	        }
-	    }
+            foreach (var d in sorted)
+            {
+                var name = d is IKeyName ? (d as IKeyName).Name : "---";
+                Debug.LogMessage(LogEventLevel.Information, "  [{0}] {1}", d.Key, name);
+            }
+        }
 
-	    private static void ListDeviceFeedbacks(string devKey)
-	    {
-	        var dev = GetDeviceForKey(devKey);
-	        if (dev == null)
-	        {
-	            Debug.LogMessage(LogEventLevel.Information, "Device '{0}' not found", devKey);
-	            return;
-	        }
-	        var statusDev = dev as IHasFeedback;
-	        if (statusDev == null)
-	        {
-	            Debug.LogMessage(LogEventLevel.Information, "Device '{0}' does not have visible feedbacks", devKey);
-	            return;
-	        }
-	        statusDev.DumpFeedbacksToConsole(true);
-	    }
+        private static void ListDeviceFeedbacks(string devKey)
+        {
+            var dev = GetDeviceForKey(devKey);
+            if (dev == null)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device '{0}' not found", devKey);
+                return;
+            }
+            if (!(dev is IHasFeedback statusDev))
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device '{0}' does not have visible feedbacks", devKey);
+                return;
+            }
+            statusDev.DumpFeedbacksToConsole(true);
+        }
 
-	    //static void ListDeviceCommands(string devKey)
+        //static void ListDeviceCommands(string devKey)
         //{
         //    var dev = GetDeviceForKey(devKey);
         //    if (dev == null)
@@ -223,134 +221,132 @@ namespace PepperDash.Essentials.Core
         //    Debug.LogMessage(LogEventLevel.Information, "This needs to be reworked.  Stay tuned.", devKey);
         //}
 
-	    private static void ListDeviceCommStatuses(string input)
-	    {
-	        var sb = new StringBuilder();
-	        foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
-	        {
-	            sb.Append(string.Format("{0}: {1}\r", dev,
-	                dev.CommunicationMonitor.Status));
-	        }
-	        CrestronConsole.ConsoleCommandResponse(sb.ToString());
-	    }
+        private static void ListDeviceCommStatuses(string input)
+        {
+
+            foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
+            {
+                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}{Environment.NewLine}");
+            }
+        }
 
 
-	    //static void DoDeviceCommand(string command)
+        //static void DoDeviceCommand(string command)
         //{
         //    Debug.LogMessage(LogEventLevel.Information, "Not yet implemented.  Stay tuned");
         //}
 
-		public static void AddDevice(IKeyed newDev)
-		{
-		    try
-		    {
-		        if (!DeviceCriticalSection.TryEnter())
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, "Currently unable to add devices to Device Manager. Please try again");
-		            return;
-		        }
-		        // Check for device with same key
-		        //var existingDevice = _Devices.FirstOrDefault(d => d.Key.Equals(newDev.Key, StringComparison.OrdinalIgnoreCase));
-		        ////// If it exists, remove or warn??
-		        //if (existingDevice != null)
+        public static void AddDevice(IKeyed newDev)
+        {
+            try
+            {
+                if (!DeviceCriticalSection.TryEnter())
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Currently unable to add devices to Device Manager. Please try again");
+                    return;
+                }
+                // Check for device with same key
+                //var existingDevice = _Devices.FirstOrDefault(d => d.Key.Equals(newDev.Key, StringComparison.OrdinalIgnoreCase));
+                ////// If it exists, remove or warn??
+                //if (existingDevice != null)
 
-		        if (!AddDeviceEnabled)
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, "All devices have been activated. Adding new devices is not allowed.");
-		            return;
-		        }
+                if (!AddDeviceEnabled)
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "All devices have been activated. Adding new devices is not allowed.");
+                    return;
+                }
 
-		        if (Devices.ContainsKey(newDev.Key))
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, newDev, "WARNING: A device with this key already exists.  Not added to manager");
-		            return;
-		        }
-		        Devices.Add(newDev.Key, newDev);
-		        //if (!(_Devices.Contains(newDev)))
-		        //    _Devices.Add(newDev);
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+                if (Devices.ContainsKey(newDev.Key))
+                {
+                    Debug.LogMessage(LogEventLevel.Information, newDev, "WARNING: A device with this key already exists.  Not added to manager");
+                    return;
+                }
+                Devices.Add(newDev.Key, newDev);
+                //if (!(_Devices.Contains(newDev)))
+                //    _Devices.Add(newDev);
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-	    public static void AddDevice(IEnumerable<IKeyed> devicesToAdd)
-	    {
-	        try
-	        {
-	            if (!DeviceCriticalSection.TryEnter())
-	            {
-	                Debug.LogMessage(LogEventLevel.Information,
-	                    "Currently unable to add devices to Device Manager. Please try again");
-	                return;
-	            }
-	            if (!AddDeviceEnabled)
-	            {
-	                Debug.LogMessage(LogEventLevel.Information,
-	                    "All devices have been activated. Adding new devices is not allowed.");
-	                return;
-	            }
+        public static void AddDevice(IEnumerable<IKeyed> devicesToAdd)
+        {
+            try
+            {
+                if (!DeviceCriticalSection.TryEnter())
+                {
+                    Debug.LogMessage(LogEventLevel.Information,
+                        "Currently unable to add devices to Device Manager. Please try again");
+                    return;
+                }
+                if (!AddDeviceEnabled)
+                {
+                    Debug.LogMessage(LogEventLevel.Information,
+                        "All devices have been activated. Adding new devices is not allowed.");
+                    return;
+                }
 
-	            foreach (var dev in devicesToAdd)
-	            {
-	                try
-	                {
-	                    Devices.Add(dev.Key, dev);
-	                }
-	                catch (ArgumentException ex)
-	                {
-	                    Debug.LogMessage(LogEventLevel.Information, "Error adding device with key {0} to Device Manager: {1}\r\nStack Trace: {2}",
-	                        dev.Key, ex.Message, ex.StackTrace);
-	                }
-	            }
-	        }
-	        finally
-	        {
-	            DeviceCriticalSection.Leave();
-	        }
-	    }
+                foreach (var dev in devicesToAdd)
+                {
+                    try
+                    {
+                        Devices.Add(dev.Key, dev);
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, "Error adding device with key {0} to Device Manager: {1}\r\nStack Trace: {2}",
+                            dev.Key, ex.Message, ex.StackTrace);
+                    }
+                }
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-		public static void RemoveDevice(IKeyed newDev)
-		{
-		    try
-		    {
+        public static void RemoveDevice(IKeyed newDev)
+        {
+            try
+            {
                 DeviceCriticalSection.Enter();
-		        if (newDev == null)
-		            return;
-		        if (Devices.ContainsKey(newDev.Key))
-		            Devices.Remove(newDev.Key);
-		            //if (_Devices.Contains(newDev))
-		            //    _Devices.Remove(newDev);
-		        else
-		            Debug.LogMessage(LogEventLevel.Information, "Device manager: Device '{0}' does not exist in manager.  Cannot remove", newDev.Key);
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+                if (newDev == null)
+                    return;
+                if (Devices.ContainsKey(newDev.Key))
+                    Devices.Remove(newDev.Key);
+                //if (_Devices.Contains(newDev))
+                //    _Devices.Remove(newDev);
+                else
+                    Debug.LogMessage(LogEventLevel.Information, "Device manager: Device '{0}' does not exist in manager.  Cannot remove", newDev.Key);
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-		public static IEnumerable<string> GetDeviceKeys()
-		{
-		        //return _Devices.Select(d => d.Key).ToList();
-		        return Devices.Keys;
-		}
+        public static IEnumerable<string> GetDeviceKeys()
+        {
+            //return _Devices.Select(d => d.Key).ToList();
+            return Devices.Keys;
+        }
 
-		public static IEnumerable<IKeyed> GetDevices()
-		{
-		        //return _Devices.Select(d => d.Key).ToList();
-		        return Devices.Values;
-		}
+        public static IEnumerable<IKeyed> GetDevices()
+        {
+            //return _Devices.Select(d => d.Key).ToList();
+            return Devices.Values;
+        }
 
-		public static IKeyed GetDeviceForKey(string key)
-		{
-		        //return _Devices.FirstOrDefault(d => d.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
-		        if (key != null && Devices.ContainsKey(key))
-		            return Devices[key];
+        public static IKeyed GetDeviceForKey(string key)
+        {
+            //return _Devices.FirstOrDefault(d => d.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            if (key != null && Devices.ContainsKey(key))
+                return Devices[key];
 
-		        return null;
-		}
+            return null;
+        }
 
         /// <summary>
         /// Console handler that simulates com port data receive 
@@ -367,8 +363,7 @@ namespace PepperDash.Essentials.Core
             }
             //Debug.LogMessage(LogEventLevel.Verbose, "**** {0} - {1} ****", match.Groups[1].Value, match.Groups[2].Value);
 
-            var com = GetDeviceForKey(match.Groups[1].Value) as ComPortController;
-            if (com == null)
+            if (!(GetDeviceForKey(match.Groups[1].Value) is ComPortController com))
             {
                 CrestronConsole.ConsoleCommandResponse("'{0}' is not a comm port device", match.Groups[1].Value);
                 return;
@@ -423,16 +418,15 @@ namespace PepperDash.Essentials.Core
             var deviceKey = args[0];
             var setting = args[1];
 
-            var timeout= String.Empty;
+            var timeout = String.Empty;
 
             if (args.Length >= 3)
             {
                 timeout = args[2];
             }
 
-            var device = GetDeviceForKey(deviceKey) as IStreamDebugging;
 
-            if (device == null)
+            if (!(GetDeviceForKey(deviceKey) is IStreamDebugging device))
             {
                 CrestronConsole.ConsoleCommandResponse("Unable to get device with key: {0}", deviceKey);
                 return;
@@ -479,13 +473,11 @@ namespace PepperDash.Essentials.Core
         {
             foreach (var device in AllDevices)
             {
-                var streamDevice = device as IStreamDebugging;
-
-                if (streamDevice != null)
+                if (device is IStreamDebugging streamDevice)
                 {
                     streamDevice.StreamDebugging.SetDebuggingWithDefaultTimeout(eStreamDebuggingSetting.Off);
                 }
             }
         }
-	}
+    }
 }

src/PepperDash.Essentials.Core/Devices/EssentialsDevice.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;

src/PepperDash.Essentials.Core/Devices/IDspPreset.cs

@@ -1,17 +0,0 @@
-using System.Collections.Generic;
-
-namespace PepperDash.Essentials.Core
-{
-    public interface IHasDspPresets
-    {
-        List<IDspPreset> Presets { get; }
-
-        void RecallPreset(IDspPreset preset);
-
-    }
-
-    public interface IDspPreset
-    {
-        string Name { get; }
-    }
-}

src/PepperDash.Essentials.Core/Devices/IDspPresets.cs

@@ -0,0 +1,12 @@
+using PepperDash.Core;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface IDspPresets
+    {
+        Dictionary<string, IKeyName> Presets { get; }
+
+        void RecallPreset(string key);
+    }
+}

src/PepperDash.Essentials.Core/Devices/IHasFeedbacks.cs

@@ -1,7 +1,5 @@
-using System.Collections.Generic;
+using System;
 using System.Linq;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharp.Reflection;
 
 using PepperDash.Core;
 using Serilog.Events;
@@ -23,7 +21,7 @@ namespace PepperDash.Essentials.Core
 	{
 		public static void DumpFeedbacksToConsole(this IHasFeedback source, bool getCurrentStates)
 		{
-            CType t = source.GetType();
+            Type t = source.GetType();
             // get the properties and set them into a new collection of NameType wrappers
             var props = t.GetProperties().Select(p => new PropertyNameType(p, t));
 

src/PepperDash.Essentials.Core/Devices/LevelControlListItem.cs

@@ -5,13 +5,13 @@ using System.Text;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using PepperDash.Core;
+using PepperDash.Essentials.Core.Devices;
 
 namespace PepperDash.Essentials.Core
 {
-    public class LevelControlListItem
+    public class LevelControlListItem : AudioControlListItemBase
     {
-        [JsonProperty("deviceKey")]
-        public string DeviceKey { get; set; }
+
 
         [JsonIgnore]
         public IBasicVolumeWithFeedback LevelControl
@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.Core
             get
             {
                 if (_levelControl == null)
-                    _levelControl = DeviceManager.GetDeviceForKey(DeviceKey) as IBasicVolumeWithFeedback;
+                    _levelControl = DeviceManager.GetDeviceForKey(ParentDeviceKey) as IBasicVolumeWithFeedback;
                 return _levelControl;
             }
         }
@@ -34,8 +34,8 @@ namespace PepperDash.Essentials.Core
             get
             {
                 if (!string.IsNullOrEmpty(Name)) return Name;
-                else 
-                { 
+                else
+                {
                     if (LevelControl is IKeyName namedLevelControl)
                     {
                         if (namedLevelControl == null)
@@ -48,22 +48,11 @@ namespace PepperDash.Essentials.Core
         }
 
         /// <summary>
-        /// A name that will override the items's name on the UI
+        /// The key of the device in the DeviceManager for control
         /// </summary>
-        [JsonProperty("name")]
-        public string Name { get; set; }
-
-        /// <summary>
-        /// Indicates if the item should be included in the user accessible list
-        /// </summary>
-        [JsonProperty("includeInUserList")]
-        public bool IncludeInUserList { get; set; }
-
-        /// <summary>
-        /// Used to specify the order of the items in the source list when displayed
-        /// </summary>
-        [JsonProperty("order")]
-        public int Order { get; set; }
+        [JsonProperty("deviceKey")]
+        public string DeviceKey => DeviceManager.AllDevices.
+            Where(d => d.Key.Contains(ParentDeviceKey) && d.Key.Contains(ItemKey)).FirstOrDefault()?.Key ?? $"{ParentDeviceKey}--{ItemKey}";
 
         /// <summary>
         /// Indicates if the item is a level, mute , or both
@@ -76,8 +65,8 @@ namespace PepperDash.Essentials.Core
     [Flags]
     public enum eLevelControlType
     {
-        Level = 0,
-        Mute = 1,
+        Level = 1,
+        Mute = 2,
         LevelAndMute = Level | Mute,
     }
 }

src/PepperDash.Essentials.Core/Devices/PC/InRoomPc.cs

@@ -5,7 +5,6 @@ using Crestron.SimplSharpPro;
 
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Routing;
 using PepperDash.Core;
 using Serilog.Events;
 

src/PepperDash.Essentials.Core/Devices/PC/Laptop.cs

@@ -5,7 +5,6 @@ using Crestron.SimplSharpPro;
 
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Routing;
 using PepperDash.Core;
 using Serilog.Events;
 
@@ -70,7 +69,7 @@ namespace PepperDash.Essentials.Core.Devices
     {
         public LaptopFactory()
         {
-            TypeNames = new List<string>() { "laptop" };
+            TypeNames = new List<string>() { "deprecated" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)

src/PepperDash.Essentials.Core/Devices/PresetListItem.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class PresetListItem : AudioControlListItemBase
+    {
+        [JsonIgnore]
+        public IKeyName Preset
+        {
+            get
+            {
+                if (_preset == null)
+                {
+                    var parent = DeviceManager.GetDeviceForKey(ParentDeviceKey) as IDspPresets;
+                    if (parent == null || !parent.Presets.ContainsKey(ItemKey))
+                        return null;
+                    _preset = parent.Presets[ItemKey];
+                }
+                return _preset;
+            }
+        }
+        private IKeyName _preset;
+
+        /// <summary>
+        /// Gets the name from the device if it implements IKeyName or else returns the Name property
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(Name)) return Name;
+
+                else return Preset.Name;
+            }
+        }
+    }
+}

src/PepperDash.Essentials.Core/Devices/SourceListItem.cs

@@ -1,128 +1,121 @@
-
-
-using System;
-using System.Collections.Generic;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharpPro;
-
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 using PepperDash.Core;
+using System.Collections.Generic;
 
 namespace PepperDash.Essentials.Core
 {
-	/// <summary>
-	/// 
-	/// </summary>
-	public enum eSourceListItemType
-	{
-		Route, Off, Other, SomethingAwesomerThanThese
-	}
+    /// <summary>
+    /// 
+    /// </summary>
+    public enum eSourceListItemType
+    {
+        Route, Off, Other, SomethingAwesomerThanThese
+    }
 
-	/// <summary>
-	/// Represents an item in a source list - can be deserialized into.
-	/// </summary>
-	public class SourceListItem
-	{
-		[JsonProperty("sourceKey")]
-		public string SourceKey { get; set; }
+    /// <summary>
+    /// Represents an item in a source list - can be deserialized into.
+    /// </summary>
+    public class SourceListItem
+    {
+        [JsonProperty("sourceKey")]
+        public string SourceKey { get; set; }
 
-		/// <summary>
-		/// Returns the source Device for this, if it exists in DeviceManager
-		/// </summary>
-		[JsonIgnore]
-		public Device SourceDevice
-		{
-			get
-			{
-				if (_SourceDevice == null)
-					_SourceDevice = DeviceManager.GetDeviceForKey(SourceKey) as Device;
-				return _SourceDevice;
-			}
-		}
-		Device _SourceDevice;
+        /// <summary>
+        /// Returns the source Device for this, if it exists in DeviceManager
+        /// </summary>
+        [JsonIgnore]
+        public Device SourceDevice
+        {
+            get
+            {
+                if (_SourceDevice == null)
+                    _SourceDevice = DeviceManager.GetDeviceForKey(SourceKey) as Device;
+                return _SourceDevice;
+            }
+        }
 
-		/// <summary>
-		/// Gets either the source's Name or this AlternateName property, if 
-		/// defined.  If source doesn't exist, returns "Missing source"
-		/// </summary>
-		[JsonProperty("preferredName")]
-		public string PreferredName
-		{
-			get
-			{
-				if (string.IsNullOrEmpty(Name))
-				{
-					if (SourceDevice == null)
-						return "---";
-					return SourceDevice.Name;
-				}
-				return Name;
-			}
-		}
+        private Device _SourceDevice;
 
-		/// <summary>
-		/// A name that will override the source's name on the UI
-		/// </summary>
-		[JsonProperty("name")]
-		public string Name { get; set; }
+        /// <summary>
+        /// Gets either the source's Name or this AlternateName property, if 
+        /// defined.  If source doesn't exist, returns "Missing source"
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(Name))
+                {
+                    if (SourceDevice == null)
+                        return "---";
+                    return SourceDevice.Name;
+                }
+                return Name;
+            }
+        }
+
+        /// <summary>
+        /// A name that will override the source's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
 
         /// <summary>
         /// Specifies and icon for the source list item
         /// </summary>
 		[JsonProperty("icon")]
-		public string Icon { get; set; }
+        public string Icon { get; set; }
 
         /// <summary>
         /// Alternate icon
         /// </summary>
 		[JsonProperty("altIcon")]
-		public string AltIcon { get; set; }
+        public string AltIcon { get; set; }
 
         /// <summary>
         /// Indicates if the item should be included in the source list
         /// </summary>
 		[JsonProperty("includeInSourceList")]
-		public bool IncludeInSourceList { get; set; }
+        public bool IncludeInSourceList { get; set; }
 
         /// <summary>
         /// Used to specify the order of the items in the source list when displayed
         /// </summary>
 		[JsonProperty("order")]
-		public int Order { get; set; }
+        public int Order { get; set; }
 
         /// <summary>
         /// The key of the device for volume control
         /// </summary>
 		[JsonProperty("volumeControlKey")]
-		public string VolumeControlKey { get; set; }
+        public string VolumeControlKey { get; set; }
 
         /// <summary>
         /// The type of source list item
         /// </summary>
 		[JsonProperty("type")]
-		[JsonConverter(typeof(StringEnumConverter))]
-		public eSourceListItemType Type { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public eSourceListItemType Type { get; set; }
 
         /// <summary>
         /// The list of routes to execute for this source list item
         /// </summary>
 		[JsonProperty("routeList")]
-		public List<SourceRouteListItem> RouteList { get; set; }
+        public List<SourceRouteListItem> RouteList { get; set; }
 
         /// <summary>
         /// Indicates if this source should be disabled for sharing to the far end call participants via codec content
         /// </summary>
 		[JsonProperty("disableCodecSharing")]
-		public bool DisableCodecSharing { get; set; }
+        public bool DisableCodecSharing { get; set; }
 
         /// <summary>
         /// Indicates if this source should be disabled for routing to a shared output
         /// </summary>
 		[JsonProperty("disableRoutedSharing")]
-		public bool DisableRoutedSharing { get; set; }
+        public bool DisableRoutedSharing { get; set; }
 
         [JsonProperty("destinations")]
         public List<eSourceListItemDestinationTypes> Destinations { get; set; }
@@ -144,25 +137,46 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("isAudioSource")]
         public bool IsAudioSource { get; set; }
 
-		public SourceListItem()
-		{
-			Icon = "Blank";
-		}
+        /// <summary>
+        /// Hide source on UI when Avanced Sharing is enabled
+        /// </summary>
+        [JsonProperty("disableAdvancedRouting")]
+        public bool DisableAdvancedRouting { get; set; }
 
-        
-	}
+        /// <summary>
+        /// Hide source on UI when Simpl Sharing is enabled
+        /// </summary>
+        [JsonProperty("disableSimpleRouting")]
+        public bool DisableSimpleRouting { get; set; }
 
-	public class SourceRouteListItem
-	{
-		[JsonProperty("sourceKey")]
-		public string SourceKey { get; set; }
+        public SourceListItem()
+        {
+            Icon = "Blank";
+        }
 
-		[JsonProperty("destinationKey")]
-		public string DestinationKey { get; set; }
+        public override string ToString()
+        {
+            return $"{SourceKey}:{Name}";
+        }
+    }
 
-		[JsonProperty("type")]
-		public eRoutingSignalType Type { get; set; }
-	}
+    public class SourceRouteListItem
+    {
+        [JsonProperty("sourceKey")]
+        public string SourceKey { get; set; }
+
+        [JsonProperty("sourcePortKey")]
+        public string SourcePortKey { get; set; }
+
+        [JsonProperty("destinationKey")]
+        public string DestinationKey { get; set; }
+
+        [JsonProperty("destinationPortKey")]
+        public string DestinationPortKey { get; set; }
+
+        [JsonProperty("type")]
+        public eRoutingSignalType Type { get; set; }
+    }
 
     /// <summary>
     /// Defines the valid destination types for SourceListItems in a room
@@ -172,7 +186,12 @@ namespace PepperDash.Essentials.Core
         defaultDisplay,
         leftDisplay,
         rightDisplay,
+        centerDisplay,
         programAudio,
-        codecContent
+        codecContent,
+        frontLeftDisplay,
+        frontRightDisplay,
+        rearLeftDisplay,
+        rearRightDisplay,
     }
 }

src/PepperDash.Essentials.Core/Display/BasicIrDisplay.cs

@@ -10,7 +10,6 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Core

src/PepperDash.Essentials.Core/Display/DisplayBase.cs

@@ -1,25 +1,23 @@
 
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
 using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 
 namespace PepperDash.Essentials.Core
 {
-	[Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
+    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public abstract class DisplayBase : EssentialsDevice, IHasFeedback, IRoutingSinkWithSwitching, IHasPowerControl, IWarmingCooling, IUsageTracking
 	{
         public event SourceInfoChangeHandler CurrentSourceChange;
+        public event InputChangedEventHandler InputChanged;
 
         public string CurrentSourceInfoKey { get; set; }
         public SourceListItem CurrentSourceInfo
@@ -96,7 +94,9 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 
-	    public abstract void ExecuteSwitch(object selector);
+        public RoutingInputPort CurrentInputPort => throw new NotImplementedException();
+
+        public abstract void ExecuteSwitch(object selector);
 
 	    protected void LinkDisplayToApi(DisplayBase displayDevice, BasicTriList trilist, uint joinStart, string joinMapKey,
 	        EiscApiAdvanced bridge)
@@ -266,16 +266,16 @@ namespace PepperDash.Essentials.Core
         abstract protected Func<bool> PowerIsOnFeedbackFunc { get; }
 
 
-        public static MockDisplay DefaultDisplay
-        { 
-			get 
-			{
-				if (_DefaultDisplay == null)
-					_DefaultDisplay = new MockDisplay("default", "Default Display");
-				return _DefaultDisplay;
-			} 
-		}
-		static MockDisplay _DefaultDisplay;
+  //      public static MockDisplay DefaultDisplay
+  //      { 
+		//	get 
+		//	{
+		//		if (_DefaultDisplay == null)
+		//			_DefaultDisplay = new MockDisplay("default", "Default Display");
+		//		return _DefaultDisplay;
+		//	} 
+		//}
+		//static MockDisplay _DefaultDisplay;
 
 		public TwoWayDisplayBase(string key, string name)
 			: base(key, name)

src/PepperDash.Essentials.Core/Display/MockDisplay.cs

@@ -1,224 +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 Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.Core.Routing;
-using PepperDash.Essentials.Core.Config;
-using Serilog.Events;
-
-namespace PepperDash.Essentials.Core
-{
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
-    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced
-
-	{
-		public RoutingInputPort HdmiIn1 { get; private set; }
-		public RoutingInputPort HdmiIn2 { get; private set; }
-		public RoutingInputPort HdmiIn3 { get; private set; }
-		public RoutingInputPort ComponentIn1 { get; private set; }
-		public RoutingInputPort VgaIn1 { get; private set; }
-
-		bool _PowerIsOn;
-		bool _IsWarmingUp;
-		bool _IsCoolingDown;
-
-        protected override Func<bool> PowerIsOnFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** Display Power is {0}", _PowerIsOn ? "on" : "off");
-                        return _PowerIsOn;
-                    };
-        } }
-		protected override Func<bool> IsCoolingDownFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                {
-                    Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** {0}", _IsCoolingDown ? "Display is cooling down" : "Display has finished cooling down");
-                    return _IsCoolingDown;
-                };
-            }
-        }
-		protected override Func<bool> IsWarmingUpFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                {
-                    Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** {0}", _IsWarmingUp ? "Display is warming up" : "Display has finished warming up");
-                    return _IsWarmingUp;
-                };
-            }
-        }
-        protected override Func<string> CurrentInputFeedbackFunc { get { return () => "Not Implemented"; } }
-
-        int VolumeHeldRepeatInterval = 200;
-        ushort VolumeInterval = 655;
-		ushort _FakeVolumeLevel = 31768;
-		bool _IsMuted;
-
-		public MockDisplay(string key, string name)
-			: base(key, name)
-		{
-			HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			ComponentIn1 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Component, null, this);
-			VgaIn1 = new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Composite, null, this);
-			InputPorts.AddRange(new[] { HdmiIn1, HdmiIn2, HdmiIn3, ComponentIn1, VgaIn1 });
-
-			VolumeLevelFeedback = new IntFeedback(() => { return _FakeVolumeLevel; });
-			MuteFeedback = new BoolFeedback("MuteOn", () => _IsMuted);
-
-            WarmupTime = 10000;
-            CooldownTime = 10000;
-		}
-
-		public override void PowerOn()
-		{
-			if (!PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
-			{
-				_IsWarmingUp = true;
-				IsWarmingUpFeedback.InvokeFireUpdate();
-				// Fake power-up cycle
-				WarmupTimer = new CTimer(o =>
-					{
-						_IsWarmingUp = false;
-						_PowerIsOn = true;
-						IsWarmingUpFeedback.InvokeFireUpdate();
-						PowerIsOnFeedback.InvokeFireUpdate();
-					}, WarmupTime);
-			}
-		}
-
-		public override void PowerOff()
-		{
-			// If a display has unreliable-power off feedback, just override this and
-			// remove this check.
-			if (PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
-			{
-				_IsCoolingDown = true;
-				IsCoolingDownFeedback.InvokeFireUpdate();
-				// Fake cool-down cycle
-				CooldownTimer = new CTimer(o =>
-					{
-						Debug.LogMessage(LogEventLevel.Verbose, this, "Cooldown timer ending");
-						_IsCoolingDown = false;
-						IsCoolingDownFeedback.InvokeFireUpdate();
-                        _PowerIsOn = false;
-                        PowerIsOnFeedback.InvokeFireUpdate();
-					}, CooldownTime);
-			}
-		}		
-		
-		public override void PowerToggle()
-		{
-			if (PowerIsOnFeedback.BoolValue && !IsWarmingUpFeedback.BoolValue)
-				PowerOff();
-			else if (!PowerIsOnFeedback.BoolValue && !IsCoolingDownFeedback.BoolValue)
-				PowerOn();
-		}
-
-		public override void ExecuteSwitch(object selector)
-		{
-			Debug.LogMessage(LogEventLevel.Verbose, this, "ExecuteSwitch: {0}", selector);
-
-		    if (!_PowerIsOn)
-		    {
-		        PowerOn();
-		    }
-		}
-
-
-
-		#region IBasicVolumeWithFeedback Members
-
-		public IntFeedback VolumeLevelFeedback { get; private set; }
-
-		public void SetVolume(ushort level)
-		{
-			_FakeVolumeLevel = level;
-			VolumeLevelFeedback.InvokeFireUpdate();
-		}
-
-		public void MuteOn()
-		{
-			_IsMuted = true;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		public void MuteOff()
-		{
-			_IsMuted = false;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		public BoolFeedback MuteFeedback { get; private set; }
-
-		#endregion
-
-		#region IBasicVolumeControls Members
-
-		public void VolumeUp(bool pressRelease)
-		{
-            //while (pressRelease)
-            //{
-                Debug.LogMessage(LogEventLevel.Verbose, this, "Volume Down {0}", pressRelease);
-                if (pressRelease)
-                {
-                    var newLevel = _FakeVolumeLevel + VolumeInterval;
-                    SetVolume((ushort)newLevel);
-                    CrestronEnvironment.Sleep(VolumeHeldRepeatInterval);
-                }
-            //}
-		}
-
-		public void VolumeDown(bool pressRelease)
-		{
-            //while (pressRelease)
-            //{
-                Debug.LogMessage(LogEventLevel.Verbose, this, "Volume Up {0}", pressRelease);
-                if (pressRelease)
-                {
-                    var newLevel = _FakeVolumeLevel - VolumeInterval;
-                    SetVolume((ushort)newLevel);
-                    CrestronEnvironment.Sleep(VolumeHeldRepeatInterval);
-                }
-            //}
-		}
-
-		public void MuteToggle()
-		{
-			_IsMuted = !_IsMuted;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		#endregion
-
-	    public void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-	    {
-	        LinkDisplayToApi(this, trilist, joinStart, joinMapKey, bridge);
-	    }
-	}
-
-
-
-}

src/PepperDash.Essentials.Core/Factory/DeviceFactory.cs

@@ -1,7 +1,7 @@
 
 
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -14,13 +14,13 @@ namespace PepperDash.Essentials.Core
 {
     public class DeviceFactoryWrapper
     {
-        public CType CType { get; set; }
+        public Type Type { get; set; }
         public string Description { get; set; }
         public Func<DeviceConfig, IKeyed> FactoryMethod { get; set; }
 
         public DeviceFactoryWrapper()
         {
-            CType = null;
+            Type = null;
             Description = "Not Available";
         }
     }
@@ -40,7 +40,7 @@ namespace PepperDash.Essentials.Core
                 {
                     try
                     {
-                        var factory = (IDeviceFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                        var factory = (IDeviceFactory)Activator.CreateInstance(type);
                         factory.LoadTypeFactories();
                     }
                     catch (Exception e)
@@ -69,7 +69,7 @@ namespace PepperDash.Essentials.Core
             DeviceFactory.FactoryMethods.Add(typeName, new DeviceFactoryWrapper() { FactoryMethod = method});
 		}
 
-        public static void AddFactoryForType(string typeName, string description, CType cType, Func<DeviceConfig, IKeyed> method)
+        public static void AddFactoryForType(string typeName, string description, Type Type, Func<DeviceConfig, IKeyed> method)
         {
             //Debug.LogMessage(LogEventLevel.Debug, "Adding factory method for type '{0}'", typeName);
 
@@ -79,7 +79,7 @@ namespace PepperDash.Essentials.Core
                 return;
             }
 
-            var wrapper = new DeviceFactoryWrapper() { CType = cType, Description = description, FactoryMethod = method };
+            var wrapper = new DeviceFactoryWrapper() { Type = Type, Description = description, FactoryMethod = method };
             DeviceFactory.FactoryMethods.Add(typeName, wrapper);
         }
 
@@ -149,18 +149,7 @@ namespace PepperDash.Essentials.Core
             }
             catch (Exception ex)
             {
-                Debug.LogMessage(LogEventLevel.Error, "Exception occurred while creating device {0}: {1}", dc.Key, ex.Message);
-
-                Debug.LogMessage(LogEventLevel.Verbose, "{0}", ex.StackTrace);
-
-                if (ex.InnerException == null)
-                {
-                    return null;
-                }
-
-                Debug.LogMessage(LogEventLevel.Error, "Inner exception while creating device {0}: {1}", dc.Key,
-                    ex.InnerException.Message);
-                Debug.LogMessage(LogEventLevel.Verbose, "{0}", ex.InnerException.StackTrace);
+                Debug.LogMessage(ex, "Exception occurred while creating device {0}: {1}", null, dc.Key, ex.Message);
                 return null;
             }
         }
@@ -180,17 +169,17 @@ namespace PepperDash.Essentials.Core
             foreach (var type in types.OrderBy(t => t.Key))
             {
                 var description = type.Value.Description;
-                var cType = "Not Specified by Plugin";
+                var Type = "Not Specified by Plugin";
 
-                if (type.Value.CType != null)
+                if (type.Value.Type != null)
                 {
-                    cType = type.Value.CType.FullName;
+                    Type = type.Value.Type.FullName;
                 }
 
                 CrestronConsole.ConsoleCommandResponse(
                     @"Type: '{0}' 
-                    CType: '{1}' 
-                    Description: {2}{3}", type.Key, cType, description, CrestronEnvironment.NewLine);
+                    Type: '{1}' 
+                    Description: {2}{3}", type.Key, Type, description, CrestronEnvironment.NewLine);
             }
         }
 

src/PepperDash.Essentials.Core/Factory/IDeviceFactory.cs

@@ -1,14 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core.Config;
-
-namespace PepperDash.Essentials.Core
+namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Defines a class that is capable of loading device types

src/PepperDash.Essentials.Core/Factory/ProcessorExtensionDeviceFactory.cs

@@ -1,5 +1,5 @@
 
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 using Serilog.Events;
@@ -25,7 +25,7 @@ namespace PepperDash.Essentials.Core
                 {
                     try
                     {
-                        var factory = (IProcessorExtensionDeviceFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(extension);
+                        var factory = (IProcessorExtensionDeviceFactory)Activator.CreateInstance(extension);
                         factory.LoadFactories();
                     }
                     catch( Exception e )
@@ -55,7 +55,7 @@ namespace PepperDash.Essentials.Core
             ProcessorExtensionDeviceFactory.ProcessorExtensionFactoryMethods.Add(extensionName, new DeviceFactoryWrapper() { FactoryMethod = method });
         }
 
-        public static void AddFactoryForType(string extensionName, string description, CType cType, Func<DeviceConfig, IKeyed> method)
+        public static void AddFactoryForType(string extensionName, string description, Type Type, Func<DeviceConfig, IKeyed> method)
         {
             //Debug.LogMessage(LogEventLevel.Debug, "Adding factory method for type '{0}'", typeName);
 
@@ -65,7 +65,7 @@ namespace PepperDash.Essentials.Core
                 return;
             }
 
-            var wrapper = new DeviceFactoryWrapper() { CType = cType, Description = description, FactoryMethod = method };
+            var wrapper = new DeviceFactoryWrapper() { Type = Type, Description = description, FactoryMethod = method };
             ProcessorExtensionDeviceFactory.ProcessorExtensionFactoryMethods.Add(extensionName, wrapper);
         }
 

src/PepperDash.Essentials.Core/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -1,9 +1,5 @@
 
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharp.CrestronXml;
@@ -14,6 +10,10 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 
 namespace PepperDash.Essentials.Core.Fusion
 {

src/PepperDash.Essentials.Core/Global/Global.cs

@@ -137,6 +137,7 @@ namespace PepperDash.Essentials.Core
         public static void SetFilePathPrefix(string prefix)
         {
             FilePathPrefix = prefix;
+            Debug.LogMessage(LogEventLevel.Information, "File Path Prefix set to '{0}'", FilePathPrefix);
         }
 
         static string _AssemblyVersion;

src/PepperDash.Essentials.Core/JoinMaps/JoinMapBase.cs

@@ -5,7 +5,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Text;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharp;
 
@@ -109,7 +109,7 @@ namespace PepperDash.Essentials.Core
         protected void AddJoins(Type type)
         {
             var fields =
-                type.GetCType()
+                type.GetType()
                     .GetFields(BindingFlags.Public | BindingFlags.Instance)
                     .Where(f => f.IsDefined(typeof (JoinNameAttribute), true));
 
@@ -501,7 +501,7 @@ namespace PepperDash.Essentials.Core
         public string GetNameAttribute(MemberInfo memberInfo)
         {
             var name = string.Empty;
-            var attribute = (JoinNameAttribute)CAttribute.GetCustomAttribute(memberInfo, typeof(JoinNameAttribute));
+            var attribute = (JoinNameAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(JoinNameAttribute));
 
             if (attribute == null) return name;
 
@@ -514,7 +514,7 @@ namespace PepperDash.Essentials.Core
     
 
     [AttributeUsage(AttributeTargets.All)]
-    public class JoinNameAttribute : CAttribute
+    public class JoinNameAttribute : Attribute
     {
         private string _Name;
 

src/PepperDash.Essentials.Core/Monitoring/SystemMonitorController.cs

@@ -110,7 +110,7 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptimePollTimer = null;
         }
 
-        private void PollUptime(object obj)
+        public void PollUptime(object obj)
         {
             var consoleResponse = string.Empty;
 
@@ -142,19 +142,22 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptime = uptimeRaw.Substring(forIndex + 4);
         }
 
-	    private static void ProcessorReboot()
+	    public static void ProcessorReboot()
 	    {
 		    if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+            Debug.LogMessage(LogEventLevel.Information, "Rebooting...");
 
-		    var response = string.Empty;
+
+            var response = string.Empty;
 		    CrestronConsole.SendControlSystemCommand("reboot", ref response);
 	    }
 
-		private static void ProgramReset(uint index)
+		public static void ProgramReset(uint index)
 		{
 			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+            Debug.LogMessage(LogEventLevel.Information, "Resetting Program {0}...", index);
 
-			if (index <= 0 || index > 10) return;
+            if (index <= 0 || index > 10) return;
 
 			var cmd = string.Format("progreset -p:{0}", index);
 

src/PepperDash.Essentials.Core/PartitionSensor/EssentialsPartitionController.cs

@@ -1,9 +1,5 @@
-using System;
+using PepperDash.Core;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core
 {
@@ -26,6 +22,11 @@ namespace PepperDash.Essentials.Core
         {
             get
             {
+                if (IsInAutoMode)
+                {
+                    return _partitionSensor.PartitionPresentFeedback.BoolValue;
+                }
+
                 return _partitionPresent;
             }
             set
@@ -73,11 +74,11 @@ namespace PepperDash.Essentials.Core
             PartitionPresentFeedback.FireUpdate();
         }
 
-        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        private void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
             if (IsInAutoMode)
             {
-                PartitionPresentFeedback.FireUpdate();
+                PartitionPresent = e.BoolValue;
             }
         }
 
@@ -87,6 +88,8 @@ namespace PepperDash.Essentials.Core
 
         public void SetAutoMode()
         {
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, $"Setting {Key} to Auto Mode", this);
+
             IsInAutoMode = true;
             if (PartitionPresentFeedback != null)
             {
@@ -101,11 +104,16 @@ namespace PepperDash.Essentials.Core
             {
                 _partitionSensor.PartitionPresentFeedback.OutputChange -= PartitionPresentFeedback_OutputChange;
                 _partitionSensor.PartitionPresentFeedback.OutputChange += PartitionPresentFeedback_OutputChange;
+                PartitionPresent = _partitionSensor.PartitionPresentFeedback.BoolValue;
             }
+
+            PartitionPresentFeedback.FireUpdate();
         }
 
         public void SetManualMode()
         {
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, $"Setting {Key} to Manual Mode", this);
+
             IsInAutoMode = false;
             if (PartitionPresentFeedback != null)
             {
@@ -119,7 +127,10 @@ namespace PepperDash.Essentials.Core
             if (_partitionSensor != null)
             {
                 _partitionSensor.PartitionPresentFeedback.OutputChange -= PartitionPresentFeedback_OutputChange;
+                PartitionPresent = _partitionSensor.PartitionPresentFeedback.BoolValue;
             }
+
+            PartitionPresentFeedback.FireUpdate();
         }
 
 

src/PepperDash.Essentials.Core/PepperDash.Essentials.Core.csproj

@@ -11,6 +11,9 @@
     <RootNamespace>PepperDash.Essentials.Core</RootNamespace>
     <Title>PepperDash Essentials Core</Title>
     <PackageId>PepperDash.Essentials.Core</PackageId>
+    <InformationalVersion>$(Version)</InformationalVersion>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <Version>2.0.0-local</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>full</DebugType>
@@ -22,8 +25,8 @@
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-407" />
+    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.66" />
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-424" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Crestron\CrestronGenericBaseDevice.cs.orig" />

src/PepperDash.Essentials.Core/Plugins/PluginLoader.cs

@@ -1,14 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using Serilog.Events;
+using Newtonsoft.Json;
 
 namespace PepperDash.Essentials
 {
@@ -27,24 +27,31 @@ namespace PepperDash.Essentials
         /// </summary>
         static List<LoadedAssembly> LoadedPluginFolderAssemblies;
 
+        public static LoadedAssembly EssentialsAssembly { get; private set; }
+
+        public static LoadedAssembly PepperDashCoreAssembly { get; private set; }
+
+        public static List<LoadedAssembly> EssentialsPluginAssemblies { get; private set; }
+
         /// <summary>
         /// The directory to look in for .cplz plugin packages
         /// </summary>
-        static string _pluginDirectory = Global.FilePathPrefix + "plugins";
+        static string _pluginDirectory => Global.FilePathPrefix + "plugins";
 
         /// <summary>
         /// The directory where plugins will be moved to and loaded from
         /// </summary>
-        static string _loadedPluginsDirectoryPath = _pluginDirectory + Global.DirectorySeparator + "loadedAssemblies";
+        static string _loadedPluginsDirectoryPath => _pluginDirectory + Global.DirectorySeparator + "loadedAssemblies";
 
         // The temp directory where .cplz archives will be unzipped to
-        static string _tempDirectory = _pluginDirectory + Global.DirectorySeparator + "temp";
+        static string _tempDirectory => _pluginDirectory + Global.DirectorySeparator + "temp";
 
 
         static PluginLoader()
         {
             LoadedAssemblies = new List<LoadedAssembly>();
             LoadedPluginFolderAssemblies = new List<LoadedAssembly>();
+            EssentialsPluginAssemblies = new List<LoadedAssembly>();
         }
 
         /// <summary>
@@ -59,7 +66,7 @@ namespace PepperDash.Essentials
 
             Debug.LogMessage(LogEventLevel.Verbose, "Found {0} Assemblies", assemblyFiles.Length);
 
-            foreach (var fi in assemblyFiles)
+            foreach (var fi in assemblyFiles.Where(fi => fi.Name.Contains("Essentials") || fi.Name.Contains("PepperDash")))
             {
                 string version = string.Empty;
                 Assembly assembly = null;
@@ -69,6 +76,7 @@ namespace PepperDash.Essentials
                     case ("PepperDashEssentials.dll"):
                         {
                             version = Global.AssemblyVersion;
+                            EssentialsAssembly = new LoadedAssembly(fi.Name, version, assembly);
                             break;
                         }
                     case ("PepperDash_Essentials_Core.dll"):
@@ -81,9 +89,12 @@ namespace PepperDash.Essentials
                             version = Global.AssemblyVersion;
                             break;
                         }
-                    case ("PepperDash_Core.dll"):
+                    case ("PepperDashCore.dll"):
                         {
-                            version = PepperDash.Core.Debug.PepperDashCoreVersion;
+                            Debug.LogMessage(LogEventLevel.Verbose, "Found PepperDash_Core.dll");
+                            version = Debug.PepperDashCoreVersion;
+                            Debug.LogMessage(LogEventLevel.Verbose, "PepperDash_Core Version: {0}", version);
+                            PepperDashCoreAssembly = new LoadedAssembly(fi.Name, version, assembly);
                             break;
                         }
                 }
@@ -119,24 +130,31 @@ namespace PepperDash.Essentials
         /// <param name="fileName"></param>
         static LoadedAssembly LoadAssembly(string filePath)
         {
-            //Debug.LogMessage(LogEventLevel.Verbose, "Attempting to load {0}", filePath);
-            var assembly = Assembly.LoadFrom(filePath);
-            if (assembly != null)
+            try
             {
-                var assyVersion = GetAssemblyVersion(assembly);
+                //Debug.LogMessage(LogEventLevel.Verbose, "Attempting to load {0}", filePath);
+                var assembly = Assembly.LoadFrom(filePath);
+                if (assembly != null)
+                {
+                    var assyVersion = GetAssemblyVersion(assembly);
 
-                var loadedAssembly = new LoadedAssembly(assembly.GetName().Name, assyVersion, assembly);
-                LoadedAssemblies.Add(loadedAssembly);
-                Debug.LogMessage(LogEventLevel.Information, "Loaded assembly '{0}', version {1}", loadedAssembly.Name, loadedAssembly.Version);
-                return loadedAssembly;
-            }
-            else
+                    var loadedAssembly = new LoadedAssembly(assembly.GetName().Name, assyVersion, assembly);
+                    LoadedAssemblies.Add(loadedAssembly);
+                    Debug.LogMessage(LogEventLevel.Information, "Loaded assembly '{0}', version {1}", loadedAssembly.Name, loadedAssembly.Version);
+                    return loadedAssembly;
+                }
+                else
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Unable to load assembly: '{0}'", filePath);
+                }
+
+                return null;
+            } catch(Exception ex)
             {
-                Debug.LogMessage(LogEventLevel.Information, "Unable to load assembly: '{0}'", filePath);
+                Debug.LogMessage(ex, "Error loading assembly from {path}", null, filePath);
+                return null;
             }
 
-            return null;
-
         }
 
         /// <summary>
@@ -144,7 +162,7 @@ namespace PepperDash.Essentials
         /// </summary>
         /// <param name="assembly"></param>
         /// <returns></returns>
-        static string GetAssemblyVersion(Assembly assembly)
+        public static string GetAssemblyVersion(Assembly assembly)
         {
             var ver = assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false);
             if (ver != null && ver.Length > 0)
@@ -190,12 +208,19 @@ namespace PepperDash.Essentials
         /// <param name="command"></param>
         public static void ReportAssemblyVersions(string command)
         {
-
-            CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
-            foreach (var assembly in LoadedAssemblies)
+            CrestronConsole.ConsoleCommandResponse("Essentials Version: {0}" + CrestronEnvironment.NewLine, Global.AssemblyVersion);
+            CrestronConsole.ConsoleCommandResponse("PepperDash Core Version: {0}" + CrestronEnvironment.NewLine, PepperDashCoreAssembly.Version);
+            CrestronConsole.ConsoleCommandResponse("Essentials Plugin Versions:" + CrestronEnvironment.NewLine);
+            foreach (var assembly in EssentialsPluginAssemblies)
             {
                 CrestronConsole.ConsoleCommandResponse("{0} Version: {1}" + CrestronEnvironment.NewLine, assembly.Name, assembly.Version);
             }
+
+            //CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
+            //foreach (var assembly in LoadedAssemblies)
+            //{
+            //    CrestronConsole.ConsoleCommandResponse("{0} Version: {1}" + CrestronEnvironment.NewLine, assembly.Name, assembly.Version);
+            //}
         }
         /// <summary>
         /// Moves any .dll assemblies not already loaded from the plugins folder to loadedPlugins folder
@@ -354,7 +379,7 @@ namespace PepperDash.Essentials
                 try
                 {
                     var assy = loadedAssembly.Assembly;
-                    CType[] types = {};
+                    Type[] types = {};
                     try
                     {
                         types = assy.GetTypes();
@@ -375,7 +400,7 @@ namespace PepperDash.Essentials
                             if (typeof (IPluginDeviceFactory).IsAssignableFrom(type) && !type.IsAbstract)
                             {
                                 var plugin =
-                                    (IPluginDeviceFactory) Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                                    (IPluginDeviceFactory)Activator.CreateInstance(type);
                                 LoadCustomPlugin(plugin, loadedAssembly);
                             }
                         }
@@ -432,6 +457,9 @@ namespace PepperDash.Essentials
 
             Debug.LogMessage(LogEventLevel.Information, "Loading plugin: {0}", loadedAssembly.Name);
             plugin.LoadTypeFactories();
+
+            if(!EssentialsPluginAssemblies.Contains(loadedAssembly))
+                EssentialsPluginAssemblies.Add(loadedAssembly);
         }
 
         /// <summary>
@@ -439,7 +467,7 @@ namespace PepperDash.Essentials
         /// </summary>
         /// <param name="type"></param>
         /// <param name="loadPlugin"></param>
-        static void LoadCustomLegacyPlugin(CType type, MethodInfo loadPlugin, LoadedAssembly loadedAssembly)
+        static void LoadCustomLegacyPlugin(Type type, MethodInfo loadPlugin, LoadedAssembly loadedAssembly)
         {
             Debug.LogMessage(LogEventLevel.Verbose, "LoadPlugin method found in {0}", type.Name);
 
@@ -486,6 +514,8 @@ namespace PepperDash.Essentials
         /// </summary>
         public static void LoadPlugins()
         {
+            Debug.LogMessage(LogEventLevel.Information, "Attempting to Load Plugins from {_pluginDirectory}", _pluginDirectory);
+
             if (Directory.Exists(_pluginDirectory))
             {
                 Debug.LogMessage(LogEventLevel.Information, "Plugins directory found, checking for plugins");
@@ -514,8 +544,11 @@ namespace PepperDash.Essentials
     /// </summary>
     public class LoadedAssembly
     {
+        [JsonProperty("name")]
         public string Name { get; private set; }
+        [JsonProperty("version")]
         public string Version { get; private set; }
+        [JsonIgnore]
         public Assembly Assembly { get; private set; }
 
         public LoadedAssembly(string name, string version, Assembly assembly)

src/PepperDash.Essentials.Core/Room/Combining/EssentialsRoomCombiner.cs

@@ -1,11 +1,12 @@
-using System;
+using Crestron.SimplSharp;
+using PepperDash.Core;
+using PepperDash.Core.Logging;
+using Serilog.Events;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using Crestron.SimplSharp;
-
-using PepperDash.Core;
-using Serilog.Events;
-using Newtonsoft.Json;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core
 {
@@ -35,7 +36,7 @@ namespace PepperDash.Essentials.Core
             }
             set
             {
-                if(value == _isInAutoMode)
+                if (value == _isInAutoMode)
                 {
                     return;
                 }
@@ -49,6 +50,8 @@ namespace PepperDash.Essentials.Core
 
         private int _scenarioChangeDebounceTimeSeconds = 10; // default to 10s
 
+        private Mutex _scenarioChange = new Mutex();
+
         public EssentialsRoomCombiner(string key, EssentialsRoomCombinerPropertiesConfig props)
             : base(key)
         {
@@ -93,7 +96,7 @@ namespace PepperDash.Essentials.Core
             });
         }
 
-        void CreateScenarios()
+        private void CreateScenarios()
         {
             foreach (var scenarioConfig in _propertiesConfig.Scenarios)
             {
@@ -102,21 +105,29 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        void SetRooms()
+        private void SetRooms()
         {
             _rooms = new List<IEssentialsRoom>();
 
             foreach (var roomKey in _propertiesConfig.RoomKeys)
             {
-                var room = DeviceManager.GetDeviceForKey(roomKey) as IEssentialsRoom;
-                if (room != null)
+                var room = DeviceManager.GetDeviceForKey(roomKey);
+
+                if (DeviceManager.GetDeviceForKey(roomKey) is IEssentialsRoom essentialsRoom)
                 {
-                    _rooms.Add(room);
+                    _rooms.Add(essentialsRoom);
                 }
             }
+
+            var rooms = DeviceManager.AllDevices.OfType<IEssentialsRoom>().Cast<Device>();
+
+            foreach (var room in rooms)
+            {
+                room.Deactivate();
+            }
         }
 
-        void SetupPartitionStateProviders()
+        private void SetupPartitionStateProviders()
         {
             foreach (var pConfig in _propertiesConfig.Partitions)
             {
@@ -130,18 +141,18 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        private void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
             StartDebounceTimer();
         }
 
-        void StartDebounceTimer()
+        private void StartDebounceTimer()
         {
             // default to 500ms for manual mode
             var time = 500;
 
             // if in auto mode, debounce the scenario change
-            if(IsInAutoMode) time = _scenarioChangeDebounceTimeSeconds * 1000;
+            if (IsInAutoMode) time = _scenarioChangeDebounceTimeSeconds * 1000;
 
             if (_scenarioChangeDebounceTimer == null)
             {
@@ -156,7 +167,7 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Determines the current room combination scenario based on the state of the partition sensors
         /// </summary>
-        void DetermineRoomCombinationScenario()
+        private void DetermineRoomCombinationScenario()
         {
             if (_scenarioChangeDebounceTimer != null)
             {
@@ -164,14 +175,20 @@ namespace PepperDash.Essentials.Core
                 _scenarioChangeDebounceTimer = null;
             }
 
+            this.LogInformation("Determining Combination Scenario");
+
             var currentScenario = RoomCombinationScenarios.FirstOrDefault((s) =>
             {
+                this.LogDebug("Checking scenario {scenarioKey}", s.Key);
                 // iterate the partition states
                 foreach (var partitionState in s.PartitionStates)
                 {
+                    this.LogDebug("checking PartitionState {partitionStateKey}", partitionState.PartitionKey);
                     // get the partition by key
                     var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionState.PartitionKey));
 
+                    this.LogDebug("Expected State: {partitionPresent} Actual State: {partitionState}", partitionState.PartitionPresent, partition.PartitionPresentFeedback.BoolValue);
+
                     if (partition != null && partitionState.PartitionPresent != partition.PartitionPresentFeedback.BoolValue)
                     {
                         // the partition can't be found or the state doesn't match
@@ -184,10 +201,41 @@ namespace PepperDash.Essentials.Core
 
             if (currentScenario != null)
             {
-                CurrentScenario = currentScenario;
+                this.LogInformation("Found combination Scenario {scenarioKey}", currentScenario.Key);
+                ChangeScenario(currentScenario);
             }
         }
 
+        private async Task ChangeScenario(IRoomCombinationScenario newScenario)
+        {
+            
+
+                if (newScenario == _currentScenario)
+                {
+                    return;
+                }
+
+                // Deactivate the old scenario first
+                if (_currentScenario != null)
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Deactivating scenario {currentScenario}", this, _currentScenario.Name);
+                    await _currentScenario.Deactivate();
+                }
+
+                _currentScenario = newScenario;
+
+                // Activate the new scenario
+                if (_currentScenario != null)
+                {
+                    Debug.LogMessage(LogEventLevel.Debug, $"Current Scenario: {_currentScenario.Name}", this);
+                    await _currentScenario.Activate();
+                }
+
+                RoomCombinationScenarioChanged?.Invoke(this, new EventArgs());
+
+            
+        }
+
         #region IEssentialsRoomCombiner Members
 
         public event EventHandler<EventArgs> RoomCombinationScenarioChanged;
@@ -198,33 +246,6 @@ namespace PepperDash.Essentials.Core
             {
                 return _currentScenario;
             }
-            private set
-            {
-                if (value != _currentScenario)
-                {
-                    // Deactivate the old scenario first
-                    if (_currentScenario != null)
-                    {
-                        _currentScenario.Deactivate();
-                    }
-
-                    _currentScenario = value;
-
-                    // Activate the new scenario
-                    if (_currentScenario != null)
-                    {
-                        _currentScenario.Activate();
-
-                        Debug.LogMessage(LogEventLevel.Debug, $"Current Scenario: {_currentScenario.Name}", this);
-                    }
-
-                    var handler = RoomCombinationScenarioChanged;
-                    if (handler != null)
-                    {
-                        handler(this, new EventArgs());
-                    }
-                }
-            }
         }
 
         public BoolFeedback IsInAutoModeFeedback { get; private set; }
@@ -232,16 +253,35 @@ namespace PepperDash.Essentials.Core
         public void SetAutoMode()
         {
             IsInAutoMode = true;
+
+            foreach (var partition in Partitions)
+            {
+                partition.SetAutoMode();
+            }
+
+            DetermineRoomCombinationScenario();
         }
 
         public void SetManualMode()
         {
             IsInAutoMode = false;
+
+            foreach (var partition in Partitions)
+            {
+                partition.SetManualMode();
+            }
         }
 
         public void ToggleMode()
         {
-            IsInAutoMode = !IsInAutoMode;
+            if (IsInAutoMode)
+            {
+                SetManualMode();
+            }
+            else
+            {
+                SetAutoMode();
+            }
         }
 
         public List<IRoomCombinationScenario> RoomCombinationScenarios { get; private set; }

src/PepperDash.Essentials.Core/Room/Combining/IEssentialsRoomCombiner.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using PepperDash.Core;
 
@@ -87,12 +88,12 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Activates this room combination scenario
         /// </summary>
-        void Activate();
+        Task Activate();
 
         /// <summary>
         /// Deactivates this room combination scenario
         /// </summary>
-        void Deactivate();
+        Task Deactivate();
 
         /// <summary>
         /// The state of the partitions that would activate this scenario

src/PepperDash.Essentials.Core/Room/Combining/RoomCombinationScenario.cs

@@ -1,22 +1,16 @@
-
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
+using Newtonsoft.Json;
 using PepperDash.Core;
-
-using Newtonsoft.Json;
+using PepperDash.Core.Logging;
 using Serilog.Events;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Represents a room combination scenario
     /// </summary>
-    public class RoomCombinationScenario: IRoomCombinationScenario, IKeyName
+    public class RoomCombinationScenario : IRoomCombinationScenario, IKeyName
     {
         private RoomCombinationScenarioConfig _config;
 
@@ -40,7 +34,7 @@ namespace PepperDash.Essentials.Core
             get { return _isActive; }
             set
             {
-                if(value == _isActive)
+                if (value == _isActive)
                 {
                     return;
                 }
@@ -76,33 +70,43 @@ namespace PepperDash.Essentials.Core
             IsActiveFeedback = new BoolFeedback(() => _isActive);
         }
 
-        public void Activate()
+        public async Task Activate()
         {
-            Debug.LogMessage(LogEventLevel.Debug, "Activating Scenario: '{0}' with {1} action(s) defined", Name, activationActions.Count);   
+            this.LogInformation("Activating Scenario {name} with {activationActionCount} action(s) defined", Name, activationActions.Count);
+
+            List<Task> tasks = new List<Task>();
 
             if (activationActions != null)
             {
                 foreach (var action in activationActions)
                 {
-                    DeviceJsonApi.DoDeviceAction(action);
+                    this.LogInformation("Running Activation action {@action}", action);
+                    tasks.Add(DeviceJsonApi.DoDeviceActionAsync(action));
                 }
             }
 
+            await Task.WhenAll(tasks);
+
             IsActive = true;
         }
 
-        public void Deactivate()
+        public async Task Deactivate()
         {
-            Debug.LogMessage(LogEventLevel.Debug, "Deactivating Scenario: '{0}' with {1} action(s) defined", Name, deactivationActions.Count);
+            this.LogInformation("Deactivating Scenario {name} with {deactivationActionCount} action(s) defined", Name, deactivationActions.Count);
+
+            List<Task> tasks = new List<Task>();
 
             if (deactivationActions != null)
             {
                 foreach (var action in deactivationActions)
                 {
-                    DeviceJsonApi.DoDeviceAction(action);
+                    this.LogInformation("Running deactivation action {actionDeviceKey}:{actionMethod}", action.DeviceKey, action.MethodName);
+                    tasks.Add( DeviceJsonApi.DoDeviceActionAsync(action));
                 }
             }
 
+            await Task.WhenAll(tasks);
+
             IsActive = false;
         }
 

src/PepperDash.Essentials.Core/Room/Config/EssentialsRoomConfig.cs

@@ -198,8 +198,11 @@ namespace PepperDash.Essentials.Room.Config
         public string SourceListKey { get; set; }
         [JsonProperty("destinationListKey")]
         public string DestinationListKey { get; set; }
-        [JsonProperty("levelControlListKey")]
-        public string LevelControlListKey { get; set; }
+        [JsonProperty("audioControlPointListKey")]
+        public string AudioControlPointListKey { get; set; }
+        [JsonProperty("cameraListKey")]
+        public string CameraListKey { get; set; }
+
 
         [JsonProperty("defaultSourceItem")]
         public string DefaultSourceItem { get; set; }

src/PepperDash.Essentials.Core/Room/EssentialsRoomBase.cs

@@ -110,12 +110,12 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        private string _levelControlListKey;
-        public string LevelControlListKey
+        private string _audioControlPointListKey;
+        public string AudioControlPointListKey
         {
             get
             {
-                if (string.IsNullOrEmpty(_levelControlListKey))
+                if (string.IsNullOrEmpty(_audioControlPointListKey))
                 {
                     return _defaultListKey;
                 }
@@ -126,14 +126,35 @@ namespace PepperDash.Essentials.Core
             }
             protected set
             {
-                if (value != _levelControlListKey)
+                if (value != _audioControlPointListKey)
                 {
-                    _levelControlListKey = value;
+                    _audioControlPointListKey = value;
                 }
             }
         }
 
-
+        private string _cameraListKey;
+        public string CameraListKey
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(_cameraListKey))
+                {
+                    return _defaultListKey;
+                }
+                else
+                {
+                    return _cameraListKey;
+                }
+            }
+            protected set
+            {
+                if (value != _cameraListKey)
+                {
+                    _cameraListKey = value;
+                }
+            }
+        }
 
         /// <summary>
         /// Timer used for informing the UIs of a shutdown

src/PepperDash.Essentials.Core/Room/IEssentialsRoom.cs

@@ -29,7 +29,9 @@ namespace PepperDash.Essentials.Core
 
         string DestinationListKey { get; }
 
-        string LevelControlListKey { get; }
+        string AudioControlPointListKey { get; }
+
+        string CameraListKey { get; }
 
         SecondsCountdownTimer ShutdownPromptTimer { get; }
         int ShutdownPromptSeconds { get; }

src/PepperDash.Essentials.Core/Room/Interfaces.cs

@@ -40,7 +40,7 @@ namespace PepperDash.Essentials.Core
     {
         void RunRouteAction(string routeKey, string sourceListKey);
 
-        void RunRouteAction(string routeKey, string sourceListKey, Action successCallback);
+        void RunRouteAction(string routeKey, string sourceListKey, Action successCallback);        
     }
 
     /// <summary>

src/PepperDash.Essentials.Core/Routing/DummyRoutingInputsDevice.cs

@@ -8,7 +8,7 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Routing
 {
-	public class DummyRoutingInputsDevice : Device, IRoutingSource
+	public class DummyRoutingInputsDevice : Device, IRoutingSource, IRoutingOutputs
 	{
 		/// <summary>
 		/// A single output port, backplane, audioVideo

src/PepperDash.Essentials.Core/Routing/Extensions.cs

@@ -0,0 +1,351 @@
+using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Debug = PepperDash.Core.Debug;
+
+
+namespace PepperDash.Essentials.Core
+{
+
+    /// <summary>
+    /// Extensions added to any IRoutingInputs classes to provide discovery-based routing
+    /// on those destinations.
+    /// </summary>
+    public static class Extensions
+    {
+        private static readonly Dictionary<string, RouteRequest> RouteRequests = new Dictionary<string, RouteRequest>();
+
+        /// <summary>
+        /// Gets any existing RouteDescriptor for a destination, clears it using ReleaseRoute
+        /// and then attempts a new Route and if sucessful, stores that RouteDescriptor
+        /// in RouteDescriptorCollection.DefaultCollection
+        /// </summary>        
+        public static void ReleaseAndMakeRoute(this IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, string destinationPortKey = "", string sourcePortKey = "")
+        {
+            // Remove this line before committing!!!!!
+            var frame = new StackFrame(1, true);
+            Debug.LogMessage(LogEventLevel.Information, "ReleaseAndMakeRoute Called from {method} with params {destinationKey}:{sourceKey}:{signalType}:{destinationPortKey}:{sourcePortKey}", frame.GetMethod().Name, destination.Key, source.Key, signalType.ToString(), destinationPortKey, sourcePortKey);
+
+            var inputPort = string.IsNullOrEmpty(destinationPortKey) ? null : destination.InputPorts.FirstOrDefault(p => p.Key == destinationPortKey);
+            var outputPort = string.IsNullOrEmpty(sourcePortKey) ? null : source.OutputPorts.FirstOrDefault(p => p.Key == sourcePortKey);
+
+            ReleaseAndMakeRoute(destination, source, signalType, inputPort, outputPort);
+        }
+
+        public static void RemoveRouteRequestForDestination(string destinationKey)
+        {
+            Debug.LogMessage(LogEventLevel.Information, "Removing route request for {destination}", null, destinationKey);
+
+            var result = RouteRequests.Remove(destinationKey);
+
+            var messageTemplate = result ? "Route Request for {destination} removed" : "Route Request for {destination} not found";
+
+            Debug.LogMessage(LogEventLevel.Information, messageTemplate, null, destinationKey);
+        }
+
+        private static void ReleaseAndMakeRoute(IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, RoutingInputPort destinationPort = null, RoutingOutputPort sourcePort = null)
+        {
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (destinationPort == null) Debug.LogMessage(LogEventLevel.Information, "Destination port is null");
+            if (sourcePort == null) Debug.LogMessage(LogEventLevel.Information, "Source port is null");
+
+            var routeRequest = new RouteRequest
+            {
+                Destination = destination,
+                DestinationPort = destinationPort,
+                Source = source,
+                SourcePort = sourcePort,
+                SignalType = signalType
+            };
+
+            var coolingDevice = destination as IWarmingCooling;
+
+
+            //We already have a route request for this device, and it's a cooling device and is cooling
+            if (RouteRequests.TryGetValue(destination.Key, out RouteRequest existingRouteRequest) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
+            {
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRouteRequest.HandleCooldown;
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
+
+                RouteRequests[destination.Key] = routeRequest;
+
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is cooling down and already has a routing request stored.  Storing new route request to route to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+
+                return;
+            }
+
+            //New Request
+            if (coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
+            {
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= routeRequest.HandleCooldown;
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
+
+                RouteRequests.Add(destination.Key, routeRequest);
+
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is cooling down.  Storing route request to route to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+                return;
+            }
+
+            if (RouteRequests.ContainsKey(destination.Key) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == false)
+            {
+                RouteRequests.Remove(destination.Key);
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is NOT cooling down.  Removing stored route request and routing to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+            }
+
+            destination.ReleaseRoute(destinationPort?.Key ?? string.Empty);
+
+            RunRouteRequest(routeRequest);
+        }
+
+        private static void RunRouteRequest(RouteRequest request)
+        {
+            if (request.Source == null)
+                return;
+
+            var (audioOrSingleRoute, videoRoute) = request.Destination.GetRouteToSource(request.Source, request.SignalType, request.DestinationPort, request.SourcePort);
+
+            if (audioOrSingleRoute == null && videoRoute == null)
+                return;
+
+            RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(audioOrSingleRoute);
+
+            if (videoRoute != null)
+            {
+                RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(videoRoute);
+            }
+
+            Debug.LogMessage(LogEventLevel.Verbose, "Executing full route", request.Destination);
+
+            audioOrSingleRoute.ExecuteRoutes();
+            videoRoute?.ExecuteRoutes();
+        }
+
+        public static void ReleaseRoute(this IRoutingInputs destination)
+        {
+            ReleaseRoute(destination, string.Empty);
+        }
+
+        /// <summary>
+        /// Will release the existing route on the destination, if it is found in 
+        /// RouteDescriptorCollection.DefaultCollection
+        /// </summary>
+        /// <param name="destination"></param>       
+        public static void ReleaseRoute(this IRoutingInputs destination, string inputPortKey)
+        {
+
+            Debug.LogMessage(LogEventLevel.Information, "Release route for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+
+            if (RouteRequests.TryGetValue(destination.Key, out RouteRequest existingRequest) && destination is IWarmingCooling)
+            {
+                var coolingDevice = destination as IWarmingCooling;
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRequest.HandleCooldown;
+            }
+
+            RouteRequests.Remove(destination.Key);
+
+            var current = RouteDescriptorCollection.DefaultCollection.RemoveRouteDescriptor(destination, inputPortKey);
+            if (current != null)
+            {
+                Debug.LogMessage(LogEventLevel.Debug, "Releasing current route: {0}", destination, current.Source.Key);
+                current.ReleaseRoutes();
+            }
+        }
+
+        /// <summary>
+        /// Builds a RouteDescriptor that contains the steps necessary to make a route between devices.  
+        /// Routes of type AudioVideo will be built as two separate routes, audio and video. If
+        /// a route is discovered, a new RouteDescriptor is returned.  If one or both parts
+        /// of an audio/video route are discovered a route descriptor is returned.  If no route is 
+        /// discovered, then null is returned
+        /// </summary>
+        public static (RouteDescriptor, RouteDescriptor) GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, RoutingInputPort destinationPort, RoutingOutputPort sourcePort)
+        {
+            // if it's a single signal type, find the route
+            if (!signalType.HasFlag(eRoutingSignalType.AudioVideo))
+            {
+                var singleTypeRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, signalType);
+                Debug.LogMessage(LogEventLevel.Debug, "Attempting to build source route from {sourceKey} of type {type}", destination, source.Key, signalType);
+
+                if (!destination.GetRouteToSource(source, null, null, signalType, 0, singleTypeRouteDescriptor, destinationPort, sourcePort))
+                    singleTypeRouteDescriptor = null;
+
+                foreach (var route in singleTypeRouteDescriptor.Routes)
+                {
+                    Debug.LogMessage(LogEventLevel.Verbose, "Route for device: {route}", destination, route.ToString());
+                }
+
+                return (singleTypeRouteDescriptor, null);
+            }
+            // otherwise, audioVideo needs to be handled as two steps.
+
+            Debug.LogMessage(LogEventLevel.Debug, "Attempting to build source route from {sourceKey} of type {type}", destination, source.Key);
+
+            var audioRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, eRoutingSignalType.Audio);
+
+            var audioSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Audio, 0, audioRouteDescriptor, destinationPort, sourcePort);
+
+            if (!audioSuccess)
+                Debug.LogMessage(LogEventLevel.Debug, "Cannot find audio route to {0}", destination, source.Key);
+
+            var videoRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, eRoutingSignalType.Video);
+
+            var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, videoRouteDescriptor, destinationPort, sourcePort);
+
+            if (!videoSuccess)
+                Debug.LogMessage(LogEventLevel.Debug, "Cannot find video route to {0}", destination, source.Key);
+
+            foreach (var route in audioRouteDescriptor.Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "Audio route for device: {route}", destination, route.ToString());
+            }
+
+            foreach (var route in videoRouteDescriptor.Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "Video route for device: {route}", destination, route.ToString());
+            }
+
+
+            if (!audioSuccess && !videoSuccess)
+                return (null, null);
+
+
+            return (audioRouteDescriptor, videoRouteDescriptor);
+        }
+
+        /// <summary>
+        /// The recursive part of this.  Will stop on each device, search its inputs for the 
+        /// desired source and if not found, invoke this function for the each input port
+        /// hoping to find the source.
+        /// </summary>
+        /// <param name="destination"></param>
+        /// <param name="source"></param>
+        /// <param name="destinationPort">The RoutingOutputPort whose link is being checked for a route</param>
+        /// <param name="alreadyCheckedDevices">Prevents Devices from being twice-checked</param>
+        /// <param name="signalType">This recursive function should not be called with AudioVideo</param>
+        /// <param name="cycle">Just an informational counter</param>
+        /// <param name="routeTable">The RouteDescriptor being populated as the route is discovered</param>
+        /// <returns>true if source is hit</returns>
+        private static bool GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source,
+            RoutingOutputPort outputPortToUse, List<IRoutingInputsOutputs> alreadyCheckedDevices,
+                eRoutingSignalType signalType, int cycle, RouteDescriptor routeTable, RoutingInputPort destinationPort, RoutingOutputPort sourcePort)
+        {
+            cycle++;
+
+            Debug.LogMessage(LogEventLevel.Verbose, "GetRouteToSource: {cycle} {sourceKey}:{sourcePortKey}--> {destinationKey}:{destinationPortKey} {type}", null, cycle, source.Key, sourcePort?.Key ?? "auto", destination.Key, destinationPort?.Key ?? "auto", signalType.ToString());
+
+            RoutingInputPort goodInputPort = null;
+
+            IEnumerable<TieLine> destinationTieLines;
+            TieLine directTie = null;
+
+            if (destinationPort == null)
+            {
+
+                destinationTieLines = TieLineCollection.Default.Where(t =>
+                    t.DestinationPort.ParentDevice.Key == destination.Key && (t.Type == signalType || t.Type.HasFlag(eRoutingSignalType.AudioVideo)));
+            }
+            else
+            {
+                destinationTieLines = TieLineCollection.Default.Where(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && (t.Type == signalType || t.Type.HasFlag(eRoutingSignalType.AudioVideo)));
+            }
+
+            // find the TieLine without a port
+            if (destinationPort == null && sourcePort == null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.SourcePort.ParentDevice.Key == source.Key);
+            }
+            // find a tieLine to a specific destination port without a specific source port
+            else if (destinationPort != null && sourcePort == null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && t.SourcePort.ParentDevice.Key == source.Key);
+            }
+            // find a tieline to a specific source port without a specific destination port
+            else if (destinationPort == null & sourcePort != null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.SourcePort.ParentDevice.Key == source.Key && t.SourcePort.Key == sourcePort.Key);
+            }
+            // find a tieline to a specific source port and destination port
+            else if (destinationPort != null && sourcePort != null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && t.SourcePort.ParentDevice.Key == source.Key && t.SourcePort.Key == sourcePort.Key);
+            }
+
+            if (directTie != null) // Found a tie directly to the source
+            {
+                goodInputPort = directTie.DestinationPort;
+            }
+            else // no direct-connect.  Walk back devices.
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "is not directly connected to {sourceKey}. Walking down tie lines", destination, source.Key);
+
+                // No direct tie? Run back out on the inputs' attached devices... 
+                // Only the ones that are routing devices
+                var midpointTieLines = destinationTieLines.Where(t => t.SourcePort.ParentDevice is IRoutingInputsOutputs);
+
+                //Create a list for tracking already checked devices to avoid loops, if it doesn't already exist from previous iteration
+                if (alreadyCheckedDevices == null)
+                    alreadyCheckedDevices = new List<IRoutingInputsOutputs>();
+                alreadyCheckedDevices.Add(destination as IRoutingInputsOutputs);
+
+                foreach (var tieLine in midpointTieLines)
+                {
+                    var midpointDevice = tieLine.SourcePort.ParentDevice as IRoutingInputsOutputs;
+
+                    // Check if this previous device has already been walked
+                    if (alreadyCheckedDevices.Contains(midpointDevice))
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Skipping input {midpointDeviceKey} on {destinationKey}, this was already checked", destination, midpointDevice.Key, destination.Key);
+                        continue;
+                    }
+
+                    var midpointOutputPort = tieLine.SourcePort;
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Trying to find route on {midpointDeviceKey}", destination, midpointDevice.Key);
+
+                    // haven't seen this device yet.  Do it.  Pass the output port to the next
+                    // level to enable switching on success
+                    var upstreamRoutingSuccess = midpointDevice.GetRouteToSource(source, midpointOutputPort,
+                        alreadyCheckedDevices, signalType, cycle, routeTable, null, sourcePort);
+
+                    if (upstreamRoutingSuccess)
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Upstream device route found", destination);
+                        Debug.LogMessage(LogEventLevel.Verbose, "Route found on {midpointDeviceKey}", destination, midpointDevice.Key);
+                        Debug.LogMessage(LogEventLevel.Verbose, "TieLine: SourcePort: {SourcePort} DestinationPort: {DestinationPort}", destination, tieLine.SourcePort, tieLine.DestinationPort);
+                        goodInputPort = tieLine.DestinationPort;
+                        break; // Stop looping the inputs in this cycle
+                    }
+                }
+            }
+
+
+            if (goodInputPort == null)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "No route found to {0}", destination, source.Key);
+                return false;
+            }
+
+            // we have a route on corresponding inputPort. *** Do the route ***
+
+            if (destination is IRoutingSink)
+            {
+                // it's a sink device
+                routeTable.Routes.Add(new RouteSwitchDescriptor(goodInputPort));
+            }
+            else if (destination is IRouting)
+            {
+                routeTable.Routes.Add(new RouteSwitchDescriptor(outputPortToUse, goodInputPort));
+            }
+            else // device is merely IRoutingInputOutputs
+                Debug.LogMessage(LogEventLevel.Verbose, "No routing. Passthrough device", destination);
+
+            return true;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/IHasCurrentSourceInfoChange.cs

@@ -0,0 +1,30 @@
+/* Unmerged change from project 'PepperDash.Essentials.Core (net6)'
+Before:
+namespace PepperDash.Essentials.Core.Routing.Interfaces
+After:
+using PepperDash;
+using PepperDash.Essentials;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Core.Routing.Interfaces
+*/
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// The handler type for a Room's SourceInfoChange
+    /// </summary>
+    public delegate void SourceInfoChangeHandler(SourceListItem info, ChangeType type);
+    //*******************************************************************************************
+    // Interfaces
+
+    /// <summary>
+    /// For rooms with a single presentation source, change event
+    /// </summary>
+    public interface IHasCurrentSourceInfoChange
+    {
+        string CurrentSourceInfoKey { get; set; }
+        SourceListItem CurrentSourceInfo { get; set; }
+        event SourceInfoChangeHandler CurrentSourceChange;
+    }
+}

src/PepperDash.Essentials.Core/Routing/IInputSync.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core.Routing
 {
-    public interface IVideoSync: IKeyed
+    public interface IVideoSync : IKeyed
     {
         bool VideoSyncDetected { get; }
 

src/PepperDash.Essentials.Core/Routing/IRmcRouting.cs

@@ -0,0 +1,10 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a receiver that has internal routing (DM-RMC-4K-Z-SCALER-C)
+    /// </summary>
+    public interface IRmcRouting : IRoutingNumeric
+    {
+        IntFeedback AudioVideoSourceNumericFeedback { get; }
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRmcRoutingWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRmcRouting with a feedback event 
+    /// </summary>
+    public interface IRmcRoutingWithFeedback : IRmcRouting
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRouting.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a midpoint device as have internal routing.  Any devices in the middle of the
+    /// signal chain, that do switching, must implement this for routing to work otherwise
+    /// the routing algorithm will treat the IRoutingInputsOutputs device as a passthrough
+    /// device.
+    /// </summary>
+    public interface IRouting : IRoutingInputsOutputs
+	{
+		void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType);        
+    }    
+
+    /*public interface IRouting<TInputSelector,TOutputSelector> : IRoutingInputsOutputs
+    {
+        void ExecuteSwitch(TInputSelector inputSelector, TOutputSelector outputSelector, eRoutingSignalType signalType);
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingFeedback.cs

@@ -0,0 +1,16 @@
+using System;
+
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an event structure for reporting output route data
+    /// </summary>
+    public interface IRoutingFeedback : IKeyName
+    {
+        event EventHandler<RoutingNumericEventArgs> NumericSwitchChange;
+        //void OnSwitchChange(RoutingNumericEventArgs e);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingHasVideoInputSyncFeedbacks.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+
+	public interface IRoutingHasVideoInputSyncFeedbacks
+	{
+		FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; }
+	}	
+}

src/PepperDash.Essentials.Core/Routing/IRoutingInputs.cs

@@ -0,0 +1,18 @@
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a class that has a collection of RoutingInputPorts
+    /// </summary>
+    public interface IRoutingInputs : IKeyed
+	{
+		RoutingPortCollection<RoutingInputPort> InputPorts { get; }
+	}
+
+/*    public interface IRoutingInputs<TSelector> : IKeyed
+    {
+        RoutingPortCollection<RoutingInputPort<TSelector>, TSelector> InputPorts { get; }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingInputsExtensions.cs

@@ -1,426 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-using Serilog.Events;
-
-
-namespace PepperDash.Essentials.Core
-{
-    public class RouteRequest
-    {
-        public IRoutingSink Destination {get; set;}
-        public IRoutingOutputs Source {get; set;}
-        public eRoutingSignalType SignalType {get; set;}
-
-        public void HandleCooldown(object sender, FeedbackEventArgs args)
-        {
-            var coolingDevice = sender as IWarmingCooling;
-            
-            if(args.BoolValue == false)
-            {
-                Destination.ReleaseAndMakeRoute(Source, SignalType);
-                
-                if(sender == null) return;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= HandleCooldown;
-            }
-        }
-    }
-
-	/// <summary>
-	/// Extensions added to any IRoutingInputs classes to provide discovery-based routing
-	/// on those destinations.
-	/// </summary>
-	public static class IRoutingInputsExtensions
-	{
-        private static Dictionary<string, RouteRequest> RouteRequests = new Dictionary<string, RouteRequest>();
-		/// <summary>
-		/// Gets any existing RouteDescriptor for a destination, clears it using ReleaseRoute
-		/// and then attempts a new Route and if sucessful, stores that RouteDescriptor
-		/// in RouteDescriptorCollection.DefaultCollection
-		/// </summary>
-		public static void ReleaseAndMakeRoute(this IRoutingSink destination, IRoutingOutputs source, eRoutingSignalType signalType)
-		{
-            var routeRequest = new RouteRequest { 
-                        Destination = destination,
-                        Source = source,
-                        SignalType = signalType
-                    };
-
-            var coolingDevice = destination as IWarmingCooling;
-
-            RouteRequest existingRouteRequest;
-
-            //We already have a route request for this device, and it's a cooling device and is cooling
-            if (RouteRequests.TryGetValue(destination.Key, out existingRouteRequest) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
-            {     
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRouteRequest.HandleCooldown;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
-
-                RouteRequests[destination.Key] = routeRequest;
-
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is cooling down and already has a routing request stored.  Storing new route request to route to source key: {1}", destination.Key, routeRequest.Source.Key);
-
-                return;
-            }            
-            
-            //New Request
-            if (coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
-            {
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= routeRequest.HandleCooldown;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
-
-                RouteRequests.Add(destination.Key, routeRequest);
-
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is cooling down.  Storing route request to route to source key: {1}", destination.Key, routeRequest.Source.Key);
-                return;
-            }
-
-            if (RouteRequests.ContainsKey(destination.Key) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == false)
-            {
-                RouteRequests.Remove(destination.Key);
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is NOT cooling down.  Removing stored route request and routing to source key: {1}", destination.Key, routeRequest.Source.Key);
-            }
-
-            destination.ReleaseRoute();
-
-			RunRouteRequest(routeRequest);
-		}
-
-        public static void RunRouteRequest(RouteRequest request)
-        {
-            if (request.Source == null) return;
-            var newRoute = request.Destination.GetRouteToSource(request.Source, request.SignalType);
-            if (newRoute == null) return;
-            RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(newRoute);
-            Debug.LogMessage(LogEventLevel.Verbose, request.Destination, "Executing full route");
-            newRoute.ExecuteRoutes();
-        }
-
-		/// <summary>
-		/// Will release the existing route on the destination, if it is found in 
-		/// RouteDescriptorCollection.DefaultCollection
-		/// </summary>
-		/// <param name="destination"></param>
-        public static void ReleaseRoute(this IRoutingSink destination)
-		{
-            RouteRequest existingRequest;
-
-            if (RouteRequests.TryGetValue(destination.Key, out existingRequest) && destination is IWarmingCooling)
-            {
-                var coolingDevice = destination as IWarmingCooling;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRequest.HandleCooldown;
-            }
-
-            RouteRequests.Remove(destination.Key);
-
-			var current = RouteDescriptorCollection.DefaultCollection.RemoveRouteDescriptor(destination);
-			if (current != null)
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Releasing current route: {0}", current.Source.Key);
-				current.ReleaseRoutes();
-			}
-		}
-
-		/// <summary>
-		/// Builds a RouteDescriptor that contains the steps necessary to make a route between devices.  
-		/// Routes of type AudioVideo will be built as two separate routes, audio and video. If
-		/// a route is discovered, a new RouteDescriptor is returned.  If one or both parts
-		/// of an audio/video route are discovered a route descriptor is returned.  If no route is 
-		/// discovered, then null is returned
-		/// </summary>
-        public static RouteDescriptor GetRouteToSource(this IRoutingSink destination, IRoutingOutputs source, eRoutingSignalType signalType)
-		{
-			var routeDescr = new RouteDescriptor(source, destination, signalType);
-			// if it's a single signal type, find the route
-			if ((signalType & (eRoutingSignalType.Audio & eRoutingSignalType.Video)) == (eRoutingSignalType.Audio & eRoutingSignalType.Video))
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Attempting to build source route from {0}", source.Key);
-				if (!destination.GetRouteToSource(source, null, null, signalType, 0, routeDescr))
-					routeDescr = null;
-			}
-			// otherwise, audioVideo needs to be handled as two steps.
-			else
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Attempting to build audio and video routes from {0}", source.Key);
-				var audioSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Audio, 0, routeDescr);
-				if (!audioSuccess)
-					Debug.LogMessage(LogEventLevel.Debug, destination, "Cannot find audio route to {0}", source.Key);
-				var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, routeDescr);
-				if (!videoSuccess)
-					Debug.LogMessage(LogEventLevel.Debug, destination, "Cannot find video route to {0}", source.Key);
-				if (!audioSuccess && !videoSuccess)
-					routeDescr = null;
-			}
-
-            //Debug.LogMessage(LogEventLevel.Debug, destination, "Route{0} discovered", routeDescr == null ? " NOT" : "");
-			return routeDescr;
-		}
-
-		/// <summary>
-		/// The recursive part of this.  Will stop on each device, search its inputs for the 
-		/// desired source and if not found, invoke this function for the each input port
-		/// hoping to find the source.
-		/// </summary>
-		/// <param name="destination"></param>
-		/// <param name="source"></param>
-		/// <param name="outputPortToUse">The RoutingOutputPort whose link is being checked for a route</param>
-		/// <param name="alreadyCheckedDevices">Prevents Devices from being twice-checked</param>
-		/// <param name="signalType">This recursive function should not be called with AudioVideo</param>
-		/// <param name="cycle">Just an informational counter</param>
-		/// <param name="routeTable">The RouteDescriptor being populated as the route is discovered</param>
-		/// <returns>true if source is hit</returns>
-		static bool GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source,
-			RoutingOutputPort outputPortToUse, List<IRoutingInputsOutputs> alreadyCheckedDevices, 
-				eRoutingSignalType signalType, int cycle, RouteDescriptor routeTable)
-		{
-			cycle++;
-			Debug.LogMessage(LogEventLevel.Verbose, "GetRouteToSource: {0} {1}--> {2}", cycle, source.Key, destination.Key);
-
-			RoutingInputPort goodInputPort = null;
-			var destDevInputTies = TieLineCollection.Default.Where(t =>
-                t.DestinationPort.ParentDevice == destination && (t.Type == signalType || (t.Type & (eRoutingSignalType.Audio | eRoutingSignalType.Video)) == (eRoutingSignalType.Audio | eRoutingSignalType.Video)));
-
-			// find a direct tie
-			var directTie = destDevInputTies.FirstOrDefault(
-				t => t.DestinationPort.ParentDevice == destination 
-					&& t.SourcePort.ParentDevice == source);
-			if (directTie != null) // Found a tie directly to the source
-			{
-				goodInputPort = directTie.DestinationPort;
-			}
-			else // no direct-connect.  Walk back devices.
-			{
-				Debug.LogMessage(LogEventLevel.Verbose, destination, "is not directly connected to {0}. Walking down tie lines", source.Key);
-
-				// No direct tie? Run back out on the inputs' attached devices... 
-				// Only the ones that are routing devices
-				var attachedMidpoints = destDevInputTies.Where(t => t.SourcePort.ParentDevice is IRoutingInputsOutputs);
-
-                //Create a list for tracking already checked devices to avoid loops, if it doesn't already exist from previous iteration
-                if (alreadyCheckedDevices == null)
-                    alreadyCheckedDevices = new List<IRoutingInputsOutputs>();
-                alreadyCheckedDevices.Add(destination as IRoutingInputsOutputs);
-
-				foreach (var inputTieToTry in attachedMidpoints)
-				{
-					var upstreamDeviceOutputPort = inputTieToTry.SourcePort;
-					var upstreamRoutingDevice = upstreamDeviceOutputPort.ParentDevice as IRoutingInputsOutputs;
-                    Debug.LogMessage(LogEventLevel.Verbose, destination, "Trying to find route on {0}", upstreamRoutingDevice.Key);
-
-					// Check if this previous device has already been walked
-                    if (alreadyCheckedDevices.Contains(upstreamRoutingDevice))
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, destination, "Skipping input {0} on {1}, this was already checked", upstreamRoutingDevice.Key, destination.Key);
-                        continue;
-                    }
-                    // haven't seen this device yet.  Do it.  Pass the output port to the next
-                    // level to enable switching on success
-                    var upstreamRoutingSuccess = upstreamRoutingDevice.GetRouteToSource(source, upstreamDeviceOutputPort,
-                        alreadyCheckedDevices, signalType, cycle, routeTable);
-                    if (upstreamRoutingSuccess)
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, destination, "Upstream device route found");
-                        goodInputPort = inputTieToTry.DestinationPort;
-                        break; // Stop looping the inputs in this cycle
-                    }
-				}
-			}
-
-			// we have a route on corresponding inputPort. *** Do the route ***
-			if (goodInputPort != null) 
-			{
-                //Debug.LogMessage(LogEventLevel.Verbose, destination, "adding RouteDescriptor");
-				if (outputPortToUse == null)
-				{
-					// it's a sink device
-                        routeTable.Routes.Add(new RouteSwitchDescriptor(goodInputPort));
-				}
-				else if (destination is IRouting)
-				{
-					routeTable.Routes.Add(new RouteSwitchDescriptor (outputPortToUse, goodInputPort));
-				}
-				else // device is merely IRoutingInputOutputs
-					Debug.LogMessage(LogEventLevel.Verbose, destination, "    No routing. Passthrough device");
-                //Debug.LogMessage(LogEventLevel.Verbose, destination, "Exiting cycle {0}", cycle);
-				return true;
-			}
-
-			Debug.LogMessage(LogEventLevel.Verbose, destination, "No route found to {0}", source.Key);
-			return false;
-		}
-	}
-
-
-
-
-
-	// MOVE MOVE MOVE MOVE MOVE MOVE MOVE  MOVE MOVE MOVE MOVE MOVE MOVE MOVE  MOVE MOVE MOVE MOVE MOVE MOVE MOVE 
-
-
-	/// <summary>
-	/// A collection of RouteDescriptors - typically the static DefaultCollection is used
-	/// </summary>
-	public class RouteDescriptorCollection
-	{
-		public static RouteDescriptorCollection DefaultCollection
-		{
-			get
-			{
-				if (_DefaultCollection == null)
-					_DefaultCollection = new RouteDescriptorCollection();
-				return _DefaultCollection;
-			}
-		}
-		static RouteDescriptorCollection _DefaultCollection;
-
-		List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
-
-		/// <summary>
-		/// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
-		/// destination exists already, it will not be added - in order to preserve
-		/// proper route releasing.
-		/// </summary>
-		/// <param name="descriptor"></param>
-		public void AddRouteDescriptor(RouteDescriptor descriptor)
-		{
-			if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination))
-			{
-				Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination, 
-					"Route to [{0}] already exists in global routes table", descriptor.Source.Key);
-				return;
-			}
-			RouteDescriptors.Add(descriptor);
-		}
-
-		/// <summary>
-		/// Gets the RouteDescriptor for a destination
-		/// </summary>
-		/// <returns>null if no RouteDescriptor for a destination exists</returns>
-		public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs destination)
-		{
-			return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
-		}
-
-		/// <summary>
-		/// Returns the RouteDescriptor for a given destination AND removes it from collection.
-		/// Returns null if no route with the provided destination exists.
-		/// </summary>
-		public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs destination)
-		{
-			var descr = GetRouteDescriptorForDestination(destination);
-			if (descr != null)
-				RouteDescriptors.Remove(descr);
-			return descr;
-		}
-	}
-
-	/// <summary>
-	/// Represents an collection of individual route steps between Source and Destination
-	/// </summary>
-	public class RouteDescriptor
-	{
-		public IRoutingInputs Destination { get; private set; }
-		public IRoutingOutputs Source { get; private set; }
-		public eRoutingSignalType SignalType { get; private set; }
-		public List<RouteSwitchDescriptor> Routes { get; private set; }
-
-
-		public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, eRoutingSignalType signalType)
-		{
-			Destination = destination;
-			Source = source;
-			SignalType = signalType;
-			Routes = new List<RouteSwitchDescriptor>();
-		}
-
-		/// <summary>
-		/// Executes all routes described in this collection.  Typically called via
-		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
-		/// </summary>
-		public void ExecuteRoutes()
-		{
-			foreach (var route in Routes)
-			{
-				Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}", route.ToString());
-                if (route.SwitchingDevice is IRoutingSink)
-                {
-                    var device = route.SwitchingDevice as IRoutingSinkWithSwitching;
-                    if (device == null)
-                        continue;
-
-                    device.ExecuteSwitch(route.InputPort.Selector);
-                }
-                else if (route.SwitchingDevice is IRouting)
-                {
-                    (route.SwitchingDevice as IRouting).ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
-                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
-                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
-                }
-			}
-		}
-
-		/// <summary>
-		/// Releases all routes in this collection. Typically called via
-		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
-		/// </summary>
-		public void ReleaseRoutes()
-		{
-			foreach (var route in Routes)
-			{
-				if (route.SwitchingDevice is IRouting)
-				{
-					// Pull the route from the port.  Whatever is watching the output's in use tracker is
-					// responsible for responding appropriately.
-					route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
-					Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
-				}
-			}
-		}
-
-		public override string ToString()
-		{
-			var routesText = Routes.Select(r => r.ToString()).ToArray();
-			return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
-		}
-	}
-
-	/// <summary>
-	/// Represents an individual link for a route
-	/// </summary>
-	public class RouteSwitchDescriptor
-	{
-		public IRoutingInputs SwitchingDevice { get { return InputPort.ParentDevice; } }
-		public RoutingOutputPort OutputPort { get; set; }
-		public RoutingInputPort InputPort { get; set; }
-
-		public RouteSwitchDescriptor(RoutingInputPort inputPort)
-		{
-			InputPort = inputPort;
-		}
-
-		public RouteSwitchDescriptor(RoutingOutputPort outputPort, RoutingInputPort inputPort)
-		{
-			InputPort = inputPort;
-			OutputPort = outputPort;
-		}
-
-		public override string ToString()
-		{
-			if(SwitchingDevice is IRouting)
-				return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
-			else
-				return string.Format("{0} switches to input '{1}'", SwitchingDevice.Key, InputPort.Selector);
-
-		}
-	}
-}

src/PepperDash.Essentials.Core/Routing/IRoutingInputsOutputs.cs

@@ -0,0 +1,16 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// For devices like RMCs, baluns, other devices with no switching.
+    /// </summary>
+    public interface IRoutingInputsOutputs : IRoutingInputs, IRoutingOutputs
+	{
+	}
+
+/*    /// <summary>
+    /// For devices like RMCs, baluns, other devices with no switching.
+    /// </summary>
+    public interface IRoutingInputsOutputs<TInputSelector, TOutputSelector> : IRoutingInputs<TInputSelector>, IRoutingOutputs<TOutputSelector>
+    {
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingNumeric.cs

@@ -0,0 +1,7 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface IRoutingNumeric : IRouting
+    {
+        void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingNumericWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRoutingNumeric with a feedback event 
+    /// </summary>
+    public interface IRoutingNumericWithFeedback : IRoutingNumeric, IRoutingFeedback
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingOutputs.cs

@@ -0,0 +1,19 @@
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a class that has a collection of RoutingOutputPorts
+    /// </summary>
+
+    public interface IRoutingOutputs : IKeyed
+	{
+		RoutingPortCollection<RoutingOutputPort> OutputPorts { get; }
+	}
+
+/*    public interface IRoutingOutputs<TSelector> : IKeyed
+    {
+        RoutingPortCollection<RoutingOutputPort<TSelector>, TSelector> OutputPorts { get; }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSink.cs

@@ -0,0 +1,23 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSink : IRoutingInputs, IHasCurrentSourceInfoChange
+    {        
+    }
+
+    public interface IRoutingSinkWithInputPort :IRoutingSink
+    {
+        RoutingInputPort CurrentInputPort { get; }
+    }
+    /*/// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSink<TSelector> : IRoutingInputs<TSelector>, IHasCurrentSourceInfoChange
+    {
+        void UpdateRouteRequest<TOutputSelector>(RouteRequest<TSelector, TOutputSelector> request);
+
+        RouteRequest<TSelector, TOutputSelector> GetRouteRequest<TOutputSelector>();
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSinkWithFeedback.cs

@@ -0,0 +1,25 @@
+using PepperDash.Essentials.Core.Routing;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    
+    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSinkWithFeedback : IRoutingSinkWithSwitching
+    {
+        
+    }
+
+/*    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSinkWithFeedback<TSelector> : IRoutingSinkWithSwitching<TSelector>
+    {
+        RouteSwitchDescriptor CurrentRoute { get; }
+
+        event EventHandler InputChanged;
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSinkWithSwitching.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace PepperDash.Essentials.Core
+{
+    public delegate void InputChangedEventHandler(IRoutingSinkWithSwitching destination, RoutingInputPort currentPort);
+
+    /// <summary>
+    /// Endpoint device like a display, that selects inputs
+    /// </summary>
+    public interface IRoutingSinkWithSwitching : IRoutingSink
+	{		
+		void ExecuteSwitch(object inputSelector);        
+    }
+
+    public interface IRoutingSinkWithSwitchingWithInputPort:IRoutingSinkWithSwitching, IRoutingSinkWithInputPort
+    {
+        event InputChangedEventHandler InputChanged;
+    }
+
+/*    /// <summary>
+    /// Endpoint device like a display, that selects inputs
+    /// </summary>
+    public interface IRoutingSinkWithSwitching<TSelector> : IRoutingSink<TSelector>
+    {
+        void ExecuteSwitch(TSelector inputSelector);
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSource.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRoutingOutputs devices as being a source - the start of the chain
+    /// </summary>
+    public interface IRoutingSource : IRoutingOutputs
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingWithClear.cs

@@ -0,0 +1,12 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface IRoutingWithClear : IRouting
+    {
+        /// <summary>
+        /// Clears a route to an output, however a device needs to do that
+        /// </summary>
+        /// <param name="outputSelector">Output to clear</param>
+        /// <param name="signalType">signal type to clear</param>
+        void ClearRoute(object outputSelector, eRoutingSignalType signalType);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingWithFeedback.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System;
+
+namespace PepperDash.Essentials.Core
+{
+    public delegate void RouteChangedEventHandler(IRoutingWithFeedback midpoint, RouteSwitchDescriptor newRoute);
+    /// <summary>
+    /// Defines an IRouting with a feedback event
+    /// </summary>
+    public interface IRoutingWithFeedback : IRouting
+    {
+        List<RouteSwitchDescriptor> CurrentRoutes { get; }
+
+        event RouteChangedEventHandler RouteChanged;
+    }
+}

src/PepperDash.Essentials.Core/Routing/ITxRouting.cs

@@ -0,0 +1,8 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface ITxRouting : IRoutingNumeric
+    {
+        IntFeedback VideoSourceNumericFeedback { get; }
+        IntFeedback AudioSourceNumericFeedback { get; }
+    }
+}

src/PepperDash.Essentials.Core/Routing/ITxRoutingWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRmcRouting with a feedback event 
+    /// </summary>
+    public interface ITxRoutingWithFeedback : ITxRouting
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/RouteDescriptor.cs

@@ -0,0 +1,162 @@
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+using Serilog.Events;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents an collection of individual route steps between Source and Destination
+    /// </summary>
+    public class RouteDescriptor
+	{
+		public IRoutingInputs Destination { get; private set; }
+
+        public RoutingInputPort InputPort { get; private set; }
+
+		public IRoutingOutputs Source { get; private set; }
+		public eRoutingSignalType SignalType { get; private set; }
+		public List<RouteSwitchDescriptor> Routes { get; private set; }
+
+
+		public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, eRoutingSignalType signalType):this(source,destination, null, signalType)
+		{
+		}
+
+        public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, RoutingInputPort inputPort, eRoutingSignalType signalType)
+        {
+            Destination = destination;
+            Source = source;
+            SignalType = signalType;
+            InputPort = inputPort;
+            Routes = new List<RouteSwitchDescriptor>();
+        }
+
+		/// <summary>
+		/// Executes all routes described in this collection.  Typically called via
+		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
+		/// </summary>
+		public void ExecuteRoutes()
+		{
+			foreach (var route in Routes)
+			{
+				Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}",null, route.ToString());
+
+                if (route.SwitchingDevice is IRoutingSinkWithSwitching sink)
+                {                   
+                    sink.ExecuteSwitch(route.InputPort.Selector);
+                    continue; 
+                }
+
+                if (route.SwitchingDevice is IRouting switchingDevice)
+                {
+                    switchingDevice.ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
+
+                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+			}
+		}
+
+		/// <summary>
+		/// Releases all routes in this collection. Typically called via
+		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
+		/// </summary>
+		public void ReleaseRoutes()
+		{
+			foreach (var route in Routes.Where(r => r.SwitchingDevice is IRouting))
+			{
+				if (route.SwitchingDevice is IRouting switchingDevice)
+				{
+                    switchingDevice.ExecuteSwitch(null, route.OutputPort.Selector, SignalType);
+
+					// Pull the route from the port.  Whatever is watching the output's in use tracker is
+					// responsible for responding appropriately.
+					route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
+					Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}",null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+				}
+			}
+		}
+
+		public override string ToString()
+		{
+			var routesText = Routes.Select(r => r.ToString()).ToArray();
+			return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
+		}
+	}
+
+    /*/// <summary>
+    /// Represents an collection of individual route steps between Source and Destination
+    /// </summary>
+    public class RouteDescriptor<TInputSelector, TOutputSelector>
+    {
+        public IRoutingInputs<TInputSelector> Destination { get; private set; }
+        public IRoutingOutputs<TOutputSelector> Source { get; private set; }
+        public eRoutingSignalType SignalType { get; private set; }
+        public List<RouteSwitchDescriptor<TInputSelector, TOutputSelector>> Routes { get; private set; }
+
+
+        public RouteDescriptor(IRoutingOutputs<TOutputSelector> source, IRoutingInputs<TInputSelector> destination, eRoutingSignalType signalType)
+        {
+            Destination = destination;
+            Source = source;
+            SignalType = signalType;
+            Routes = new List<RouteSwitchDescriptor<TInputSelector, TOutputSelector>>();
+        }
+
+        /// <summary>
+        /// Executes all routes described in this collection.  Typically called via
+        /// extension method IRoutingInputs.ReleaseAndMakeRoute()
+        /// </summary>
+        public void ExecuteRoutes()
+        {
+            foreach (var route in Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}", null, route.ToString());
+
+                if (route.SwitchingDevice is IRoutingSinkWithSwitching<TInputSelector> sink)
+                {
+                    sink.ExecuteSwitch(route.InputPort.Selector);
+                    continue;
+                }
+
+                if (route.SwitchingDevice is IRouting switchingDevice)
+                {
+                    switchingDevice.ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
+
+                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Releases all routes in this collection. Typically called via
+        /// extension method IRoutingInputs.ReleaseAndMakeRoute()
+        /// </summary>
+        public void ReleaseRoutes()
+        {
+            foreach (var route in Routes)
+            {
+                if (route.SwitchingDevice is IRouting<TInputSelector, TOutputSelector>)
+                {
+                    // Pull the route from the port.  Whatever is watching the output's in use tracker is
+                    // responsible for responding appropriately.
+                    route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
+                    Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            var routesText = Routes.Select(r => r.ToString()).ToArray();
+            return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RouteDescriptorCollection.cs

@@ -0,0 +1,143 @@
+using PepperDash.Core;
+using Serilog.Events;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// A collection of RouteDescriptors - typically the static DefaultCollection is used
+    /// </summary>
+    public class RouteDescriptorCollection
+    {
+        public static RouteDescriptorCollection DefaultCollection
+        {
+            get
+            {
+                if (_DefaultCollection == null)
+                    _DefaultCollection = new RouteDescriptorCollection();
+                return _DefaultCollection;
+            }
+        }
+        private static RouteDescriptorCollection _DefaultCollection;
+
+        private readonly List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
+
+        /// <summary>
+        /// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
+        /// destination exists already, it will not be added - in order to preserve
+        /// proper route releasing.
+        /// </summary>
+        /// <param name="descriptor"></param>
+        public void AddRouteDescriptor(RouteDescriptor descriptor)
+        {
+            if (descriptor == null)
+            {
+                return;
+            }
+
+            if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination)
+                && RouteDescriptors.Any(t => t.Destination == descriptor.Destination && t.InputPort != null && descriptor.InputPort != null && t.InputPort.Key == descriptor.InputPort.Key))
+            {
+                Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination,
+                    "Route to [{0}] already exists in global routes table", descriptor.Source.Key);
+                return;
+            }
+            RouteDescriptors.Add(descriptor);
+        }
+
+        /// <summary>
+        /// Gets the RouteDescriptor for a destination
+        /// </summary>
+        /// <returns>null if no RouteDescriptor for a destination exists</returns>
+        public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs destination)
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Getting route descriptor", destination);
+
+            return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
+        }
+
+        public RouteDescriptor GetRouteDescriptorForDestinationAndInputPort(IRoutingInputs destination, string inputPortKey)
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Getting route descriptor for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+            return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination && rd.InputPort != null && rd.InputPort.Key == inputPortKey);
+        }
+
+        /// <summary>
+        /// Returns the RouteDescriptor for a given destination AND removes it from collection.
+        /// Returns null if no route with the provided destination exists.
+        /// </summary>
+        public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs destination, string inputPortKey = "")
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Removing route descriptor for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+
+            var descr = string.IsNullOrEmpty(inputPortKey) 
+                ? GetRouteDescriptorForDestination(destination)
+                : GetRouteDescriptorForDestinationAndInputPort(destination, inputPortKey);
+            if (descr != null)
+                RouteDescriptors.Remove(descr);
+
+            Debug.LogMessage(LogEventLevel.Debug, "Found route descriptor {routeDescriptor}", destination, descr);
+
+            return descr;
+        }
+    }
+
+    /*/// <summary>
+    /// A collection of RouteDescriptors - typically the static DefaultCollection is used
+    /// </summary>
+    public class RouteDescriptorCollection<TInputSelector, TOutputSelector>
+	{
+		public static RouteDescriptorCollection<TInputSelector, TOutputSelector> DefaultCollection
+		{
+			get
+			{
+				if (_DefaultCollection == null)
+					_DefaultCollection = new RouteDescriptorCollection<TInputSelector, TOutputSelector>();
+				return _DefaultCollection;
+			}
+		}
+		private static RouteDescriptorCollection<TInputSelector, TOutputSelector> _DefaultCollection;
+
+		private readonly List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
+
+		/// <summary>
+		/// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
+		/// destination exists already, it will not be added - in order to preserve
+		/// proper route releasing.
+		/// </summary>
+		/// <param name="descriptor"></param>
+		public void AddRouteDescriptor(RouteDescriptor descriptor)
+		{
+			if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination))
+			{
+				Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination, 
+					"Route to [{0}] already exists in global routes table", descriptor.Source.Key);
+				return;
+			}
+			RouteDescriptors.Add(descriptor);
+		}
+
+		/// <summary>
+		/// Gets the RouteDescriptor for a destination
+		/// </summary>
+		/// <returns>null if no RouteDescriptor for a destination exists</returns>
+		public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs<TInputSelector> destination)
+		{
+			return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
+		}
+
+		/// <summary>
+		/// Returns the RouteDescriptor for a given destination AND removes it from collection.
+		/// Returns null if no route with the provided destination exists.
+		/// </summary>
+		public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs<TInputSelector> destination)
+		{
+			var descr = GetRouteDescriptorForDestination(destination);
+			if (descr != null)
+				RouteDescriptors.Remove(descr);
+			return descr;
+		}
+	}*/
+}

src/PepperDash.Essentials.Core/Routing/RouteRequest.cs

@@ -0,0 +1,34 @@
+using PepperDash.Core;
+using Serilog.Events;
+
+namespace PepperDash.Essentials.Core
+{
+    public class RouteRequest
+    {
+        public RoutingInputPort DestinationPort { get; set; }
+
+        public RoutingOutputPort SourcePort { get; set; }
+        public IRoutingInputs Destination { get; set; }
+        public IRoutingOutputs Source { get; set; }
+        public eRoutingSignalType SignalType { get; set; }
+
+        public void HandleCooldown(object sender, FeedbackEventArgs args)
+        {
+            Debug.LogMessage(LogEventLevel.Information, "Handling cooldown route request: {destination}:{destinationPort} -> {source}:{sourcePort} {type}", null, Destination.Key, DestinationPort.Key, Source.Key, SourcePort.Key, SignalType.ToString());
+
+            if (args.BoolValue == true)
+            {
+                return;
+            }
+
+            Debug.LogMessage(LogEventLevel.Information, "Cooldown complete. Making route from {destination} to {source}", Destination.Key, Source.Key);
+            Destination.ReleaseAndMakeRoute(Source, SignalType, DestinationPort?.Key ?? string.Empty, SourcePort?.Key ?? string.Empty);
+
+            if (sender is IWarmingCooling coolingDevice)
+            {
+                Debug.LogMessage(LogEventLevel.Debug, "Unsubscribing from cooling feedback for {destination}", null, Destination.Key);
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= HandleCooldown;
+            }
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RouteSwitchDescriptor.cs

@@ -0,0 +1,60 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents an individual link for a route
+    /// </summary>
+    public class RouteSwitchDescriptor
+	{
+		public IRoutingInputs SwitchingDevice { get { return InputPort.ParentDevice; } }
+		public RoutingOutputPort OutputPort { get; set; }
+		public RoutingInputPort InputPort { get; set; }
+
+		public RouteSwitchDescriptor(RoutingInputPort inputPort)
+		{
+			InputPort = inputPort;
+		}
+
+		public RouteSwitchDescriptor(RoutingOutputPort outputPort, RoutingInputPort inputPort)
+		{
+			InputPort = inputPort;
+			OutputPort = outputPort;
+		}
+
+		public override string ToString()
+		{
+            if (SwitchingDevice is IRouting)
+                return $"{SwitchingDevice?.Key} switches output {OutputPort.Key} to input {InputPort.Key}";
+            else
+                return $"{SwitchingDevice.Key} switches to input {InputPort.Key}";
+		}
+	}
+
+    /*/// <summary>
+    /// Represents an individual link for a route
+    /// </summary>
+    public class RouteSwitchDescriptor<TInputSelector, TOutputSelector>
+    {
+        public IRoutingInputs<TInputSelector> SwitchingDevice { get { return InputPort.ParentDevice; } }
+        public RoutingOutputPort<TOutputSelector> OutputPort { get; set; }
+        public RoutingInputPort<TInputSelector> InputPort { get; set; }
+
+        public RouteSwitchDescriptor(RoutingInputPort<TInputSelector> inputPort)
+        {
+            InputPort = inputPort;
+        }
+
+        public RouteSwitchDescriptor(RoutingOutputPort<TOutputSelector> outputPort, RoutingInputPort<TInputSelector> inputPort)
+        {
+            InputPort = inputPort;
+            OutputPort = outputPort;
+        }
+
+        public override string ToString()
+        {
+            if (SwitchingDevice is IRouting)
+                return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
+            else
+                return string.Format("{0} switches to input '{1}'", SwitchingDevice.Key, InputPort.Selector);
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingFeedbackManager.cs

@@ -0,0 +1,269 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using System;
+using System.Linq;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public class RoutingFeedbackManager:EssentialsDevice
+    {
+        public RoutingFeedbackManager(string key, string name): base(key, name)
+        {            
+            AddPreActivationAction(SubscribeForMidpointFeedback);
+            AddPreActivationAction(SubscribeForSinkFeedback);
+        }
+
+
+        private void SubscribeForMidpointFeedback()
+        {
+            var midpointDevices = DeviceManager.AllDevices.OfType<IRoutingWithFeedback>();
+
+            foreach (var device in midpointDevices)
+            {
+                device.RouteChanged += HandleMidpointUpdate;
+            }
+        }
+
+        private void SubscribeForSinkFeedback()
+        {
+                var sinkDevices = DeviceManager.AllDevices.OfType<IRoutingSinkWithSwitchingWithInputPort>();
+
+                foreach (var device in sinkDevices)
+                {
+                    device.InputChanged += HandleSinkUpdate;
+                }   
+        }
+
+        private void HandleMidpointUpdate(IRoutingWithFeedback midpoint, RouteSwitchDescriptor newRoute)
+        {
+            try
+            {
+                var devices = DeviceManager.AllDevices.OfType<IRoutingSinkWithSwitchingWithInputPort>();
+
+                foreach (var device in devices)
+                {
+                    UpdateDestination(device, device.CurrentInputPort);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error handling midpoint update from {midpointKey}:{Exception}", this, midpoint.Key, ex);
+            }
+        }
+
+        private void HandleSinkUpdate(IRoutingSinkWithSwitching sender, RoutingInputPort currentInputPort)
+        {
+            try
+            {
+                UpdateDestination(sender, currentInputPort);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error handling Sink update from {senderKey}:{Exception}", this, sender.Key, ex);
+            }
+        }
+
+        private void UpdateDestination(IRoutingSinkWithSwitching destination, RoutingInputPort inputPort)
+        {            
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Updating destination {destination} with inputPort {inputPort}", this,destination?.Key, inputPort?.Key);
+
+            if(inputPort == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "Destination {destination} has not reported an input port yet", this,destination.Key);
+                return;
+            }
+
+            TieLine firstTieLine;
+            try
+            {
+                var tieLines = TieLineCollection.Default;
+
+                firstTieLine = tieLines.FirstOrDefault(tl => tl.DestinationPort.Key == inputPort.Key && tl.DestinationPort.ParentDevice.Key == inputPort.ParentDevice.Key);
+
+                if (firstTieLine == null)
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No tieline found for inputPort {inputPort}. Clearing current source", this, inputPort);
+
+                    var tempSourceListItem = new SourceListItem
+                    {
+                        SourceKey = "$transient",
+                        Name = inputPort.Key,
+                    };
+
+
+                    destination.CurrentSourceInfo = tempSourceListItem;                        ;
+                    destination.CurrentSourceInfoKey = "$transient";
+                    return;
+                }
+            } catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error getting first tieline: {Exception}", this, ex);
+                return;
+            }
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Getting source for first TieLine {tieLine}", this, firstTieLine);
+
+            TieLine sourceTieLine;
+            try
+            {
+                sourceTieLine = GetRootTieLine(firstTieLine);
+
+                if (sourceTieLine == null)
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No route found to source for inputPort {inputPort}. Clearing current source", this, inputPort);
+
+                    var tempSourceListItem = new SourceListItem
+                    {
+                        SourceKey = "$transient",
+                        Name = "None",
+                    };
+
+                    destination.CurrentSourceInfo = tempSourceListItem;
+                    destination.CurrentSourceInfoKey = string.Empty;
+                    return;
+                }
+            } catch(Exception ex)
+            {
+                Debug.LogMessage(ex, "Error getting sourceTieLine: {Exception}", this, ex);
+                return;
+            }
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root TieLine {tieLine}", this, sourceTieLine);           
+
+            // Does not handle combinable scenarios or other scenarios where a display might be part of multiple rooms yet.
+            var room = DeviceManager.AllDevices.OfType<IEssentialsRoom>().FirstOrDefault((r) => {
+                if(r is IHasMultipleDisplays roomMultipleDisplays)
+                {
+                    return roomMultipleDisplays.Displays.Any(d => d.Value.Key == destination.Key);
+                }
+
+                if(r is IHasDefaultDisplay roomDefaultDisplay)
+                {
+                    return roomDefaultDisplay.DefaultDisplay.Key == destination.Key;
+                }
+
+                return false;
+            });
+            
+            if(room == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "No room found for display {destination}", this, destination.Key);
+                return;
+            }
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found room {room} for destination {destination}", this, room.Key, destination.Key);
+
+            var sourceList = ConfigReader.ConfigObject.GetSourceListForKey(room.SourceListKey);
+
+            if (sourceList == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "No source list found for source list key {key}. Unable to find source for tieLine {sourceTieLine}", this, room.SourceListKey, sourceTieLine);
+                return;
+            }
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found sourceList for room {room}", this, room.Key);
+
+            var sourceListItem = sourceList.FirstOrDefault(sli => {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose,
+                    "SourceListItem {sourceListItem}:{sourceKey} tieLine sourceport device key {sourcePortDeviceKey}",
+                    this,
+                    sli.Key,
+                    sli.Value.SourceKey,
+                    sourceTieLine.SourcePort.ParentDevice.Key);
+
+                return sli.Value.SourceKey.Equals(sourceTieLine.SourcePort.ParentDevice.Key,StringComparison.InvariantCultureIgnoreCase);
+            });            
+
+            var source = sourceListItem.Value;
+
+            if (source == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No source found for device {key}. Creating transient source for {destination}", this, sourceTieLine.SourcePort.ParentDevice.Key, destination);
+
+                var tempSourceListItem = new SourceListItem
+                {
+                    SourceKey = "$transient",
+                    Name = sourceTieLine.SourcePort.Key,
+                };
+
+                destination.CurrentSourceInfo = tempSourceListItem; ;
+                destination.CurrentSourceInfoKey = "$transient";
+                return;
+            }
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Got Source {source}", this, source);
+
+            destination.CurrentSourceInfo = source;
+            destination.CurrentSourceInfoKey = source.SourceKey;
+        }
+
+        private TieLine GetRootTieLine(TieLine tieLine)
+        {
+            TieLine nextTieLine = null;
+            try
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "**Following tieLine {tieLine}**", this, tieLine);
+
+                if (tieLine.SourcePort.ParentDevice is IRoutingWithFeedback midpoint)
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLine Source device {sourceDevice} is midpoint", this, midpoint);
+
+                    if(midpoint.CurrentRoutes == null || midpoint.CurrentRoutes.Count == 0)
+                    {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "Midpoint {midpointKey} has no routes",this, midpoint.Key);
+                        return null;
+                    }
+
+                    var currentRoute = midpoint.CurrentRoutes.FirstOrDefault(route => {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Checking {route} against {tieLine}", this, route, tieLine);
+
+                        return route.OutputPort.Key == tieLine.SourcePort.Key && route.OutputPort.ParentDevice.Key == tieLine.SourcePort.ParentDevice.Key;
+                    });
+
+                    if (currentRoute == null)
+                    {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No route through midpoint {midpoint} for outputPort {outputPort}", this, midpoint.Key, tieLine.SourcePort);
+                        return null;
+                    }
+
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found currentRoute {currentRoute} through {midpoint}", this, currentRoute, midpoint);
+
+                    nextTieLine = TieLineCollection.Default.FirstOrDefault(tl => { 
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Checking {route} against {tieLine}", tl.DestinationPort.Key, currentRoute.InputPort.Key);
+                        return tl.DestinationPort.Key == currentRoute.InputPort.Key && tl.DestinationPort.ParentDevice.Key == currentRoute.InputPort.ParentDevice.Key; });
+
+                    if (nextTieLine != null)
+                    {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found next tieLine {tieLine}. Walking the chain", this, nextTieLine);
+                        return GetRootTieLine(nextTieLine);
+                    }
+
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root tieLine {tieLine}", this,nextTieLine);
+                    return nextTieLine;
+                }
+
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLIne Source Device {sourceDeviceKey} is IRoutingSource: {isIRoutingSource}", this, tieLine.SourcePort.ParentDevice.Key, tieLine.SourcePort.ParentDevice is IRoutingSource);
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLine Source Device interfaces: {typeFullName}:{interfaces}", this, tieLine.SourcePort.ParentDevice.GetType().FullName, tieLine.SourcePort.ParentDevice.GetType().GetInterfaces().Select(i => i.Name));
+
+                if (tieLine.SourcePort.ParentDevice is IRoutingSource || tieLine.SourcePort.ParentDevice is IRoutingOutputs) //end of the chain
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root: {tieLine}", this, tieLine);
+                    return tieLine;
+                }
+
+                nextTieLine = TieLineCollection.Default.FirstOrDefault(tl => tl.DestinationPort.Key == tieLine.SourcePort.Key && tl.DestinationPort.ParentDevice.Key == tieLine.SourcePort.ParentDevice.Key );
+
+                if (nextTieLine != null)
+                {
+                    return GetRootTieLine(nextTieLine);
+                }
+            } catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error walking tieLines: {Exception}", this, ex);
+                return null;
+            }
+
+            return null;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RoutingInputPort.cs

@@ -0,0 +1,82 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Basic RoutingInput with no statuses.
+    /// </summary>
+    public class RoutingInputPort : RoutingPort
+	{
+		/// <summary>
+		/// The IRoutingInputs object this lives on
+		/// </summary>
+		public IRoutingInputs ParentDevice { get; private set; }
+
+		/// <summary>
+		/// Constructor for a basic RoutingInputPort
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingInputs object this lives on</param>
+		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingInputs parent)
+			: this (key, type, connType, selector, parent, false)
+		{
+		}
+
+		/// <summary>
+		/// Constructor for a virtual routing input port that lives inside a device. For example
+		/// the ports that link a DM card to a DM matrix bus
+		/// </summary>
+		/// <param name="isInternal">true for internal ports</param>
+		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingInputs parent, bool isInternal)
+			: base(key, type, connType, selector, isInternal)
+		{
+			if (parent == null)
+				throw new ArgumentNullException(nameof(parent));
+			ParentDevice = parent;
+		}
+
+        public override string ToString()
+        {
+            return $"{ParentDevice.Key}|{Key}|{Type}|{ConnectionType}";
+        }
+    }
+
+    /*/// <summary>
+    /// Basic RoutingInput with no statuses.
+    /// </summary>
+    public class RoutingInputPort<TSelector> : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// The IRoutingInputs object this lives on
+        /// </summary>
+        public IRoutingInputs<TSelector> ParentDevice { get; private set; }
+
+        /// <summary>
+        /// Constructor for a basic RoutingInputPort
+        /// </summary>
+        /// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+        /// May be string, number, whatever</param>
+        /// <param name="parent">The IRoutingInputs object this lives on</param>
+        public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingInputs<TSelector> parent)
+            : this(key, type, connType, selector, parent, false)
+        {
+        }
+
+        /// <summary>
+        /// Constructor for a virtual routing input port that lives inside a device. For example
+        /// the ports that link a DM card to a DM matrix bus
+        /// </summary>
+        /// <param name="isInternal">true for internal ports</param>
+        public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingInputs<TSelector> parent, bool isInternal)
+            : base(key, type, connType, selector, isInternal)
+        {
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingInputPortWithVideoStatuses.cs

@@ -0,0 +1,30 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// A RoutingInputPort for devices like DM-TX and DM input cards. 
+    /// Will provide video statistics on connected signals
+    /// </summary>
+    public class RoutingInputPortWithVideoStatuses : RoutingInputPort
+	{
+		/// <summary>
+		/// Video statuses attached to this port
+		/// </summary>
+		public VideoStatusOutputs VideoStatus { get; private set; }
+
+		/// <summary>
+		/// Constructor 
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingInputs object this lives on</param>
+		/// <param name="funcs">A VideoStatusFuncsWrapper used to assign the callback funcs that will get 
+		/// the values for the various stats</param>
+		public RoutingInputPortWithVideoStatuses(string key, 
+			eRoutingSignalType type, eRoutingPortConnectionType connType, object selector, 
+			IRoutingInputs parent, VideoStatusFuncsWrapper funcs) :
+			base(key, type, connType, selector, parent)
+		{
+			VideoStatus = new VideoStatusOutputs(funcs);		
+		}
+	}
+}

src/PepperDash.Essentials.Core/Routing/RoutingInterfaces.cs

@@ -1,203 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-
-
-namespace PepperDash.Essentials.Core
-{
-
-    /// <summary>
-    /// The handler type for a Room's SourceInfoChange
-    /// </summary>
-    public delegate void SourceInfoChangeHandler(/*EssentialsRoomBase room,*/ SourceListItem info, ChangeType type);
-
-
-	//*******************************************************************************************
-	// Interfaces
-
-    /// <summary>
-    /// For rooms with a single presentation source, change event
-    /// </summary>
-    public interface IHasCurrentSourceInfoChange
-    {
-        string CurrentSourceInfoKey { get; set; }
-        SourceListItem CurrentSourceInfo { get; set; }
-        event SourceInfoChangeHandler CurrentSourceChange;
-    }
-
-	/// <summary>
-	/// Defines a class that has a collection of RoutingInputPorts
-	/// </summary>
-	public interface IRoutingInputs : IKeyed
-	{
-		RoutingPortCollection<RoutingInputPort> InputPorts { get; }
-	}
-
-	/// <summary>
-	/// Defines a class that has a collection of RoutingOutputPorts
-	/// </summary>
-
-	public interface IRoutingOutputs : IKeyed
-	{
-		RoutingPortCollection<RoutingOutputPort> OutputPorts { get; }
-	}
-
-    /// <summary>
-    /// For fixed-source endpoint devices
-    /// </summary>
-    public interface IRoutingSink : IRoutingInputs, IHasCurrentSourceInfoChange
-    {
-
-    }
-
-	/// <summary>
-	/// Endpoint device like a display, that selects inputs
-	/// </summary>
-    public interface IRoutingSinkWithSwitching : IRoutingSink
-	{
-		//void ClearRoute();
-		void ExecuteSwitch(object inputSelector);
-	}
-
-	/// <summary>
-	/// For devices like RMCs, baluns, other devices with no switching.
-	/// </summary>
-	public interface IRoutingInputsOutputs : IRoutingInputs, IRoutingOutputs
-	{
-	}
-
-	/// <summary>
-	/// Defines a midpoint device as have internal routing.  Any devices in the middle of the
-	/// signal chain, that do switching, must implement this for routing to work otherwise
-	/// the routing algorithm will treat the IRoutingInputsOutputs device as a passthrough
-	/// device.
-	/// </summary>
-	public interface IRouting : IRoutingInputsOutputs
-	{
-		void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType);
-    }
-
-    public interface IRoutingWithClear : IRouting
-    {
-        /// <summary>
-        /// Clears a route to an output, however a device needs to do that
-        /// </summary>
-        /// <param name="outputSelector">Output to clear</param>
-        /// <param name="signalType">signal type to clear</param>
-        void ClearRoute(object outputSelector, eRoutingSignalType signalType);
-    }
-
-    public interface IRoutingNumeric : IRouting
-    {
-        void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type);
-    }
-
-    public interface ITxRouting : IRoutingNumeric
-    {
-        IntFeedback VideoSourceNumericFeedback { get; }
-        IntFeedback AudioSourceNumericFeedback { get; }
-    }
-
-    /// <summary>
-    /// Defines a receiver that has internal routing (DM-RMC-4K-Z-SCALER-C)
-    /// </summary>
-    public interface IRmcRouting : IRoutingNumeric
-    {
-        IntFeedback AudioVideoSourceNumericFeedback { get; }
-    }
-
-
-    /// <summary>
-    /// Defines an IRmcRouting with a feedback event 
-    /// </summary>
-    public interface ITxRoutingWithFeedback : ITxRouting
-    {
-    }
-
-    /// <summary>
-    /// Defines an IRmcRouting with a feedback event 
-    /// </summary>
-    public interface IRmcRoutingWithFeedback : IRmcRouting
-    {
-    }
-
-    /// <summary>
-	/// Defines an IRoutingOutputs devices as being a source - the start of the chain
-	/// </summary>
-	public interface IRoutingSource : IRoutingOutputs
-	{
-	}
-
-    /// <summary>
-    /// Defines an event structure for reporting output route data
-    /// </summary>
-    public interface IRoutingFeedback : IKeyName
-    {
-        event EventHandler<RoutingNumericEventArgs> NumericSwitchChange;
-        //void OnSwitchChange(RoutingNumericEventArgs e);
-    }
-
-    /// <summary>
-    /// Defines an IRoutingNumeric with a feedback event 
-    /// </summary>
-    public interface IRoutingNumericWithFeedback : IRoutingNumeric, IRoutingFeedback
-    {
-    }
-
-    /// <summary>
-    /// Defines an IRouting with a feedback event
-    /// </summary>
-    public interface IRoutingWithFeedback : IRouting, IRoutingFeedback
-    {
-        
-    }
-
-    public class RoutingNumericEventArgs : EventArgs
-    {
-
-        public uint? Output { get; set; }
-        public uint? Input { get; set; }
-
-        public eRoutingSignalType SigType { get; set; }
-        public RoutingInputPort InputPort { get; set; }
-        public RoutingOutputPort OutputPort { get; set; }
-
-        public RoutingNumericEventArgs(uint output, uint input, eRoutingSignalType sigType) : this(output, input, null, null, sigType)
-        {
-        }
-
-        public RoutingNumericEventArgs(RoutingOutputPort outputPort, RoutingInputPort inputPort,
-            eRoutingSignalType sigType)
-            : this(null, null, outputPort, inputPort, sigType)
-        {
-        }
-
-        public RoutingNumericEventArgs()
-            : this(null, null, null, null, 0)
-        {
- 
-        }
-
-        public RoutingNumericEventArgs(uint? output, uint? input, RoutingOutputPort outputPort,
-            RoutingInputPort inputPort, eRoutingSignalType sigType)
-        {
-            OutputPort = outputPort;
-            InputPort = inputPort;
-
-            Output = output;
-            Input = input;
-            SigType = sigType;
-        }
-    }
-
-	public interface IRoutingHasVideoInputSyncFeedbacks
-	{
-		FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; }
-	}	
-}

src/PepperDash.Essentials.Core/Routing/RoutingNumericEventArgs.cs

@@ -0,0 +1,43 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class RoutingNumericEventArgs : EventArgs
+    {
+
+        public uint? Output { get; set; }
+        public uint? Input { get; set; }
+
+        public eRoutingSignalType SigType { get; set; }
+        public RoutingInputPort InputPort { get; set; }
+        public RoutingOutputPort OutputPort { get; set; }
+
+        public RoutingNumericEventArgs(uint output, uint input, eRoutingSignalType sigType) : this(output, input, null, null, sigType)
+        {
+        }
+
+        public RoutingNumericEventArgs(RoutingOutputPort outputPort, RoutingInputPort inputPort,
+            eRoutingSignalType sigType)
+            : this(null, null, outputPort, inputPort, sigType)
+        {
+        }
+
+        public RoutingNumericEventArgs()
+            : this(null, null, null, null, 0)
+        {
+ 
+        }
+
+        public RoutingNumericEventArgs(uint? output, uint? input, RoutingOutputPort outputPort,
+            RoutingInputPort inputPort, eRoutingSignalType sigType)
+        {
+            OutputPort = outputPort;
+            InputPort = inputPort;
+
+            Output = output;
+            Input = input;
+            SigType = sigType;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RoutingOutputPort.cs

@@ -0,0 +1,75 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class RoutingOutputPort : RoutingPort
+	{
+		/// <summary>
+		/// The IRoutingOutputs object this port lives on
+		/// </summary>
+		public IRoutingOutputs ParentDevice { get; private set; }
+
+		public InUseTracking InUseTracker { get; private set; }
+
+
+		/// <summary>
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingOutputs object this port lives on</param>
+		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingOutputs parent)
+			: this(key, type, connType, selector, parent, false)
+		{
+		}
+
+		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingOutputs parent, bool isInternal)
+			: base(key, type, connType, selector, isInternal)
+		{
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+			InUseTracker = new InUseTracking();
+		}
+
+        public override string ToString()
+        {
+            return $"{ParentDevice.Key}|{Key}|{Type}|{ConnectionType}";
+        }
+	}
+
+    /*public class RoutingOutputPort<TSelector> : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// The IRoutingOutputs object this port lives on
+        /// </summary>
+        public IRoutingOutputs ParentDevice { get; private set; }
+
+        public InUseTracking InUseTracker { get; private set; }
+
+
+        /// <summary>
+        /// </summary>
+        /// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+        /// May be string, number, whatever</param>
+        /// <param name="parent">The IRoutingOutputs object this port lives on</param>
+        public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingOutputs parent)
+            : this(key, type, connType, selector, parent, false)
+        {
+        }
+
+        public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingOutputs parent, bool isInternal)
+            : base(key, type, connType, selector, isInternal)
+        {
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+            InUseTracker = new InUseTracking();
+        }
+
+        public override string ToString()
+        {
+            return ParentDevice.Key + ":" + Key;
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingPort.cs

@@ -1,15 +1,12 @@
-using System;
-using System.Collections.Generic;
-
-using PepperDash.Core;
+using PepperDash.Core;
 
 
 namespace PepperDash.Essentials.Core
 {
-	/// <summary>
-	/// Base class for RoutingInput and Output ports
-	/// </summary>
-	public abstract class RoutingPort : IKeyed
+    /// <summary>
+    /// Base class for RoutingInput and Output ports
+    /// </summary>
+    public abstract class RoutingPort : IKeyed
 	{
 		public string Key { get; private set; }
 		public eRoutingSignalType Type { get; private set; }
@@ -26,183 +23,26 @@ namespace PepperDash.Essentials.Core
 			ConnectionType = connType;
 			Selector = selector;
 			IsInternal = isInternal;
-		}
-	}
+		}        
+    }
 
-    [Flags]
-	public enum eRoutingSignalType
-	{
-		Audio = 1,
-		Video = 2,     
-		AudioVideo = Audio | Video,
-        UsbOutput = 8,
-        UsbInput = 16,
-        SecondaryAudio = 32
-	}
+    /*public abstract class RoutingPort<TSelector>:IKeyed
+    {
+        public string Key { get; private set; }
+        public eRoutingSignalType Type { get; private set; }
+        public eRoutingPortConnectionType ConnectionType { get; private set; }
+        public readonly TSelector Selector;
+        public bool IsInternal { get; private set; }
+        public object FeedbackMatchObject { get; set; }
+        public object Port { get; set; }
 
-	public enum eRoutingPortConnectionType
-	{
-		None, BackplaneOnly, DisplayPort, Dvi, Hdmi, Rgb, Vga, LineAudio, DigitalAudio, Sdi, 
-		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
-	}
-
-	/// <summary>
-	/// Basic RoutingInput with no statuses.
-	/// </summary>
-	public class RoutingInputPort : RoutingPort
-	{
-		/// <summary>
-		/// The IRoutingInputs object this lives on
-		/// </summary>
-		public IRoutingInputs ParentDevice { get; private set; }
-
-		/// <summary>
-		/// Constructor for a basic RoutingInputPort
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingInputs object this lives on</param>
-		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingInputs parent)
-			: this (key, type, connType, selector, parent, false)
-		{
-		}
-
-		/// <summary>
-		/// Constructor for a virtual routing input port that lives inside a device. For example
-		/// the ports that link a DM card to a DM matrix bus
-		/// </summary>
-		/// <param name="isInternal">true for internal ports</param>
-		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingInputs parent, bool isInternal)
-			: base(key, type, connType, selector, isInternal)
-		{
-			if (parent == null)
-				throw new ArgumentNullException("parent");
-			ParentDevice = parent;
-		}
-
-
-
-
-		///// <summary>
-		///// Static method to get a named port from a named device
-		///// </summary>
-		///// <returns>Returns null if device or port doesn't exist</returns>
-		//public static RoutingInputPort GetDevicePort(string deviceKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as IRoutingInputs;
-		//    if (sourceDev == null)
-		//        return null;
-		//    return sourceDev.InputPorts[portKey];
-		//}
-
-		///// <summary>
-		///// Static method to get a named port from a card in a named ICardPortsDevice device
-		///// Uses ICardPortsDevice.GetChildInputPort 
-		///// </summary>
-		///// <param name="cardKey">'input-N'</param>
-		///// <returns>null if device, card or port doesn't exist</returns>
-		//public static RoutingInputPort GetDeviceCardPort(string deviceKey, string cardKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as ICardPortsDevice;
-		//    if (sourceDev == null)
-		//        return null;
-		//    return sourceDev.GetChildInputPort(cardKey, portKey);
-		//}
-	}
-
-	/// <summary>
-	/// A RoutingInputPort for devices like DM-TX and DM input cards. 
-	/// Will provide video statistics on connected signals
-	/// </summary>
-	public class RoutingInputPortWithVideoStatuses : RoutingInputPort
-	{
-		/// <summary>
-		/// Video statuses attached to this port
-		/// </summary>
-		public VideoStatusOutputs VideoStatus { get; private set; }
-
-		/// <summary>
-		/// Constructor 
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingInputs object this lives on</param>
-		/// <param name="funcs">A VideoStatusFuncsWrapper used to assign the callback funcs that will get 
-		/// the values for the various stats</param>
-		public RoutingInputPortWithVideoStatuses(string key, 
-			eRoutingSignalType type, eRoutingPortConnectionType connType, object selector, 
-			IRoutingInputs parent, VideoStatusFuncsWrapper funcs) :
-			base(key, type, connType, selector, parent)
-		{
-			VideoStatus = new VideoStatusOutputs(funcs);		
-		}
-	}
-
-	public class RoutingOutputPort : RoutingPort
-	{
-		/// <summary>
-		/// The IRoutingOutputs object this port lives on
-		/// </summary>
-		public IRoutingOutputs ParentDevice { get; private set; }
-
-		public InUseTracking InUseTracker { get; private set; }
-
-
-		/// <summary>
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingOutputs object this port lives on</param>
-		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingOutputs parent)
-			: this(key, type, connType, selector, parent, false)
-		{
-		}
-
-		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingOutputs parent, bool isInternal)
-			: base(key, type, connType, selector, isInternal)
-		{
-			if (parent == null)
-				throw new ArgumentNullException("parent");
-			ParentDevice = parent;
-			InUseTracker = new InUseTracking();
-		}
-
-		public override string ToString()
-		{
-			return ParentDevice.Key + ":" + Key;
-		}
-
-		///// <summary>
-		///// Static method to get a named port from a named device
-		///// </summary>
-		///// <returns>Returns null if device or port doesn't exist</returns>
-		//public static RoutingOutputPort GetDevicePort(string deviceKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as IRoutingOutputs;
-		//    if (sourceDev == null)
-		//        return null;
-		//    var port = sourceDev.OutputPorts[portKey];
-		//    if (port == null)
-		//        Debug.LogMessage(LogEventLevel.Information, "WARNING: Device '{0}' does does not contain output port '{1}'", deviceKey, portKey);
-		//    return port;
-		//}
-
-		///// <summary>
-		///// Static method to get a named port from a card in a named ICardPortsDevice device
-		///// Uses ICardPortsDevice.GetChildOutputPort on that device
-		///// </summary>
-		///// <param name="cardKey">'input-N' or 'output-N'</param>
-		///// <returns>null if device, card or port doesn't exist</returns>
-		//public static RoutingOutputPort GetDeviceCardPort(string deviceKey, string cardKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as ICardPortsDevice;
-		//    if (sourceDev == null)
-		//        return null;
-		//    var port = sourceDev.GetChildOutputPort(cardKey, portKey);
-		//}
-	}
+        public RoutingPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType, TSelector selector, bool isInternal)
+        {
+            Key = key;
+            Type = type;
+            ConnectionType = connType;
+            Selector = selector;
+            IsInternal = isInternal;
+        }
+    }*/
 }

src/PepperDash.Essentials.Core/Routing/RoutingPortCollection.cs

@@ -23,4 +23,21 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 	}
+
+/*    /// <summary>
+	/// Basically a List , with an indexer to find ports by key name
+	/// </summary>
+	public class RoutingPortCollection<T, TSelector> : List<T> where T : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// Case-insensitive port lookup linked to ports' keys
+        /// </summary>
+        public T this[string key]
+        {
+            get
+            {
+                return this.FirstOrDefault(i => i.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+    }*/
 }

src/PepperDash.Essentials.Core/Routing/RoutingPortNames.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 
-namespace PepperDash.Essentials.Core.Routing
+namespace PepperDash.Essentials.Core
 {
 	/// <summary>
 	/// These should correspond directly with the portNames var in the config tool.
@@ -239,5 +239,13 @@ namespace PepperDash.Essentials.Core.Routing
         /// HdBaseTOut
         /// </summary>
         public const string HdBaseTOut = "hdBaseTOut";
+        /// <summary>
+        /// SdiIn
+        /// </summary>
+        public const string SdiIn = "sdiIn";
+        /// <summary>
+        /// SdiOut
+        /// </summary>
+        public const string SdiOut = "sdiOut";
     }
 }

src/PepperDash.Essentials.Core/Routing/TieLine.cs

@@ -1,111 +1,107 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core
 {
-	public class TieLine
-	{
-		public RoutingOutputPort SourcePort { get; private set; }
-		public RoutingInputPort DestinationPort { get; private set; }
-		//public int InUseCount { get { return DestinationUsingThis.Count; } }
+    public class TieLine
+    {
+        public RoutingOutputPort SourcePort { get; private set; }
+        public RoutingInputPort DestinationPort { get; private set; }
+        //public int InUseCount { get { return DestinationUsingThis.Count; } }
 
-		/// <summary>
-		/// Gets the type of this tie line.  Will either be the type of the desination port
-		/// or the type of OverrideType when it is set.
-		/// </summary>
-		public eRoutingSignalType Type
-		{
-			get
-			{
-				if (OverrideType.HasValue) return OverrideType.Value;
-				return DestinationPort.Type;
-			}
-		}
+        /// <summary>
+        /// Gets the type of this tie line.  Will either be the type of the desination port
+        /// or the type of OverrideType when it is set.
+        /// </summary>
+        public eRoutingSignalType Type
+        {
+            get
+            {
+                if (OverrideType.HasValue) return OverrideType.Value;
+                return DestinationPort.Type;
+            }
+        }
 
-		/// <summary>
-		/// Use this to override the Type property for the destination port. For example,
-		/// when the tie line is type AudioVideo, and the signal flow should be limited to
-		/// Audio-only or Video only, changing this type will alter the signal paths
-		/// available to the routing algorithm without affecting the actual Type
-		/// of the destination port.
-		/// </summary>
-		public eRoutingSignalType? OverrideType { get; set; }
+        /// <summary>
+        /// Use this to override the Type property for the destination port. For example,
+        /// when the tie line is type AudioVideo, and the signal flow should be limited to
+        /// Audio-only or Video only, changing this type will alter the signal paths
+        /// available to the routing algorithm without affecting the actual Type
+        /// of the destination port.
+        /// </summary>
+        public eRoutingSignalType? OverrideType { get; set; }
 
-		//List<IRoutingInputs> DestinationUsingThis = new List<IRoutingInputs>();
+        //List<IRoutingInputs> DestinationUsingThis = new List<IRoutingInputs>();
 
-		/// <summary>
-		/// For tie lines that represent internal links, like from cards to the matrix in a DM.
-		/// This property is true if SourcePort and DestinationPort IsInternal
-		/// property are both true
-		/// </summary>
-		public bool IsInternal { get { return SourcePort.IsInternal && DestinationPort.IsInternal; } }
-		public bool TypeMismatch { get { return SourcePort.Type != DestinationPort.Type; } }
-		public bool ConnectionTypeMismatch { get { return SourcePort.ConnectionType != DestinationPort.ConnectionType; } }
-		public string TypeMismatchNote { get; set; }
+        /// <summary>
+        /// For tie lines that represent internal links, like from cards to the matrix in a DM.
+        /// This property is true if SourcePort and DestinationPort IsInternal
+        /// property are both true
+        /// </summary>
+        public bool IsInternal { get { return SourcePort.IsInternal && DestinationPort.IsInternal; } }
+        public bool TypeMismatch { get { return SourcePort.Type != DestinationPort.Type; } }
+        public bool ConnectionTypeMismatch { get { return SourcePort.ConnectionType != DestinationPort.ConnectionType; } }
+        public string TypeMismatchNote { get; set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="sourcePort"></param>
-		/// <param name="destinationPort"></param>
-		public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort)
-		{
-			if (sourcePort == null || destinationPort == null)
-				throw new ArgumentNullException("source or destination port");
-			SourcePort = sourcePort;
-			DestinationPort = destinationPort;
-		}
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sourcePort"></param>
+        /// <param name="destinationPort"></param>
+        public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort)
+        {
+            if (sourcePort == null || destinationPort == null)
+                throw new ArgumentNullException("source or destination port");
+            SourcePort = sourcePort;
+            DestinationPort = destinationPort;
+        }
 
-		/// <summary>
-		/// Creates a tie line with an overriding Type.  See help for OverrideType property for info
-		/// </summary>
-		/// <param name="overrideType">The signal type to limit the link to. Overrides DestinationPort.Type</param>
-		public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort, eRoutingSignalType overrideType) :
-			this(sourcePort, destinationPort)
-		{
-			OverrideType = overrideType;
-		}
+        /// <summary>
+        /// Creates a tie line with an overriding Type.  See help for OverrideType property for info
+        /// </summary>
+        /// <param name="overrideType">The signal type to limit the link to. Overrides DestinationPort.Type</param>
+        public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort, eRoutingSignalType overrideType) :
+            this(sourcePort, destinationPort)
+        {
+            OverrideType = overrideType;
+        }
 
-		/// <summary>
-		/// Will link up video status from supporting inputs to connected outputs
-		/// </summary>
-		public void Activate()
-		{
-			// Now does nothing
-		}
+        /// <summary>
+        /// Will link up video status from supporting inputs to connected outputs
+        /// </summary>
+        public void Activate()
+        {
+            // Now does nothing
+        }
 
-		public void Deactivate()
-		{
-			// Now does nothing
-		}
+        public void Deactivate()
+        {
+            // Now does nothing
+        }
 
-		public override string ToString()
-		{
-			return string.Format("Tie line: [{0}]{1} --> [{2}]{3}", SourcePort.ParentDevice.Key, SourcePort.Key,
-				DestinationPort.ParentDevice.Key, DestinationPort.Key);
-		}
-	}
+        public override string ToString()
+        {
+            return string.Format("Tie line: {0}:{1} --> {2}:{3} {4}", SourcePort.ParentDevice.Key, SourcePort.Key,
+                DestinationPort.ParentDevice.Key, DestinationPort.Key, Type.ToString());
+        }
+    }
 
-	//********************************************************************************
+    //********************************************************************************
 
-	public class TieLineCollection : List<TieLine>
-	{
-		public static TieLineCollection Default
-		{
-			get
-			{
-				if (_Default == null)
-					_Default = new TieLineCollection();
-				return _Default;
-			}
-		}
-		static TieLineCollection _Default;
-	}
+    public class TieLineCollection : List<TieLine>
+    {
+        public static TieLineCollection Default
+        {
+            get
+            {
+                if (_Default == null)
+                    _Default = new TieLineCollection();
+                return _Default;
+            }
+        }
+
+        [JsonIgnore]
+        private static TieLineCollection _Default;
+    }
 }

src/PepperDash.Essentials.Core/Routing/TieLineConfig.cs

@@ -30,7 +30,7 @@ namespace PepperDash.Essentials.Core.Config
 		/// <returns>null if config data does not match ports, cards or devices</returns>
 		public TieLine GetTieLine()
 		{
-			Debug.LogMessage(LogEventLevel.Information, "Build TieLine: {0}", this);
+			Debug.LogMessage(LogEventLevel.Information, "Build TieLine: {0}",null, this);
 			// Get the source device
 			var sourceDev = DeviceManager.GetDeviceForKey(SourceKey) as IRoutingOutputs;
 			if (sourceDev == null)
@@ -48,68 +48,29 @@ namespace PepperDash.Essentials.Core.Config
 			}
 
             //Get the source port
-            RoutingOutputPort sourceOutputPort = null;
-            //// If it's a card-based device, get the card and then the source port
-            //if (sourceDev is ICardPortsDevice)
-            //{
-            //    if (SourceCard == null)
-            //    {
-            //        LogError("Card missing from source device config");
-            //        return null;
-            //    }
-            //    sourceOutputPort = (sourceDev as ICardPortsDevice).GetChildOutputPort(SourceCard, SourcePort);
-            //    if (sourceOutputPort == null)
-            //    {
-            //        LogError("Source card does not contain port");
-            //        return null;
-            //    }
-            //}
-            //// otherwise it's a normal port device, get the source port
-            //else
-            //{
-				sourceOutputPort = sourceDev.OutputPorts[SourcePort];
-				if (sourceOutputPort == null)
-				{
-					LogError("Source does not contain port");
-					return null;
-				}
-            //}
+            var sourceOutputPort = sourceDev.OutputPorts[SourcePort];
 
+            if (sourceOutputPort == null)
+			{
+				LogError("Source does not contain port");
+				return null;
+			}
 
-			//Get the Destination port
-			RoutingInputPort destinationInputPort = null;
-            //// If it's a card-based device, get the card and then the Destination port
-            //if (destDev is ICardPortsDevice)
-            //{
-            //    if (DestinationCard == null)
-            //    {
-            //        LogError("Card missing from destination device config");
-            //        return null;
-            //    }
-            //    destinationInputPort = (destDev as ICardPortsDevice).GetChildInputPort(DestinationCard, DestinationPort);
-            //    if (destinationInputPort == null)
-            //    {
-            //        LogError("Destination card does not contain port");
-            //        return null;
-            //    }
-            //}
-            //// otherwise it's a normal port device, get the Destination port
-            //else
-            //{
-				destinationInputPort = destDev.InputPorts[DestinationPort];
-				if (destinationInputPort == null)
+            //Get the Destination port
+            var destinationInputPort = destDev.InputPorts[DestinationPort];
+
+            if (destinationInputPort == null)
 				{
 					LogError("Destination does not contain port");
 					return null;
-				}
-            //}
+				}            
 
 			return new TieLine(sourceOutputPort, destinationInputPort);
 		}
 
 		void LogError(string msg)
 		{
-			Debug.LogMessage(LogEventLevel.Debug, "WARNING: Cannot create tie line: {0}:\r   {1}", msg, this);
+			Debug.LogMessage(LogEventLevel.Error, "WARNING: Cannot create tie line: {message}:\r   {tieLineConfig}",null, msg, this);
 		}
 
 		public override string ToString()

src/PepperDash.Essentials.Core/Routing/eRoutingPortConnectionType.cs

@@ -0,0 +1,8 @@
+namespace PepperDash.Essentials.Core
+{
+    public enum eRoutingPortConnectionType
+	{
+		None, BackplaneOnly, DisplayPort, Dvi, Hdmi, Rgb, Vga, LineAudio, DigitalAudio, Sdi, 
+		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
+	}
+}

src/PepperDash.Essentials.Core/Routing/eRoutingSignalType.cs

@@ -0,0 +1,16 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    [Flags]
+	public enum eRoutingSignalType
+	{
+		Audio = 1,
+		Video = 2,     
+		AudioVideo = Audio | Video,
+        UsbOutput = 8,
+        UsbInput = 16,
+        SecondaryAudio = 32
+	}
+}

src/PepperDash.Essentials.Core/Touchpanels/CrestronTouchpanelPropertiesConfig.cs

@@ -1,38 +1,74 @@
-namespace PepperDash.Essentials.Core
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core
 {
     public class CrestronTouchpanelPropertiesConfig
     {
+        [JsonProperty("control")]
+        public EssentialsControlPropertiesConfig ControlProperties { get; set; }
+
+        [JsonProperty("ipId", NullValueHandling = NullValueHandling.Ignore)]
         public string IpId { get; set; }
+
+        [JsonProperty("defaultRoomKey", NullValueHandling = NullValueHandling.Ignore)]
         public string DefaultRoomKey { get; set; }
+        
+        [JsonProperty("roomListKey", NullValueHandling = NullValueHandling.Ignore)]
         public string RoomListKey { get; set; }
+
+        [JsonProperty("sgdFile", NullValueHandling = NullValueHandling.Ignore)]
         public string SgdFile { get; set; }
+
+        [JsonProperty("projectName", NullValueHandling = NullValueHandling.Ignore)]
         public string ProjectName { get; set; }
-        public bool ShowVolumeGauge { get; set; }
-        public bool UsesSplashPage { get; set; }
-        public bool ShowDate { get; set; }
-        public bool ShowTime { get; set; }
+
+        [JsonProperty("showVolumeGauge", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowVolumeGauge { get; set; }
+
+        [JsonProperty("usesSplashPage", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? UsesSplashPage { get; set; }
+
+        [JsonProperty("showDate", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowDate { get; set; }
+
+        [JsonProperty("showTime", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowTime { get; set; }
+
+        [JsonProperty("setup", NullValueHandling = NullValueHandling.Ignore)]
         public UiSetupPropertiesConfig Setup { get; set; }
+
+        [JsonProperty("headerStyle", NullValueHandling = NullValueHandling.Ignore)]
         public string HeaderStyle { get; set; }
-        public bool IncludeInFusionRoomHealth { get; set; }
-        public uint ScreenSaverTimeoutMin { get; set; }
-        public uint ScreenSaverMovePositionIntervalMs { get; set; }
+
+        [JsonProperty("includeInFusionRoomHealth", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? IncludeInFusionRoomHealth { get; set; }
+
+        [JsonProperty("screenSaverTimeoutMin", NullValueHandling = NullValueHandling.Ignore)]
+        public uint? ScreenSaverTimeoutMin { get; set; }
+
+        [JsonProperty("screenSaverMovePositionIntervalMs", NullValueHandling = NullValueHandling.Ignore)]
+        public uint? ScreenSaverMovePositionIntervalMs { get; set; }
 
 
         /// <summary>
         /// The count of sources that will trigger the "additional" arrows to show on the SRL.
         /// Defaults to 5
         /// </summary>
-        public int SourcesOverflowCount { get; set; }
+        [JsonProperty("sourcesOverflowCount", NullValueHandling = NullValueHandling.Ignore)]
+        public int? SourcesOverflowCount { get; set; }
 
-        public CrestronTouchpanelPropertiesConfig()
+        public CrestronTouchpanelPropertiesConfig() : this(false) { }        
+
+        public CrestronTouchpanelPropertiesConfig(bool setDefaultValues = false)
         {
+            if(!setDefaultValues) { return; }
             SourcesOverflowCount = 5;
-            HeaderStyle = CrestronTouchpanelPropertiesConfig.Habanero;
+            HeaderStyle = Habanero;
 
             // Default values
             ScreenSaverTimeoutMin = 5;
             ScreenSaverMovePositionIntervalMs = 15000;
-        }
+        }        
 
         /// <summary>
         /// "habanero"
@@ -49,6 +85,7 @@
     /// </summary>
     public class UiSetupPropertiesConfig
     {
+        [JsonProperty("isVisible", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsVisible { get; set; }
     }
 }

src/PepperDash.Essentials.Core/Web/EssentialsWebApi.cs

@@ -89,7 +89,7 @@ namespace PepperDash.Essentials.Core.Web
                     Name = "DevList",
                     RouteHandler = new DevListRequestHandler()
                 },
-                new HttpCwsRoute("deviceCommands")
+                new HttpCwsRoute("deviceCommands/{deviceKey}")
                 {
                     Name = "DevJson",
                     RouteHandler = new DevJsonRequestHandler()
@@ -163,6 +163,11 @@ namespace PepperDash.Essentials.Core.Web
                 {
                     Name = "Load Config",
                     RouteHandler = new LoadConfigRequestHandler()
+                },
+                new HttpCwsRoute("getTielines")
+                {
+                    Name = "Get TieLines",
+                    RouteHandler = new GetTieLinesRequestHandler()
                 }
 
             };
@@ -233,32 +238,32 @@ namespace PepperDash.Essentials.Core.Web
 		/// </example>
 		public void GetPaths()
 		{
-			Debug.LogMessage(LogEventLevel.Verbose, this, "{0}", new String('-', 50));
+			Debug.LogMessage(LogEventLevel.Information, this, new string('-', 50));
 
 			var currentIp = CrestronEthernetHelper.GetEthernetParameter(
 				CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0);
 			
 			var hostname = CrestronEthernetHelper.GetEthernetParameter(
                     CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_HOSTNAME, 0);
+
+            var path = CrestronEnvironment.DevicePlatform == eDevicePlatform.Server
+                ? $"http(s)://{hostname}/VirtualControl/Rooms/{InitialParametersClass.RoomId}/cws{BasePath}"
+                : $"http(s)://{currentIp}/cws{BasePath}";
 			
-			var path = CrestronEnvironment.DevicePlatform == eDevicePlatform.Server 
-				? string.Format("http(s)://{0}/VirtualControl/Rooms/{1}/cws{2}", hostname, InitialParametersClass.RoomId, BasePath)
-				: string.Format("http(s)://{0}/cws{1}", currentIp, BasePath);
-			
-			Debug.LogMessage(LogEventLevel.Verbose, this, "Server:{0}", path);
+			Debug.LogMessage(LogEventLevel.Information, this, "Server:{path:l}", path);
 
 			var routeCollection = _server.GetRouteCollection();
 			if (routeCollection == null)
 			{
-				Debug.LogMessage(LogEventLevel.Verbose, this, "Server route collection is null");
+				Debug.LogMessage(LogEventLevel.Information, this, "Server route collection is null");
 				return;
 			}
-			Debug.LogMessage(LogEventLevel.Verbose, this, "Configured Routes:");
+			Debug.LogMessage(LogEventLevel.Information, this, "Configured Routes:");
 			foreach (var route in routeCollection)
 			{
-				Debug.LogMessage(LogEventLevel.Verbose, this, "{0}: {1}/{2}", route.Name, path, route.Url);
+				Debug.LogMessage(LogEventLevel.Information, this, "{routeName:l}: {routePath:l}/{routeUrl:l}", route.Name, path, route.Url);
 			}
-			Debug.LogMessage(LogEventLevel.Verbose, this, "{0}", new String('-', 50));
+			Debug.LogMessage(LogEventLevel.Information, this, new string('-', 50));
 		}
 	}
 }

src/PepperDash.Essentials.Core/Web/EssentialsWebApiHelpers.cs

@@ -7,11 +7,11 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Web
 {
-	public class EssentialsWebApiHelpers
+	public static class EssentialsWebApiHelpers
 	{
-		public static string GetRequestBody(HttpCwsRequest request)
+		public static string GetRequestBody(this HttpCwsRequest request)
 		{
-			var bytes = new Byte[request.ContentLength];
+			var bytes = new byte[request.ContentLength];
 
 			request.InputStream.Read(bytes, 0, request.ContentLength);
 
@@ -22,8 +22,8 @@ namespace PepperDash.Essentials.Core.Web
 		{
 			return new
 			{
-				Name = assembly.Name,
-				Version = assembly.Version
+                assembly.Name,
+                assembly.Version
 			};
 		}
 
@@ -31,7 +31,7 @@ namespace PepperDash.Essentials.Core.Web
 		{
 			return new
 			{
-				Key = device.Key,
+                device.Key,
 				Name = (device is IKeyName)
 					? (device as IKeyName).Name
 					: "---"
@@ -80,7 +80,7 @@ namespace PepperDash.Essentials.Core.Web
 			{
 				Type = device.Key,
 				Description = device.Value.Description,
-				CType = device.Value.CType == null ? "---": device.Value.CType.ToString()
+				CType = device.Value.Type == null ? "---": device.Value.Type.ToString()
 			};
 		}
 	}

src/PepperDash.Essentials.Core/Web/RequestHandlers/AppDebugRequestHandler.cs

@@ -52,7 +52,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevJsonRequestHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Core.Web.RequestHandlers;
 using Serilog.Events;
@@ -25,28 +26,55 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 		/// <param name="context"></param>
 		protected override void HandlePost(HttpCwsContext context)
 		{
+            var routeData = context.Request.RouteData;
+
+            if(routeData == null)
+            {
+                context.Response.StatusCode = 400;
+                context.Response.StatusDescription = "Bad Request";
+                context.Response.End();
+
+                return;
+            }
+
+            if(!routeData.Values.TryGetValue("deviceKey", out var deviceKey))
+            {
+                context.Response.StatusCode = 400;
+                context.Response.StatusDescription = "Bad Request";
+                context.Response.End();
+
+                return;
+            }
+
 			if (context.Request.ContentLength < 0)
 			{
 				context.Response.StatusCode = 400;
-				context.Response.StatusDescription = "Bad Request";
+				context.Response.StatusDescription = "Bad Request: no body";
 				context.Response.End();
 
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
+
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;
-				context.Response.StatusDescription = "Bad Request";
+				context.Response.StatusDescription = "Bad Request: no body";
 				context.Response.End();
 
 				return;
 			}
 			
 			try
-			{
-				DeviceJsonApi.DoDeviceActionWithJson(data);
+			{                
+                var daw = new DeviceActionWrapper { DeviceKey = (string) deviceKey};
+
+                JsonConvert.PopulateObject(data, daw);
+
+                Debug.LogMessage(LogEventLevel.Verbose, "Device Action Wrapper: {@wrapper}", null, daw);
+
+				DeviceJsonApi.DoDeviceAction(daw);
 
 				context.Response.StatusCode = 200;
 				context.Response.StatusDescription = "OK";
@@ -54,12 +82,11 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 			}
 			catch (Exception ex)
 			{
-				Debug.LogMessage(LogEventLevel.Error, "Exception Message: {0}", ex.Message);
-				Debug.LogMessage(LogEventLevel.Verbose, "Exception Stack Trace: {0}", ex.StackTrace);
-				if(ex.InnerException != null) Debug.LogMessage(LogEventLevel.Error, "Exception Inner: {0}", ex.InnerException);
+				Debug.LogMessage(ex, "Error handling device command: {Exception}");				
 
 				context.Response.StatusCode = 400;
 				context.Response.StatusDescription = "Bad Request";
+                context.Response.Write(JsonConvert.SerializeObject(new { error = ex.Message }), false);
 				context.Response.End();
 			}
 		}

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevListRequestHandler.cs

@@ -34,7 +34,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			allDevices.Sort((a, b) => System.String.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
+			allDevices.Sort((a, b) => string.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
 
 			var deviceList = allDevices.Select(d => EssentialsWebApiHelpers.MapToDeviceListObject(d)).ToList();
 

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevMethodsRequestHandler.cs

@@ -1,6 +1,7 @@
 using System.Text;
 using Crestron.SimplSharp.WebScripting;
 using Newtonsoft.Json;
+using PepperDash.Core;
 using PepperDash.Core.Web.RequestHandlers;
 
 namespace PepperDash.Essentials.Core.Web.RequestHandlers
@@ -25,6 +26,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 		protected override void HandleGet(HttpCwsContext context)
 		{
             var routeData = context.Request.RouteData;
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Debug, "Getting DevMethods: {@routeData}", routeData);
             if (routeData == null)
             {
                 context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/DoNotLoadConfigOnNextBootRequestHandler.cs

@@ -52,7 +52,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/GetTieLinesRequestHandler.cs

@@ -0,0 +1,33 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using System.Linq;
+using System.Text;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+    public class GetTieLinesRequestHandler : WebApiBaseRequestHandler
+    {
+        public GetTieLinesRequestHandler() : base(true) { }
+
+        protected override void HandleGet(HttpCwsContext context)
+        {
+            var tieLineString = JsonConvert.SerializeObject(TieLineCollection.Default.Select((tl) => new
+            {
+                sourceKey = tl.SourcePort.ParentDevice.Key,
+                sourcePort = tl.SourcePort.Key,
+                destinationKey = tl.DestinationPort.ParentDevice.Key,
+                destinationPort = tl.DestinationPort.Key,
+                type = tl.Type.ToString(),
+            }));
+
+            context.Response.StatusCode = 200;
+            context.Response.StatusDescription = "OK";
+            context.Response.ContentType = "application/json";
+            context.Response.ContentEncoding = Encoding.UTF8;
+            context.Response.Write(tieLineString, false);
+            context.Response.End();
+
+        }
+    }
+}

src/PepperDash.Essentials.Core/Web/RequestHandlers/SetDeviceStreamDebugRequestHandler.cs

@@ -89,7 +89,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (data == null)
 			{
 				context.Response.StatusCode = 500;

src/PepperDash.Essentials.Devices.Common/Audio/GenericAudioOut.cs

@@ -8,7 +8,6 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Devices.Common
@@ -18,6 +17,8 @@ namespace PepperDash.Essentials.Devices.Common
 	/// </summary>
 	public class GenericAudioOut : EssentialsDevice, IRoutingSink
 	{
+        public RoutingInputPort CurrentInputPort => AnyAudioIn;
+
         public event SourceInfoChangeHandler CurrentSourceChange;
 
         public string CurrentSourceInfoKey { get; set; }

src/PepperDash.Essentials.Devices.Common/Cameras/CameraBase.cs

@@ -6,7 +6,7 @@ using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;

src/PepperDash.Essentials.Devices.Common/Cameras/CameraVisca.cs

@@ -12,7 +12,7 @@ using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Devices.Common.Codec;
 using System.Text.RegularExpressions;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 
 using Newtonsoft.Json;
 using Serilog.Events;

src/PepperDash.Essentials.Devices.Common/Codec/ICiscoCodecCameraConfig.cs

@@ -0,0 +1,31 @@
+using Crestron.SimplSharpPro;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Codec
+{ 
+    /// <summary>
+    /// Describes a cisco codec device that can allow configuration of cameras
+    /// </summary>
+    public interface ICiscoCodecCameraConfig
+    {
+        void SetCameraAssignedSerialNumber(uint cameraId, string serialNumber);
+
+        void SetCameraName(uint videoConnectorId, string name);
+
+        void SetInputSourceType(uint videoConnectorId, eCiscoCodecInputSourceType sourceType);
+    }
+
+    public enum eCiscoCodecInputSourceType
+    {
+        PC,
+        camera,
+        document_camera,
+        mediaplayer,
+        other,
+        whiteboard
+    }
+}

src/PepperDash.Essentials.Devices.Common/DeviceFactory.cs

@@ -2,7 +2,7 @@
 
 using System;
 using System.Linq;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using Serilog.Events;
@@ -25,7 +25,7 @@ namespace PepperDash.Essentials.Devices.Common
                 {
                     try
                     {
-                        var factory = (IDeviceFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                        var factory = (IDeviceFactory)Activator.CreateInstance(type);
                         factory.LoadTypeFactories();
                     }
                     catch (Exception e)

src/PepperDash.Essentials.Devices.Common/Displays/BasicIrDisplay.cs

@@ -7,7 +7,6 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Devices.Common.Displays

src/PepperDash.Essentials.Devices.Common/Displays/DisplayBase.cs

@@ -1,15 +1,14 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
+using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
-using Feedback = PepperDash.Essentials.Core.Feedback;
-using Newtonsoft.Json;
-using PepperDash.Essentials.Core.DeviceTypeInterfaces;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Feedback = PepperDash.Essentials.Core.Feedback;
 
 namespace PepperDash.Essentials.Devices.Common.Displays
 {
@@ -20,6 +19,26 @@ namespace PepperDash.Essentials.Devices.Common.Displays
         , IWarmingCooling
         , IUsageTracking
 	{
+        private RoutingInputPort _currentInputPort;
+        public RoutingInputPort CurrentInputPort
+        {
+            get
+            {
+                return _currentInputPort;
+            }
+
+            protected set
+            {
+                if (_currentInputPort == value) return;
+
+                _currentInputPort = value;
+
+                InputChanged?.Invoke(this, _currentInputPort);
+            }
+        }
+
+        public event InputChangedEventHandler InputChanged;
+
         public event SourceInfoChangeHandler CurrentSourceChange;
 
         public string CurrentSourceInfoKey { get; set; }

src/PepperDash.Essentials.Devices.Common/Displays/MockDisplay.cs

@@ -8,12 +8,11 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.DeviceTypeInterfaces;
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Devices.Common.Displays
 {
-    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced, IHasInputs<string, string>
+    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced, IHasInputs<string, string>, IRoutingSinkWithSwitchingWithInputPort, IHasPowerControlWithFeedback
 	{
         public ISelectableItems<string> Inputs { get; private set; }
 
@@ -80,7 +79,7 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 				eRoutingPortConnectionType.Hdmi, "HDMI2", this);
 			var hdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
 				eRoutingPortConnectionType.Hdmi, "HDMI3", this);
-			var hdmiIn4 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.AudioVideo,
+			var hdmiIn4 = new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo,
 				eRoutingPortConnectionType.Hdmi, "HDMI4", this);
 			var dpIn = new RoutingInputPort(RoutingPortNames.DisplayPortIn, eRoutingSignalType.AudioVideo,
 				eRoutingPortConnectionType.DisplayPort, "DP", this);
@@ -140,18 +139,65 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 
 		public override void ExecuteSwitch(object selector)
 		{
-			Debug.LogMessage(LogEventLevel.Verbose, this, "ExecuteSwitch: {0}", selector);
+            try
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "ExecuteSwitch: {0}", this, selector);
 
 			if (!_PowerIsOn)
 			{
 				PowerOn();
 			}
 
-			if (!Inputs.Items.TryGetValue(selector.ToString(), out var input))
-				return;
+                if (!Inputs.Items.TryGetValue(selector.ToString(), out var input))
+                    return;
 
-			input.Select();
-		}
+                Debug.LogMessage(LogEventLevel.Verbose, "Selected input: {input}", this, input.Key);
+                input.Select();
+
+                var inputPort = InputPorts.FirstOrDefault(port =>
+                {
+                    Debug.LogMessage(LogEventLevel.Verbose, "Checking input port {inputPort} with selector {portSelector} against {selector}", this, port, port.Selector, selector);
+                    return port.Selector.ToString() == selector.ToString();
+                });
+
+                if (inputPort == null)
+                {
+                    Debug.LogMessage(LogEventLevel.Verbose, "Unable to find input port for selector {selector}", this, selector);                    
+                    return;
+                }
+
+                Debug.LogMessage(LogEventLevel.Verbose, "Setting current input port to {inputPort}", this, inputPort);
+                CurrentInputPort = inputPort;
+            } catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error making switch: {Exception}", this, ex);
+            }
+        }
+
+        public void SetInput(string selector)
+        {
+			ISelectableItem currentInput = null;
+
+			try
+			{
+				currentInput = Inputs.Items.SingleOrDefault(Inputs => Inputs.Value.IsSelected).Value;
+			}
+			catch { }
+			
+
+            if (currentInput != null)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, this, "SetInput: {0}", selector);
+                currentInput.IsSelected = false;
+            }
+
+			if (!Inputs.Items.TryGetValue(selector, out var input))
+                return;
+
+			input.IsSelected = true;
+
+			Inputs.CurrentItem = selector;
+        }
 
 
         #region IBasicVolumeWithFeedback Members
@@ -223,14 +269,13 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 	    {
 	        LinkDisplayToApi(this, trilist, joinStart, joinMapKey, bridge);
 	    }
-
-
     }
+
 	public class MockDisplayFactory : EssentialsDeviceFactory<MockDisplay>
 	{
 		public MockDisplayFactory()
 		{
-			TypeNames = new List<string>() { "mockdisplay" };
+			TypeNames = new List<string>() { "mockdisplay" , "mockdisplay2" };
 		}
 
 		public override EssentialsDevice BuildDevice(DeviceConfig dc)