Merge branch 'development' into feature/GenericHttpClientOptions

Feature: Add constructor to set client options

feature: Add overloaded methods to set Request Types for Client Requests

PepperDashEssentials/Audio/EssentialsVolumeLevelConfig.cs

@@ -55,7 +55,7 @@ namespace PepperDash.Essentials
                 return null;
             }
 
-            // DSP format: deviceKey--levelName, biampTesira-1--master
+            // DSP/DMPS format: deviceKey--levelName, biampTesira-1--master
             match = Regex.Match(DeviceKey, @"([-_\w]+)--(.+)");
             if (match.Success)
             {
@@ -67,6 +67,27 @@ namespace PepperDash.Essentials
                     if (dsp.LevelControlPoints.ContainsKey(levelTag)) // should always...
                         return dsp.LevelControlPoints[levelTag];
                 }
+
+                var dmps = DeviceManager.GetDeviceForKey(devKey) as DmpsAudioOutputController;
+                if (dmps != null)
+                {
+                    var levelTag = match.Groups[2].Value;
+                    switch (levelTag)
+                    {
+                        case "master":
+                            return dmps.MasterVolumeLevel;
+                        case "source":
+                            return dmps.SourceVolumeLevel;
+                        case "micsmaster":
+                            return dmps.MicsMasterVolumeLevel;
+                        case "codec1":
+                            return dmps.Codec1VolumeLevel;
+                        case "codec2":
+                            return dmps.Codec2VolumeLevel;
+                        default:
+                            return dmps.MasterVolumeLevel;
+                    }
+                }
                 // No volume for some reason. We have failed as developers
                 return null;
             }

PepperDashEssentials/ControlSystem.cs

@@ -13,6 +13,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Fusion;
+using PepperDash.Essentials.Core.Web;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.DM;
 using PepperDash.Essentials.Fusion;
@@ -46,28 +47,29 @@ namespace PepperDash.Essentials
         /// </summary>
         public override void InitializeSystem()
         {
-            _startTimer = new CTimer(StartSystem,StartupTime);
-
-
             // If the control system is a DMPS type, we need to wait to exit this method until all devices have had time to activate
             // to allow any HD-BaseT DM endpoints to register first.
-            if (Global.ControlSystemIsDmpsType)
+            bool preventInitializationComplete = Global.ControlSystemIsDmpsType;
+            if (preventInitializationComplete)
             {
                 Debug.Console(1, "******************* InitializeSystem() Entering **********************");
-
+                _startTimer = new CTimer(StartSystem, preventInitializationComplete, StartupTime);
-                _initializeEvent = new CEvent();
+                _initializeEvent = new CEvent(true, false);
-
                 DeviceManager.AllDevicesRegistered += (o, a) =>
                 {
                     _initializeEvent.Set();
-                    Debug.Console(1, "******************* InitializeSystem() Exiting **********************");
                 };
-
                 _initializeEvent.Wait(30000);
+                Debug.Console(1, "******************* InitializeSystem() Exiting **********************");
+                SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
+            }
+            else
+            {
+                _startTimer = new CTimer(StartSystem, preventInitializationComplete, StartupTime);
             }
         }
 
-        private void StartSystem(object obj)
+        private void StartSystem(object preventInitialization)
         {
             DeterminePlatform();
 
@@ -79,36 +81,41 @@ namespace PepperDash.Essentials
 
             CrestronConsole.AddNewConsoleCommand(PluginLoader.ReportAssemblyVersions, "reportversions", "Reports the versions of the loaded assemblies", ConsoleAccessLevelEnum.AccessOperator);
 
-            CrestronConsole.AddNewConsoleCommand(PepperDash.Essentials.Core.DeviceFactory.GetDeviceFactoryTypes, "gettypes", "Gets the device types that can be built. Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(Core.DeviceFactory.GetDeviceFactoryTypes, "gettypes", "Gets the device types that can be built. Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(BridgeHelper.PrintJoinMap, "getjoinmap", "map(s) for bridge or device on bridge [brKey [devKey]]", ConsoleAccessLevelEnum.AccessOperator);
 
-            CrestronConsole.AddNewConsoleCommand(s =>
+            CrestronConsole.AddNewConsoleCommand(BridgeHelper.JoinmapMarkdown, "getjoinmapmarkdown"
-            {
+                , "generate markdown of map(s) for bridge or device on bridge [brKey [devKey]]", ConsoleAccessLevelEnum.AccessOperator);
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "CONSOLE MESSAGE: {0}", s);
+
-            }, "appdebugmessage", "Writes message to log", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => Debug.Console(0, Debug.ErrorLogLevel.Notice, "CONSOLE MESSAGE: {0}", s), "appdebugmessage", "Writes message to log", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
             {
                 foreach (var tl in TieLineCollection.Default)
-                    CrestronConsole.ConsoleCommandResponse("  {0}\r\n", tl);
+                    CrestronConsole.ConsoleCommandResponse("  {0}{1}", tl, CrestronEnvironment.NewLine);
             },
             "listtielines", "Prints out all tie lines", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
             {
                 CrestronConsole.ConsoleCommandResponse
-                    ("Current running configuration. This is the merged system and template configuration");
+                    ("Current running configuration. This is the merged system and template configuration" + CrestronEnvironment.NewLine);
                 CrestronConsole.ConsoleCommandResponse(Newtonsoft.Json.JsonConvert.SerializeObject
                     (ConfigReader.ConfigObject, Newtonsoft.Json.Formatting.Indented));
             }, "showconfig", "Shows the current running merged config", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
-            {
+                CrestronConsole.ConsoleCommandResponse(
-                CrestronConsole.ConsoleCommandResponse("This system can be found at the following URLs:\r\n" +
+                "This system can be found at the following URLs:{2}" +
-                    "System URL:   {0}\r\n" +
+                "System URL:   {0}{2}" +
-                    "Template URL: {1}", ConfigReader.ConfigObject.SystemUrl, ConfigReader.ConfigObject.TemplateUrl);
+                "Template URL: {1}{2}",
-            }, "portalinfo", "Shows portal URLS from configuration", ConsoleAccessLevelEnum.AccessOperator);
+                ConfigReader.ConfigObject.SystemUrl,
+                ConfigReader.ConfigObject.TemplateUrl,
+                CrestronEnvironment.NewLine),
+                "portalinfo",
+                "Shows portal URLS from configuration",
+                ConsoleAccessLevelEnum.AccessOperator);
 
 
             CrestronConsole.AddNewConsoleCommand(DeviceManager.GetRoutingPorts,
@@ -120,8 +127,11 @@ namespace PepperDash.Essentials
                 return;
             }
 
+            if (!(bool)preventInitialization)
+            {
                 SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
             }
+        }
 
         /// <summary>
         /// Determines if the program is running on a processor (appliance) or server (VC-4).
@@ -195,6 +205,8 @@ namespace PepperDash.Essentials
                 }
                 else   // Handles Linux OS (Virtual Control)
                 {
+                    Debug.SetDebugLevel(2);
+
                     Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", Global.AssemblyVersion);
 
                     // Set path to User/
@@ -296,6 +308,10 @@ namespace PepperDash.Essentials
             if (!Directory.Exists(pluginDir))
                 Directory.Create(pluginDir);
 
+            var joinmapDir = Global.FilePathPrefix + "joinmaps";
+            if(!Directory.Exists(joinmapDir))
+                Directory.Create(joinmapDir);
+
 			return configExists;
 		}
 
@@ -343,6 +359,7 @@ namespace PepperDash.Essentials
 
             // Build the processor wrapper class
             DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
+			DeviceManager.AddDevice(new EssemtialsWebApi("essentialsWebApi","Essentials Web API"));
 
             // Add global System Monitor device
             if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance)

PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs

@@ -746,6 +746,28 @@ namespace PepperDash.Essentials
             //Implement this
         }
 
+        protected override bool AllowVacancyTimerToStart()
+        {
+            bool allowVideo = true;
+            bool allowAudio = true;
+
+            if (VideoCodec != null)
+            {
+                Debug.Console(2,this, Debug.ErrorLogLevel.Notice, "Room {0} {1} in a video call", Key, VideoCodec.IsInCall ? "is" : "is not");
+                allowVideo = !VideoCodec.IsInCall;
+            }
+
+            if (AudioCodec != null)
+            {
+                Debug.Console(2,this, Debug.ErrorLogLevel.Notice, "Room {0} {1} in an audio call", Key, AudioCodec.IsInCall ? "is" : "is not");
+                allowAudio = !AudioCodec.IsInCall;
+            }
+
+            Debug.Console(2, this, "Room {0} allowing vacancy timer to start: {1}", Key, allowVideo && allowAudio);
+
+            return allowVideo && allowAudio;
+        }
+        
         /// <summary>
         /// Does what it says
         /// </summary>

PepperDashEssentials/Room/Types/EssentialsTechRoom.cs

@@ -272,7 +272,7 @@ namespace PepperDash.Essentials
                 {
                     Debug.Console(2, this, 
 @"Attempting to run action:
-DeviceKey: {0}
+Key: {0}
 MethodName: {1}
 Params: {2}"
                     , a.DeviceKey, a.MethodName, a.Params);

PepperDashEssentials/Room/Types/IEssentialsHuddleSpaceRoom.cs

@@ -1,44 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.DeviceTypeInterfaces;
-using PepperDash.Essentials.Room.Config;
-using PepperDash.Essentials.Core.Devices;
-using PepperDash.Essentials.Devices.Common.Codec;
-using PepperDash.Essentials.Devices.Common.VideoCodec;
-using PepperDash.Essentials.Devices.Common.AudioCodec;
-
-
-using PepperDash.Core;
-
-namespace PepperDash.Essentials
-{
-    public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IHasDefaultDisplay
-    {
-        bool ExcludeFromGlobalFunctions { get; }
-
-        void RunRouteAction(string routeKey);
-
-        EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; }
-
-        IBasicVolumeControls CurrentVolumeControls { get; }
-
-        event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
-    }
-
-    public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange,
-        IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay
-    {
-        EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
-
-        void RunRouteAction(string routeKey);
-
-        IHasScheduleAwareness ScheduleSource { get; }
-
-        string DefaultCodecRouteString { get; }
-    }
-}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/BridgeBase.cs

@@ -46,6 +46,33 @@ namespace PepperDash.Essentials.Core.Bridges
                 bridge.PrintJoinMaps();
             }
         }
+        public static void JoinmapMarkdown(string command)
+        {
+            var targets = command.Split(' ');
+
+            var bridgeKey = targets[0].Trim();
+
+            var bridge = DeviceManager.GetDeviceForKey(bridgeKey) as EiscApiAdvanced;
+
+            if (bridge == null)
+            {
+                Debug.Console(0, "Unable to find advanced bridge with key: '{0}'", bridgeKey);
+                return;
+            }
+
+            if (targets.Length > 1)
+            {
+                var deviceKey = targets[1].Trim();
+
+                if (string.IsNullOrEmpty(deviceKey)) return;
+                bridge.MarkdownJoinMapForDevice(deviceKey, bridgeKey);
+            }
+            else
+            {
+                bridge.MarkdownForBridge(bridgeKey);
+
+            }
+        }
     }
 
 
@@ -82,7 +109,7 @@ namespace PepperDash.Essentials.Core.Bridges
     {
         public EiscApiPropertiesConfig PropertiesConfig { get; private set; }
 
-        protected Dictionary<string, JoinMapBaseAdvanced> JoinMaps { get; private set; }
+        public Dictionary<string, JoinMapBaseAdvanced> JoinMaps { get; private set; }
 
         public BasicTriList Eisc { get; private set; }
 
@@ -227,6 +254,19 @@ namespace PepperDash.Essentials.Core.Bridges
                 joinMap.Value.PrintJoinMapInfo();
             }
         }
+        /// <summary>
+        /// Generates markdown for all join maps on this bridge
+        /// </summary>
+        public virtual void MarkdownForBridge(string bridgeKey)
+        {
+            Debug.Console(0, this, "Writing Joinmaps to files for EISC IPID: {0}", Eisc.ID.ToString("X"));
+
+            foreach (var joinMap in JoinMaps)
+            {
+                Debug.Console(0, "Generating markdown for device '{0}':", joinMap.Key);
+                joinMap.Value.MarkdownJoinMapInfo(joinMap.Key, bridgeKey);
+            }
+        }
 
         /// <summary>
         /// Prints the join map for a device by key
@@ -245,6 +285,23 @@ namespace PepperDash.Essentials.Core.Bridges
             Debug.Console(0, "Join map for device '{0}' on EISC '{1}':", deviceKey, Key);
             joinMap.PrintJoinMapInfo();
         }
+        /// <summary>
+        /// Prints the join map for a device by key
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        public void MarkdownJoinMapForDevice(string deviceKey, string bridgeKey)
+        {
+            var joinMap = JoinMaps[deviceKey];
+
+            if (joinMap == null)
+            {
+                Debug.Console(0, this, "Unable to find joinMap for device with key: '{0}'", deviceKey);
+                return;
+            }
+
+            Debug.Console(0, "Join map for device '{0}' on EISC '{1}':", deviceKey, Key);
+            joinMap.MarkdownJoinMapInfo(deviceKey, bridgeKey);
+        }
 
         /// <summary>
         /// Used for debugging to trigger an action based on a join number and type
@@ -394,35 +451,51 @@ namespace PepperDash.Essentials.Core.Bridges
 
             var controlProperties = CommFactory.GetControlPropertiesConfig(dc);
 
+            BasicTriList eisc;
+
             switch (dc.Type.ToLower())
             {
                 case "eiscapiadv":
                 case "eiscapiadvanced":
                     {
-                    var eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
+                        eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
                             controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                        break;
                     }
                 case "eiscapiadvancedserver":
                     {
-                    var eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
+                        eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                        break;
                     }
                 case "eiscapiadvancedclient":
                     {
-                    var eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
+                        eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                        break;
                     }
                 case "vceiscapiadv":
                 case "vceiscapiadvanced":
                     {
-                    var eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, InitialParametersClass.RoomId,
+                        if (string.IsNullOrEmpty(controlProperties.RoomId))
+                        {
+                            Debug.Console(0, Debug.ErrorLogLevel.Error, "Unable to build VC-4 EISC Client for device {0}. Room ID is missing or empty", dc.Key);
+                            eisc = null;
+                            break;
+                        }
+                        eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, controlProperties.RoomId,
                             Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                        break;
                     }
                 default:
+                    eisc = null;
+                    break;
+            }
+
+            if (eisc == null)
+            {
                 return null;
             }
+
+            return new EiscApiAdvanced(dc, eisc);
         }
     }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/DmRmcControllerJoinMap.cs

@@ -36,6 +36,28 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete AudioVideoSource = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
             new JoinMetadata { Description = "DM RMC Audio Video Source Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
 
+        [JoinName("HdcpSupportCapability")]
+        public JoinDataComplete HdcpSupportCapability = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC HDCP Support Capability", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("Port1HdcpState")]
+        public JoinDataComplete Port1HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 3, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC Port 1 (DM) HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("Port2HdcpState")]
+        public JoinDataComplete Port2HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 4, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM TX Port 2 (HDMI) HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("HdmiInputSync")]
+        public JoinDataComplete HdmiInputSync = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC HDMI Input Sync", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdcpInputPortCount")]
+        public JoinDataComplete HdcpInputPortCount = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata { Description = "Number of Input Ports that support HDCP", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>
@@ -50,7 +72,8 @@ namespace PepperDash.Essentials.Core.Bridges
         /// </summary>
         /// <param name="joinStart">Join this join map will start at</param>
         /// <param name="type">Type of the child join map</param>
-        protected DmRmcControllerJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        protected DmRmcControllerJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
         {
         }
     }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/DmTxControllerJoinMap.cs

@@ -64,6 +64,16 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete VgaContrast = new JoinDataComplete(new JoinData { JoinNumber = 7, JoinSpan = 1 },
             new JoinMetadata { Description = "DM TX Online", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
 
+        [JoinName("Port3HdcpState")]
+        public JoinDataComplete Port3HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 8, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM TX Port 3 HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("HdcpInputPortCount")]
+        public JoinDataComplete HdcpInputPortCount = new JoinDataComplete(new JoinData { JoinNumber = 9, JoinSpan = 1 },
+            new JoinMetadata { Description = "Number of Input Ports that support HDCP", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>
@@ -78,7 +88,8 @@ namespace PepperDash.Essentials.Core.Bridges
         /// </summary>
         /// <param name="joinStart">Join this join map will start at</param>
         /// <param name="type">Type of the child join map</param>
-        protected DmTxControllerJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        protected DmTxControllerJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
         {
         }
     }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/IAnalogInputJoinMap.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class IAnalogInputJoinMap : JoinMapBaseAdvanced
+    {
+
+        [JoinName("InputValue")]
+        public JoinDataComplete InputValue = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "Input Value", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+        [JoinName("MinimumChange")]
+        public JoinDataComplete MinimumChange = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "Minimum voltage change required to reflect a change", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        /// <summary>
+        /// Constructor to use when instantiating this Join Map without inheriting from it
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        public IAnalogInputJoinMap(uint joinStart)
+            : this(joinStart, typeof(IAnalogInputJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected IAnalogInputJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
+        {
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/IDigitalInputJoinMap.cs

@@ -7,7 +7,7 @@ namespace PepperDash.Essentials.Core.Bridges
 
         [JoinName("InputState")]
         public JoinDataComplete InputState = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
-            new JoinMetadata { Description = "Room Email Url", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+            new JoinMetadata { Description = "Input State", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
 
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/IDigitalOutputJoinMap.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class IDigitalOutputJoinMap : JoinMapBaseAdvanced
+    {
+
+        [JoinName("OutputState")]
+        public JoinDataComplete OutputState = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "Get / Set state of Digital Input", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        /// <summary>
+        /// Constructor to use when instantiating this Join Map without inheriting from it
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        public IDigitalOutputJoinMap(uint joinStart)
+            : this(joinStart, typeof(IDigitalOutputJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected IDigitalOutputJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
+        {
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/SystemMonitorJoinMap.cs

@@ -132,6 +132,23 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete DhcpStatus = new JoinDataComplete(new JoinData { JoinNumber = 86, JoinSpan = 1 },
             new JoinMetadata { Description = "Processor Ethernet Dhcp Status", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
 
+		[JoinName("ProcessorRebot")]
+		public JoinDataComplete ProcessorReboot = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+			new JoinMetadata { Description = "Reboot processor", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("IsAppliance")]
+		public JoinDataComplete IsAppliance = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+			new JoinMetadata { Description = "Is appliance Fb", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("IsServer")]
+		public JoinDataComplete IsServer = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+			new JoinMetadata { Description = "Is server Fb", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("ProgramReset")]
+		public JoinDataComplete ProgramReset = new JoinDataComplete(new JoinData { JoinNumber = 15, JoinSpan = 1 },
+			new JoinMetadata { Description = "Resets the program", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/CommFactory.cs

@@ -183,6 +183,8 @@ namespace PepperDash.Essentials.Core
         [JsonConverter(typeof(ComSpecJsonConverter))]
         public ComPort.ComPortSpec ComParams { get; set; }
 
+		public string RoomId { get; set; }
+
 		public string CresnetId { get; set; }
 
         /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/GenericHttpClient.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.ComponentModel;
-using System.Text;
-using Crestron.SimplSharp;
 using Crestron.SimplSharp.Net.Http;
+using Crestron.SimplSharp.Ssh;
+using Crestron.SimplSharpPro.EthernetCommunication;
 using PepperDash.Core;
-using PepperDash.Core.DebugThings;
 
 namespace PepperDash.Essentials.Core
 {
@@ -17,52 +16,130 @@ namespace PepperDash.Essentials.Core
 		public GenericHttpClient(string key, string name, string hostname)
 			: base(key, name)
 		{
-			Client = new HttpClient();
+			Client = new HttpClient {HostName = hostname};
-			Client.HostName = hostname;
+		}
-			
 
+	    public GenericHttpClient(string key, string name, string hostname, GenericHttpClientConnectionOptions options)
+	        : base(key, name)
+	    {
+	        Client = new HttpClient
+	        {
+	            HostName = hostname,
+	            Accept = options.Accept,
+	            KeepAlive = options.KeepAlive,
+	            Password = options.Password,
+	            Timeout = options.Timeout,
+	            TimeoutEnabled = options.TimeoutEnabled,
+	            UserAgent = options.UserAgent,
+	            UserName = options.UserName,
+	            Version = options.Version
+	        };
+	        if (options.Port > 0) Client.Port = options.Port;
 	    }
 
 	    /// <summary>
-		/// 
+		/// Send a HTTP Get Request to a client
 		/// </summary>
-		/// <param name="path"></param>
+		/// <param name="path">Path to request node</param>
         public void SendText(string path)
         {
-			HttpClientRequest request = new HttpClientRequest();
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
-			string url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
-			request.Url = new UrlParser(url);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request); 
-		}
-		public void SendText(string format, params object[] items)
             {
-			HttpClientRequest request = new HttpClientRequest();
+                Url = new UrlParser(url)
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            };
-			request.Url = new UrlParser(url);
+            var error = Client.DispatchAsyncEx(request, Response, request);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request);
         }
 
+        /// <summary>
+        /// Send a HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
         public void SendTextNoResponse(string format, params object[] items)
         {
-			HttpClientRequest request = new HttpClientRequest();
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
-			request.Url = new UrlParser(url);
+            {
+                Url = new UrlParser(url)
+            };
+            Client.Dispatch(request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="path">Path to request node</param>
+        public void SendText(RequestType requestType, string path)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendTextNoResponse(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
             Client.Dispatch(request);
         }
 
 		private void Response(HttpClientResponse response, HTTP_CALLBACK_ERROR error, object request)
 		{
-			if (error == HTTP_CALLBACK_ERROR.COMPLETED)
+		    if (error != HTTP_CALLBACK_ERROR.COMPLETED) return;
-			{
 		    var responseReceived = response;
 
-				if (responseReceived.ContentString.Length > 0)
+		    if (responseReceived.ContentString.Length <= 0) return;
-				{
+		    if (ResponseRecived == null) return;
-					if (ResponseRecived != null)
+		    var httpClientRequest = request as HttpClientRequest;
-						ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, (request as HttpClientRequest).Url.ToString(), error));
+		    if (httpClientRequest != null)
-				}
+		        ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, httpClientRequest.Url.ToString(), error));
-			}
-
 		}
 
 
@@ -100,6 +177,8 @@ namespace PepperDash.Essentials.Core
 
 		#endregion
 	}
+
+
 	public class GenericHttpClientEventArgs : EventArgs
 	{
 		public string ResponseText { get; private set; }
@@ -112,4 +191,84 @@ namespace PepperDash.Essentials.Core
 			Error = error;
 		}
 	}
+
+    /// <summary>
+    /// Objedct to set parameters for HTTP Requests
+    /// </summary>
+    public class GenericHttpClientConnectionOptions
+    {
+        /// <summary>
+        ///     Gets or sets content types that are acceptable for the response. The default
+        ///     value is "text/html, image/gif, image/jpeg, image/png, */*".
+        /// </summary>
+        [DefaultValue("text/html, image/gif, image/jpeg, image/png")]
+        public string Accept { get; set; }
+
+        /// <summary>
+        ///     Controls whether to use HTTP Keep-Alive to keep the connection alive between
+        ///     requests. If enabled (true) , once a request is made and a connection is
+        ///     established, this connection is kept open and used for future requests. If
+        ///     disabled, the connection is closed, and a new connection is created for future
+        ///     requests.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool KeepAlive { get; set; }
+
+        /// <summary>
+        ///     This property controls whether the request operation will do an automatic
+        ///     timeout checking. If timeout handling is turned on (i.e. this property is
+        ///     set to true) and a request takes longer than Timeout, it will be terminated.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool TimeoutEnabled { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the maximum amount of time (in seconds) that a client will wait
+        ///     for a server response within a single request. The default value is 60 seconds
+        ///     (1 minute).  The timeout handling can be activated via the TimeoutEnabled
+        ///     property.
+        /// </summary>
+        [DefaultValue(60)]
+        public int Timeout { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the version identifier of the UserAgent. Can be used to mimic
+        ///     particular browsers like Internet Explorer 6.0
+        /// </summary>
+        [DefaultValue("1.1")]
+        public string Version { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the identifier of the software being used to retrieve data via
+        ///     the URL. Some custom HTTP servers check this HTTP header to provide content
+        ///     optimized for particular HTTP browsers.
+        /// </summary>
+        [DefaultValue("Crestron SimplSharp HTTP Client")]
+        public string UserAgent { get; set; }
+
+        /// <summary>
+        ///    Name that will be inserted into the Authorization HTTP header in the request
+        ///    to the server.
+        /// </summary>
+        public string UserName { get; set; }
+
+        /// <summary>
+        ///     Password that will be inserted into the Authorization HTTP header in the
+        ///     request to the server.
+        /// </summary>
+        public string Password { get; set; }
+
+        /// <summary>
+        ///     The server Port that you intend the client to connect to.  If you do not
+        ///     assign a port number on this property, the port number in the parsed URL
+        ///     will be used. If a port number is assigned in the parsed URL, it will take
+        ///     precedence over this property.
+        /// </summary>
+        /// <remarks>
+        ///     If you do not assign a port number on this property, the port number in the
+        ///     parsed URL will be used.
+        /// </remarks>
+        /// 
+        public int Port { get; set; }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/DinIo8/DinIo8Controller.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class DinIo8Controller:CrestronGenericBaseDevice, IIOPorts
+    {
+        private DinIo8 _device;
+
+        public DinIo8Controller(string key, Func<DeviceConfig, DinIo8> preActivationFunc, DeviceConfig config):base(key, config.Name)
+        {
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_device);
+            });
+        }
+
+        #region Implementation of IIOPorts
+
+        public CrestronCollection<Versiport> VersiPorts
+        {
+            get { return _device.VersiPorts; }
+        }
+
+        public int NumberOfVersiPorts
+        {
+            get { return _device.NumberOfVersiPorts; }
+        }
+
+        #endregion
+
+
+    }
+
+    public class DinIo8ControllerFactory : EssentialsDeviceFactory<DinIo8Controller>
+    {
+        public DinIo8ControllerFactory()
+        {
+            TypeNames = new List<string>() { "DinIo8" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new DinIo8 Device");
+
+            return new DinIo8Controller(dc.Key, GetDinIo8Device, dc);
+        }
+
+        static DinIo8 GetDinIo8Device(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new DinIo8", parentKey);
+                return new DinIo8(cresnetId, Global.ControlSystem);
+            }
+            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new DinIo8", parentKey);
+                return new DinIo8(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/IOPortConfig.cs

@@ -15,5 +15,7 @@ namespace PepperDash.Essentials.Core.CrestronIO
         public uint PortNumber { get; set; }
         [JsonProperty("disablePullUpResistor")]
         public bool DisablePullUpResistor { get; set; }
+        [JsonProperty("minimumChange")]
+        public int MinimumChange { get; set; }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/GenericVersiportAnalogInputDevice.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic digital input deviced tied to a versiport
+    /// </summary>
+    public class GenericVersiportAnalogInputDevice : EssentialsBridgeableDevice, IAnalogInput
+    {
+        public Versiport InputPort { get; private set; }
+
+        public IntFeedback InputValueFeedback { get; private set; }
+        public IntFeedback InputMinimumChangeFeedback { get; private set; }
+
+        Func<int> InputValueFeedbackFunc
+        {
+            get
+            {
+                return () => InputPort.AnalogIn;
+            }
+        }
+
+        Func<int> InputMinimumChangeFeedbackFunc
+        {
+            get { return () => InputPort.AnalogMinChange; }
+        } 
+
+        public GenericVersiportAnalogInputDevice(string key, string name, Func<IOPortConfig, Versiport> postActivationFunc, IOPortConfig config) :
+            base(key, name)
+        {
+            InputValueFeedback = new IntFeedback(InputValueFeedbackFunc);
+            InputMinimumChangeFeedback = new IntFeedback(InputMinimumChangeFeedbackFunc);
+
+            AddPostActivationAction(() =>
+            {
+                InputPort = postActivationFunc(config);
+
+                InputPort.Register();
+
+                InputPort.SetVersiportConfiguration(eVersiportConfiguration.AnalogInput);
+                InputPort.AnalogMinChange = (ushort)(config.MinimumChange > 0 ? config.MinimumChange : 655);
+                if (config.DisablePullUpResistor)
+                    InputPort.DisablePullUpResistor = true;
+
+                InputPort.VersiportChange += InputPort_VersiportChange;
+
+                Debug.Console(1, this, "Created GenericVersiportAnalogInputDevice on port '{0}'.  DisablePullUpResistor: '{1}'", config.PortNumber, InputPort.DisablePullUpResistor);
+
+            });
+
+        }
+
+        /// <summary>
+        /// Set minimum voltage change for device to update voltage changed method
+        /// </summary>
+        /// <param name="value">valid values range from 0 - 65535, representing the full 100% range of the processor voltage source.  Check processor documentation for details</param>
+        public void SetMinimumChange(ushort value)
+        {
+            InputPort.AnalogMinChange = value;
+        }
+
+        void InputPort_VersiportChange(Versiport port, VersiportEventArgs args)
+        {
+			Debug.Console(1, this, "Versiport change: {0}", args.Event);
+
+            if(args.Event == eVersiportEvent.AnalogInChange)
+                InputValueFeedback.FireUpdate();
+            if (args.Event == eVersiportEvent.AnalogMinChangeChange)
+                InputMinimumChangeFeedback.FireUpdate();
+        }
+
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new IAnalogInputJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IAnalogInputJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            try
+            {
+                Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                InputValueFeedback.LinkInputSig(trilist.UShortInput[joinMap.InputValue.JoinNumber]);
+                InputMinimumChangeFeedback.LinkInputSig(trilist.UShortInput[joinMap.MinimumChange.JoinNumber]);
+                trilist.SetUShortSigAction(joinMap.MinimumChange.JoinNumber, SetMinimumChange);
+
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Unable to link device '{0}'.  Input is null", Key);
+                Debug.Console(1, this, "Error: {0}", e);
+            }
+
+            trilist.OnlineStatusChange += (d, args) =>
+            {
+                if (!args.DeviceOnLine) return;
+                InputValueFeedback.FireUpdate();
+                InputMinimumChangeFeedback.FireUpdate();
+            };
+
+        }
+
+        void trilist_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+
+        public static Versiport GetVersiportDigitalInput(IOPortConfig dc)
+        {
+         
+            IIOPorts ioPortDevice;
+
+            if (dc.PortDeviceKey.Equals("processor"))
+            {
+                if (!Global.ControlSystem.SupportsVersiport)
+                {
+                    Debug.Console(0, "GetVersiportAnalogInput: Processor does not support Versiports");
+                    return null;
+                }
+                ioPortDevice = Global.ControlSystem;
+            }
+            else
+            {
+                var ioPortDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IIOPorts;
+                if (ioPortDev == null)
+                {
+                    Debug.Console(0, "GetVersiportAnalogInput: Device {0} is not a valid device", dc.PortDeviceKey);
+                    return null;
+                }
+                ioPortDevice = ioPortDev;
+            }
+            if (ioPortDevice == null)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device '0' is not a valid IIOPorts Device", dc.PortDeviceKey);
+                return null;
+            }
+
+            if (dc.PortNumber > ioPortDevice.NumberOfVersiPorts)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+                return null;
+            }
+            if(!ioPortDevice.VersiPorts[dc.PortNumber].SupportsAnalogInput)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device {0} does not support AnalogInput on port {1}", dc.PortDeviceKey, dc.PortNumber);
+                return null;
+            }
+
+
+            return ioPortDevice.VersiPorts[dc.PortNumber];
+
+
+        }
+    }
+
+
+    public class GenericVersiportAbalogInputDeviceFactory : EssentialsDeviceFactory<GenericVersiportAnalogInputDevice>
+    {
+        public GenericVersiportAbalogInputDeviceFactory()
+        {
+            TypeNames = new List<string>() { "versiportanaloginput" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new Generic Versiport Device");
+
+            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+            if (props == null) return null;
+
+            var portDevice = new GenericVersiportAnalogInputDevice(dc.Key, dc.Name, GenericVersiportAnalogInputDevice.GetVersiportDigitalInput, props);
+
+            return portDevice;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/IAnalogInput.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public interface IAnalogInput
+    {
+        IntFeedback InputValueFeedback { get; }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Outputs/GenericVersiportOutputDevice.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic digital input deviced tied to a versiport
+    /// </summary>
+    public class GenericVersiportDigitalOutputDevice : EssentialsBridgeableDevice, IDigitalOutput
+    {
+        public Versiport OutputPort { get; private set; }
+
+        public BoolFeedback OutputStateFeedback { get; private set; }
+
+        Func<bool> OutputStateFeedbackFunc
+        {
+            get
+            {
+                return () => OutputPort.DigitalOut;
+            }
+        }
+
+        public GenericVersiportDigitalOutputDevice(string key, string name, Func<IOPortConfig, Versiport> postActivationFunc, IOPortConfig config) :
+            base(key, name)
+        {
+            OutputStateFeedback = new BoolFeedback(OutputStateFeedbackFunc);
+
+            AddPostActivationAction(() =>
+            {
+                OutputPort = postActivationFunc(config);
+
+                OutputPort.Register();
+
+
+                if (!OutputPort.SupportsDigitalOutput)
+                {
+                    Debug.Console(0, this, "Device does not support configuration as a Digital Output");
+                    return;
+                }
+
+                OutputPort.SetVersiportConfiguration(eVersiportConfiguration.DigitalOutput);
+
+
+                OutputPort.VersiportChange += OutputPort_VersiportChange;
+
+            });
+
+        }
+
+        void OutputPort_VersiportChange(Versiport port, VersiportEventArgs args)
+        {
+			Debug.Console(1, this, "Versiport change: {0}", args.Event);
+
+            if(args.Event == eVersiportEvent.DigitalOutChange)
+                OutputStateFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// Set value of the versiport digital output
+        /// </summary>
+        /// <param name="state">value to set the output to</param>
+        public void SetOutput(bool state)
+        {
+                if (OutputPort.SupportsDigitalOutput)
+                {
+                    Debug.Console(0, this, "Passed the Check");
+
+                    OutputPort.DigitalOut = state;
+
+                }
+                else
+                {
+                    Debug.Console(0, this, "Versiport does not support Digital Output Mode");
+                }
+
+        }
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new IDigitalOutputJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IDigitalOutputJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            try
+            {
+                Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                OutputStateFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OutputState.JoinNumber]);
+                trilist.SetBoolSigAction(joinMap.OutputState.JoinNumber, SetOutput);
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Unable to link device '{0}'.  Input is null", Key);
+                Debug.Console(1, this, "Error: {0}", e);
+            }
+        }
+
+        #endregion
+
+
+        public static Versiport GetVersiportDigitalOutput(IOPortConfig dc)
+        {
+
+                IIOPorts ioPortDevice;
+
+                if (dc.PortDeviceKey.Equals("processor"))
+                {
+                    if (!Global.ControlSystem.SupportsVersiport)
+                    {
+                        Debug.Console(0, "GetVersiportDigitalOuptut: Processor does not support Versiports");
+                        return null;
+                    }
+                    ioPortDevice = Global.ControlSystem;
+                }
+                else
+                {
+                    var ioPortDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IIOPorts;
+                    if (ioPortDev == null)
+                    {
+                        Debug.Console(0, "GetVersiportDigitalOuptut: Device {0} is not a valid device", dc.PortDeviceKey);
+                        return null;
+                    }
+                    ioPortDevice = ioPortDev;
+                }
+                if (ioPortDevice == null)
+                {
+                    Debug.Console(0, "GetVersiportDigitalOuptut: Device '0' is not a valid IOPorts Device", dc.PortDeviceKey);
+                    return null;
+                }
+
+                if (dc.PortNumber > ioPortDevice.NumberOfVersiPorts)
+                {
+                    Debug.Console(0, "GetVersiportDigitalOuptut: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+                }
+                var port = ioPortDevice.VersiPorts[dc.PortNumber];
+                return port;
+
+        }
+    }
+
+
+    public class GenericVersiportDigitalOutputDeviceFactory : EssentialsDeviceFactory<GenericVersiportDigitalInputDevice>
+    {
+        public GenericVersiportDigitalOutputDeviceFactory()
+        {
+            TypeNames = new List<string>() { "versiportoutput" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new Generic Versiport Device");
+
+            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+            if (props == null) return null;
+
+            var portDevice = new GenericVersiportDigitalOutputDevice(dc.Key, dc.Name, GenericVersiportDigitalOutputDevice.GetVersiportDigitalOutput, props);
+
+            return portDevice;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Outputs/IDigitalOutput.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a device that provides digital input
+    /// </summary>
+    public interface IDigitalOutput
+    {
+        BoolFeedback OutputStateFeedback { get; }
+        void SetOutput(bool state);
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/DeviceManager.cs

@@ -388,19 +388,17 @@ namespace PepperDash.Essentials.Core
             var outputPorts = ((device as IRoutingOutputs) != null) ? (device as IRoutingOutputs).OutputPorts : null;
             if (inputPorts != null)
             {
-	            Debug.Console(0, "Device {0} has {1} Input Ports:", s, inputPorts.Count);
+                CrestronConsole.ConsoleCommandResponse("Device {0} has {1} Input Ports:{2}", s, inputPorts.Count, CrestronEnvironment.NewLine);
                 foreach (var routingInputPort in inputPorts)
                 {
-	                Debug.Console(0, "{0}", routingInputPort.Key);
+                    CrestronConsole.ConsoleCommandResponse("{0}{1}", routingInputPort.Key, CrestronEnvironment.NewLine);
                 }
             }
-	        if (outputPorts != null)
+            if (outputPorts == null) return;
-	        {
+            CrestronConsole.ConsoleCommandResponse("Device {0} has {1} Output Ports:{2}", s, outputPorts.Count, CrestronEnvironment.NewLine);
-	            Debug.Console(0, "Device {0} has {1} Output Ports:", s, outputPorts.Count);
             foreach (var routingOutputPort in outputPorts)
             {
-	                Debug.Console(0, "{0}", routingOutputPort.Key);
+                CrestronConsole.ConsoleCommandResponse("{0}{1}", routingOutputPort.Key, CrestronEnvironment.NewLine);
-	            }
             }
         }
 
@@ -435,7 +433,7 @@ namespace PepperDash.Essentials.Core
 
             if (device == null)
             {
-                Debug.Console(0, "Unable to get device with key: {0}", deviceKey);
+                CrestronConsole.ConsoleCommandResponse("Unable to get device with key: {0}", deviceKey);
                 return;
             }
 
@@ -447,7 +445,7 @@ namespace PepperDash.Essentials.Core
             }
             catch
             {
-                Debug.Console(0, "Unable to convert setting value.  Please use off/rx/tx/both");
+                CrestronConsole.ConsoleCommandResponse("Unable to convert setting value.  Please use off/rx/tx/both");
                 return;
             }
 
@@ -458,18 +456,18 @@ namespace PepperDash.Essentials.Core
                     var min = Convert.ToUInt32(timeout);
 
                     device.StreamDebugging.SetDebuggingWithSpecificTimeout(debugSetting, min);
-                    Debug.Console(0, "Device: '{0}' debug level set to {1} for {2} minutes", deviceKey, debugSetting, min);
+                    CrestronConsole.ConsoleCommandResponse("Device: '{0}' debug level set to {1} for {2} minutes", deviceKey, debugSetting, min);
 
                 }
                 catch (Exception e)
                 {
-                    Debug.Console(0, "Unable to convert minutes or settings value.  Please use an integer value for minutes. Errro: {0}", e);
+                    CrestronConsole.ConsoleCommandResponse("Unable to convert minutes or settings value.  Please use an integer value for minutes. Error: {0}", e);
                 }
             }
             else
             {
                 device.StreamDebugging.SetDebuggingWithDefaultTimeout(debugSetting);
-                Debug.Console(0, "Device: '{0}' debug level set to {1} for default time (30 minutes)", deviceKey, debugSetting);
+                CrestronConsole.ConsoleCommandResponse("Device: '{0}' debug level set to {1} for default time (30 minutes)", deviceKey, debugSetting);
             }
         }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/PduInterfaces.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Crestron.SimplSharp;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
@@ -8,6 +9,7 @@ namespace PepperDash_Essentials_Core.Devices
     /// <summary>
     /// Interface for any device that is able to control it'spower and has a configurable reboot time
     /// </summary>
+    [Obsolete("PepperDash_Essentials_Core.Devices is Deprecated - use PepperDash.Essentials.Core")]
     public interface IHasPowerCycle : IKeyName, IHasPowerControlWithFeedback
     {
         /// <summary>
@@ -24,6 +26,7 @@ namespace PepperDash_Essentials_Core.Devices
     /// <summary>
     /// Interface for any device that contains a collection of IHasPowerReboot Devices
     /// </summary>
+    [Obsolete("PepperDash_Essentials_Core.Devices is Deprecated - use PepperDash.Essentials.Core")]
     public interface IHasControlledPowerOutlets : IKeyName
     {
         /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/PowerInterfaces.cs

@@ -0,0 +1,87 @@
+using Crestron.SimplSharp;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Interface for any device that has a battery that can be monitored
+    /// </summary>
+    public interface IHasBatteryStats : IKeyName
+    {
+        int BatteryPercentage { get; }
+        int BatteryCautionThresholdPercentage { get;  }
+        int BatteryWarningThresholdPercentage { get; }
+        BoolFeedback BatteryIsWarningFeedback { get; }
+        BoolFeedback BatteryIsCautionFeedback { get; }
+        BoolFeedback BatteryIsOkFeedback { get; }
+        IntFeedback BatteryPercentageFeedback { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that has a battery that can be monitored and the ability to charge and discharge
+    /// </summary>
+    public interface IHasBatteryCharging : IHasBatteryStats
+    {
+        BoolFeedback BatteryIsCharging { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that has multiple batteries that can be monitored
+    /// </summary>
+    public interface IHasBatteries : IKeyName
+    {
+        ReadOnlyDictionary<string, IHasBatteryStats> Batteries { get; }   
+    }
+
+    public interface IHasBatteryStatsExtended : IHasBatteryStats
+    {
+        int InputVoltage { get; }
+        int OutputVoltage { get; }
+        int InptuCurrent { get; }
+        int OutputCurrent { get; }
+
+        IntFeedback InputVoltageFeedback { get; }
+        IntFeedback OutputVoltageFeedback { get; }
+        IntFeedback InputCurrentFeedback { get; }
+        IntFeedback OutputCurrentFeedback { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that is able to control its power, has a configurable reboot time, and has batteries that can be monitored
+    /// </summary>
+    public interface IHasPowerCycleWithBattery : IHasPowerCycle, IHasBatteryStats
+    {
+        
+    }
+
+    /// <summary>
+    /// Interface for any device that is able to control it's power and has a configurable reboot time
+    /// </summary>
+    public interface IHasPowerCycle : IKeyName, IHasPowerControlWithFeedback
+    {
+        /// <summary>
+        /// Delay between power off and power on for reboot
+        /// </summary>
+        int PowerCycleTimeMs { get; }
+
+        /// <summary>
+        /// Reboot outlet
+        /// </summary>
+        void PowerCycle();
+    }
+
+    /// <summary>
+    /// Interface for any device that contains a collection of IHasPowerReboot Devices
+    /// </summary>
+    public interface IHasControlledPowerOutlets : IKeyName
+    {
+        /// <summary>
+        /// Collection of IPduOutlets
+        /// </summary>
+        ReadOnlyDictionary<int, IHasPowerCycle> PduOutlets { get; }
+
+    }
+
+
+
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Extensions/StringExtensions.cs

@@ -16,5 +16,9 @@ namespace PepperDash.Essentials.Core
         {
             return string.IsNullOrEmpty(s.Trim()) ? null : s;
         }
+        public static string ReplaceIfNullOrEmpty(this string s, string newString)
+        {
+            return string.IsNullOrEmpty(s) ? newString : s;
+        }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Factory/DeviceFactory.cs

@@ -172,21 +172,14 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Prints the type names and associated metadata from the FactoryMethods collection.
         /// </summary>
-        /// <param name="command"></param>
+        /// <param name="filter"></param>
         public static void GetDeviceFactoryTypes(string filter)
         {
-            Dictionary<string, DeviceFactoryWrapper> types = new Dictionary<string, DeviceFactoryWrapper>();
+            var types = !string.IsNullOrEmpty(filter)
+                ? FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value)
+                : FactoryMethods;
 
-            if (!string.IsNullOrEmpty(filter))
+            CrestronConsole.ConsoleCommandResponse("Device Types:");
-            {
-                types = FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value);
-            }
-            else
-            {
-                types = FactoryMethods;
-            }
-
-            Debug.Console(0, "Device Types:");
 
             foreach (var type in types.OrderBy(t => t.Key))
             {
@@ -198,11 +191,23 @@ namespace PepperDash.Essentials.Core
                     cType = type.Value.CType.FullName;
                 }
 
-                Debug.Console(0, 
+                CrestronConsole.ConsoleCommandResponse(
                     @"Type: '{0}' 
                     CType: '{1}' 
                     Description: {2}", type.Key, cType, description);
             }
         }
+
+		/// <summary>
+		/// Returns the device factory dictionary
+		/// </summary>
+		/// <param name="filter"></param>
+		/// <returns></returns>
+	    public static Dictionary<string, DeviceFactoryWrapper> GetDeviceFactoryDictionary(string filter)
+		{
+			return string.IsNullOrEmpty(filter) 
+				? FactoryMethods
+				: FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value);
+		}
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/File/FileIO.cs

@@ -23,9 +23,10 @@ namespace PepperDash.Essentials.Core
 		/// <returns></returns>
         public static FileInfo[] GetFiles(string fileName)
         {
-			DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fileName));
+            string fullFilePath = Global.FilePathPrefix + fileName;
-			var files = dirInfo.GetFiles(Path.GetFileName(fileName));
+            DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fullFilePath));
-			Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fileName);
+            var files = dirInfo.GetFiles(Path.GetFileName(fullFilePath));
+            Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fullFilePath);
             if (files.Count() > 0)
             {
                 return files;
@@ -38,9 +39,10 @@ namespace PepperDash.Essentials.Core
 
         public static FileInfo GetFile(string fileName)
         {
-			DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fileName));
+            string fullFilePath = Global.FilePathPrefix + fileName;
-			var files = dirInfo.GetFiles(Path.GetFileName(fileName));
+            DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fullFilePath));
-			Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fileName);
+            var files = dirInfo.GetFiles(Path.GetFileName(fullFilePath));
+            Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fullFilePath);
             if (files.Count() > 0)
             {
                 return files.FirstOrDefault();
@@ -81,7 +83,7 @@ namespace PepperDash.Essentials.Core
 			{
 				if (fileLock.TryEnter())
 				{
-					DirectoryInfo dirInfo = new DirectoryInfo(file.Name);
+					DirectoryInfo dirInfo = new DirectoryInfo(file.DirectoryName);
 					Debug.Console(2, "FileIO Getting Data {0}", file.FullName);
 
 					if (File.Exists(file.FullName))
@@ -202,7 +204,7 @@ namespace PepperDash.Essentials.Core
 		public static void WriteDataToFile(string data, string filePath)
 		{
 			Thread _WriteFileThread;
-			_WriteFileThread = new Thread((O) => _WriteFileMethod(data, filePath), null, Thread.eThreadStartOptions.CreateSuspended);
+            _WriteFileThread = new Thread((O) => _WriteFileMethod(data, Global.FilePathPrefix + "/" + filePath), null, Thread.eThreadStartOptions.CreateSuspended);
 			_WriteFileThread.Priority = Thread.eThreadPriority.LowestPriority;
 			_WriteFileThread.Start();
 			Debug.Console(0, Debug.ErrorLogLevel.Notice, "New WriteFile Thread");
@@ -217,6 +219,7 @@ namespace PepperDash.Essentials.Core
 			{
 				if (fileLock.TryEnter())
 				{
+
                     using (StreamWriter sw = new StreamWriter(filePath))
 					{
 						sw.Write(data);

essentials-framework/Essentials Core/PepperDashEssentialsBase/JoinMaps/JoinMapBase.cs

@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
-using System.Runtime.InteropServices;
+using System.Text;
 using Crestron.SimplSharp.Reflection;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharp;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -98,22 +101,22 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public void PrintJoinMapInfo()
         {
-            Debug.Console(0, "{0}:\n", GetType().Name);
+            CrestronConsole.ConsoleCommandResponse("{0}:\n", GetType().Name);
 
             // Get the joins of each type and print them
-            Debug.Console(0, "Digitals:");
+            CrestronConsole.ConsoleCommandResponse("Digitals:");
             var digitals = Joins.Where(j => (j.Value.JoinType & eJoinType.Digital) == eJoinType.Digital).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Digital Joins", digitals.Count); 
+            CrestronConsole.ConsoleCommandResponse("Found {0} Digital Joins", digitals.Count); 
             PrintJoinList(GetSortedJoins(digitals));
 
-            Debug.Console(0, "Analogs:");
+            CrestronConsole.ConsoleCommandResponse("Analogs:");
             var analogs = Joins.Where(j => (j.Value.JoinType & eJoinType.Analog) == eJoinType.Analog).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Analog Joins", analogs.Count); 
+            CrestronConsole.ConsoleCommandResponse("Found {0} Analog Joins", analogs.Count); 
             PrintJoinList(GetSortedJoins(analogs));
 
-            Debug.Console(0, "Serials:");
+            CrestronConsole.ConsoleCommandResponse("Serials:");
             var serials = Joins.Where(j => (j.Value.JoinType & eJoinType.Serial) == eJoinType.Serial).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Serial Joins", serials.Count);
+            CrestronConsole.ConsoleCommandResponse("Found {0} Serial Joins", serials.Count);
             PrintJoinList(GetSortedJoins(serials));
 
         }
@@ -136,7 +139,7 @@ namespace PepperDash.Essentials.Core
         {
             foreach (var join in joins)
             {
-                Debug.Console(0,
+                CrestronConsole.ConsoleCommandResponse(
                     @"Join Number: {0} | Label: '{1}' | JoinSpan: '{2}' | Type: '{3}' | Capabilities: '{4}'",
                         join.Value.JoinNumber,
                         join.Value.Label,
@@ -193,19 +196,6 @@ namespace PepperDash.Essentials.Core
 
         protected void AddJoins(Type type)
         {
-            // Add all the JoinDataComplete properties to the Joins Dictionary and pass in the offset 
-            //Joins = this.GetType()
-            //    .GetCType()
-            //    .GetFields(BindingFlags.Public | BindingFlags.Instance)
-            //    .Where(field => field.IsDefined(typeof(JoinNameAttribute), true))
-            //    .Select(field => (JoinDataComplete)field.GetValue(this))
-            //    .ToDictionary(join => join.GetNameAttribute(), join =>
-            //        {
-            //            join.SetJoinOffset(_joinOffset);
-            //            return join;
-            //        });
-
-            //type = this.GetType(); <- this wasn't working because 'this' was always the base class, never the derived class
             var fields =
                 type.GetCType()
                     .GetFields(BindingFlags.Public | BindingFlags.Instance)
@@ -219,7 +209,7 @@ namespace PepperDash.Essentials.Core
 
                 if (value == null)
                 {
-                    Debug.Console(0, "Unable to caset base class to {0}", type.Name);
+                    Debug.Console(0, "Unable to cast base class to {0}", type.Name);
                     continue;
                 }
 
@@ -244,23 +234,69 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public void PrintJoinMapInfo()
         {
-            Debug.Console(0, "{0}:\n", GetType().Name);
+            var sb = JoinmapStringBuilder();
+
+            CrestronConsole.ConsoleCommandResponse(sb.ToString());
+        }
+
+        private StringBuilder JoinmapStringBuilder()
+        {
+            var sb = new StringBuilder();
 
             // Get the joins of each type and print them
-            Debug.Console(0, "Digitals:");
+            sb.AppendLine(String.Format("# {0}", GetType().Name));
-            var digitals = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Digital) == eJoinType.Digital).ToDictionary(j => j.Key, j => j.Value);
+            sb.AppendLine();
-            Debug.Console(2, "Found {0} Digital Joins", digitals.Count);
+            sb.AppendLine("## Digitals");
-            PrintJoinList(GetSortedJoins(digitals));
+            sb.AppendLine();
+            // Get the joins of each type and print them
+            var digitals =
+                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Digital) == eJoinType.Digital)
+                    .ToDictionary(j => j.Key, j => j.Value);
+            var digitalSb = AppendJoinList(GetSortedJoins(digitals));
+            digitalSb.AppendLine("## Analogs");
+            digitalSb.AppendLine();
 
-            Debug.Console(0, "Analogs:");
+            var analogs =
-            var analogs = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Analog) == eJoinType.Analog).ToDictionary(j => j.Key, j => j.Value);
+                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Analog) == eJoinType.Analog)
-            Debug.Console(2, "Found {0} Analog Joins", analogs.Count);
+                    .ToDictionary(j => j.Key, j => j.Value);
-            PrintJoinList(GetSortedJoins(analogs));
+            var analogSb = AppendJoinList(GetSortedJoins(analogs));
+            analogSb.AppendLine("## Serials");
+            analogSb.AppendLine();
 
-            Debug.Console(0, "Serials:");
+            var serials =
-            var serials = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Serial) == eJoinType.Serial).ToDictionary(j => j.Key, j => j.Value);
+                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Serial) == eJoinType.Serial)
-            Debug.Console(2, "Found {0} Serial Joins", serials.Count);
+                    .ToDictionary(j => j.Key, j => j.Value);
-            PrintJoinList(GetSortedJoins(serials));
+            var serialSb = AppendJoinList(GetSortedJoins(serials));
+
+            sb.EnsureCapacity(sb.Length + digitalSb.Length + analogSb.Length + serialSb.Length);
+            sb.Append(digitalSb).Append(analogSb).Append(serialSb);
+            return sb;
+        }
+
+        /// <summary>
+        /// Prints the join information to console
+        /// </summary>
+        public void MarkdownJoinMapInfo(string deviceKey, string bridgeKey)
+        {
+            var pluginType = GetType().Name;
+
+            CrestronConsole.ConsoleCommandResponse("{0}:\n", pluginType);
+
+
+
+            WriteJoinmapMarkdown(JoinmapStringBuilder(), pluginType, bridgeKey, deviceKey);
+
+        }
+
+        private static void WriteJoinmapMarkdown(StringBuilder stringBuilder, string pluginType, string bridgeKey, string deviceKey)
+        {
+            var fileName = String.Format("{0}{1}{2}__{3}__{4}.md", Global.FilePathPrefix, "joinMaps/", pluginType, bridgeKey, deviceKey);
+
+            using (var sw = new StreamWriter(fileName))
+            {
+                sw.WriteLine(stringBuilder.ToString());
+                CrestronConsole.ConsoleCommandResponse("Joinmap Readme generated and written to {0}", fileName);
+            }
 
         }
 
@@ -269,7 +305,7 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         /// <param name="joins"></param>
         /// <returns></returns>
-        List<KeyValuePair<string, JoinDataComplete>> GetSortedJoins(Dictionary<string, JoinDataComplete> joins)
+        static List<KeyValuePair<string, JoinDataComplete>> GetSortedJoins(Dictionary<string, JoinDataComplete> joins)
         {
             var sortedJoins = joins.ToList();
 
@@ -278,19 +314,38 @@ namespace PepperDash.Essentials.Core
             return sortedJoins;
         }
 
-        void PrintJoinList(List<KeyValuePair<string, JoinDataComplete>> joins)
+
+        static StringBuilder AppendJoinList(List<KeyValuePair<string, JoinDataComplete>> joins)
         {
+            var sb = new StringBuilder();
+            const string stringFormatter = "| {0} | {1} | {2} | {3} | {4} |";
+            const int joinNumberLen = 11;
+            const int joinSpanLen = 9;
+            const int typeLen = 19;
+            const int capabilitiesLen = 12;
+            var descriptionLen = (from @join in joins select @join.Value into j select j.Metadata.Description.Length).Concat(new[] {11}).Max();
+
+            //build header
+            sb.AppendLine(String.Format(stringFormatter, 
+                String.Format("Join Number").PadRight(joinNumberLen, ' '), 
+                String.Format("Join Span").PadRight(joinSpanLen, ' '), 
+                String.Format("Description").PadRight(descriptionLen, ' '), 
+                String.Format("Type").PadRight(typeLen, ' '),
+                 String.Format("Capabilities").PadRight(capabilitiesLen, ' ')));
+            //build table seperator
+            sb.AppendLine(String.Format(stringFormatter,
+                new String('-', joinNumberLen),
+                new String('-', joinSpanLen),
+                new String('-', descriptionLen),
+                new String('-', typeLen),
+                new String('-', capabilitiesLen)));
+
             foreach (var join in joins)
             {
-                Debug.Console(0,
+                sb.AppendLine(join.Value.GetMarkdownFormattedData(stringFormatter, descriptionLen));
-                    @"Join Number: {0} | JoinSpan: '{1}' | JoinName: {2} | Description: '{3}' | Type: '{4}' | Capabilities: '{5}'",
-                        join.Value.JoinNumber,
-                        join.Value.JoinSpan,
-                        join.Key,
-                        String.IsNullOrEmpty(join.Value.AttributeName) ? join.Value.Metadata.Label : join.Value.AttributeName,
-                        join.Value.Metadata.JoinType.ToString(),
-                        join.Value.Metadata.JoinCapabilities.ToString());
             }
+            sb.AppendLine();
+            return sb;
         }
 
         /// <summary>
@@ -459,6 +514,64 @@ namespace PepperDash.Essentials.Core
             Metadata = metadata;
         }
 
+        public string GetMarkdownFormattedData(string stringFormatter, int descriptionLen)
+        {
+
+            //Fixed Width Headers
+            var joinNumberLen = String.Format("Join Number").Length;
+            var joinSpanLen = String.Format("Join Span").Length;
+            var typeLen = String.Format("AnalogDigitalSerial").Length;
+            var capabilitiesLen = String.Format("ToFromFusion").Length;
+
+            //Track which one failed, if it did
+            const string placeholder = "unknown";
+            var dataArray = new Dictionary<string, string>
+            {
+                {"joinNumber", placeholder.PadRight(joinNumberLen, ' ')},
+                {"joinSpan", placeholder.PadRight(joinSpanLen, ' ')},
+                {"description", placeholder.PadRight(descriptionLen, ' ')},
+                {"joinType", placeholder.PadRight(typeLen, ' ')},
+                {"capabilities", placeholder.PadRight(capabilitiesLen, ' ')}
+            };
+
+
+            try
+            {
+                dataArray["joinNumber"] = String.Format("{0}", JoinNumber.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinNumberLen, ' ');
+                dataArray["joinSpan"] = String.Format("{0}", JoinSpan.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinSpanLen, ' ');
+                dataArray["description"] = String.Format("{0}", Metadata.Description.ReplaceIfNullOrEmpty(placeholder)).PadRight(descriptionLen, ' ');
+                dataArray["joinType"] = String.Format("{0}", Metadata.JoinType.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(typeLen, ' ');
+                dataArray["capabilities"] = String.Format("{0}", Metadata.JoinCapabilities.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(capabilitiesLen, ' ');
+
+                return String.Format(stringFormatter,
+                    dataArray["joinNumber"],
+                    dataArray["joinSpan"],
+                    dataArray["description"],
+                    dataArray["joinType"],
+                    dataArray["capabilities"]);
+
+            }
+            catch (Exception e)
+            {
+                //Don't Throw - we don't want to kill the system if this falls over - it's not mission critical. Print the error, use placeholder data
+                var errorKey = string.Empty;
+                foreach (var item in dataArray)
+                {
+                    if (item.Value.TrimEnd() == placeholder) continue;
+                    errorKey = item.Key;
+                    break;
+                }
+                Debug.Console(0, "Unable to decode join metadata {1}- {0}", e.Message, !String.IsNullOrEmpty(errorKey) ? (' ' + errorKey) : String.Empty);
+                return String.Format(stringFormatter,
+                    dataArray["joinNumber"],
+                    dataArray["joinSpan"],
+                    dataArray["description"],
+                    dataArray["joinType"],
+                    dataArray["capabilities"]);
+            }
+        }
+
+
         /// <summary>
         /// Sets the join offset value
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Monitoring/SystemMonitorController.cs

@@ -43,6 +43,19 @@ namespace PepperDash.Essentials.Core.Monitoring
         public StringFeedback UptimeFeedback { get; set; }
         public StringFeedback LastStartFeedback { get; set; }
 
+		public BoolFeedback IsApplianceFeedback { get; protected set; }
+	    private bool _isApplianceFb
+	    {
+			get { return CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance; }
+	    }
+
+		public BoolFeedback IsServerFeedback { get; protected set; }
+	    private bool _isServerFb
+	    {
+			get { return CrestronEnvironment.DevicePlatform == eDevicePlatform.Server; }
+	    }
+
+
 	    public SystemMonitorController(string key)
             : base(key)
         {
@@ -63,6 +76,9 @@ namespace PepperDash.Essentials.Core.Monitoring
             UptimeFeedback = new StringFeedback(() => _uptime);
             LastStartFeedback = new StringFeedback(()=> _lastStart);
 
+			IsApplianceFeedback = new BoolFeedback(() => _isApplianceFb);
+			IsServerFeedback = new BoolFeedback(() => _isServerFb);
+
             ProgramStatusFeedbackCollection = new Dictionary<uint, ProgramStatusFeedbacks>();
 
             foreach (var prog in SystemMonitor.ProgramCollection)
@@ -123,6 +139,26 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptime = uptimeRaw.Substring(forIndex + 4);
         }
 
+	    private static void ProcessorReboot()
+	    {
+		    if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+
+		    var response = string.Empty;
+		    CrestronConsole.SendControlSystemCommand("reboot", ref response);
+	    }
+
+		private static void ProgramReset(uint index)
+		{
+			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+
+			if (index <= 0 || index > 10) return;
+
+			var cmd = string.Format("progreset -p:{0}", index);
+
+			var response = string.Empty;
+			CrestronConsole.SendControlSystemCommand(cmd, ref response);
+		}
+
         private void CrestronEnvironmentOnEthernetEventHandler(EthernetEventArgs ethernetEventArgs)
         {
             if (ethernetEventArgs.EthernetEventType != eEthernetEventType.LinkUp) return;
@@ -185,6 +221,9 @@ namespace PepperDash.Essentials.Core.Monitoring
             SerialNumberFeedback.FireUpdate();
             ModelFeedback.FireUpdate();
 
+			IsApplianceFeedback.FireUpdate();
+			IsServerFeedback.FireUpdate();
+
             OnSystemMonitorPropertiesChanged();
         }
 
@@ -237,6 +276,11 @@ namespace PepperDash.Essentials.Core.Monitoring
             UptimeFeedback.LinkInputSig(trilist.StringInput[joinMap.Uptime.JoinNumber]);
             LastStartFeedback.LinkInputSig(trilist.StringInput[joinMap.LastBoot.JoinNumber]);
 
+	        trilist.SetSigHeldAction(joinMap.ProcessorReboot.JoinNumber, 10000, ProcessorReboot);
+
+			IsApplianceFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsAppliance.JoinNumber]);
+			IsServerFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsServer.JoinNumber]);
+
             // iterate the program status feedback collection and map all the joins
             LinkProgramInfoJoins(this, trilist, joinMap);
 
@@ -301,6 +345,8 @@ namespace PepperDash.Essentials.Core.Monitoring
                 p.Value.AggregatedProgramInfoFeedback.LinkInputSig(
                     trilist.StringInput[programSlotJoinStart + joinMap.AggregatedProgramInfo.JoinNumber]);
 
+				trilist.SetSigHeldAction(programSlotJoinStart + joinMap.ProgramReset.JoinNumber, 10000, () => ProgramReset(programNumber));
+
                 programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin.JoinSpan;
             }
         }	    

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -92,6 +92,10 @@
       <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="SimplSharpCWSHelperInterface, Version=2.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCWSHelperInterface.dll</HintPath>
+    </Reference>
     <Reference Include="SimplSharpHelperInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
@@ -123,6 +127,8 @@
     <Compile Include="Bridges\IBridge.cs" />
     <Compile Include="Bridges\JoinMaps\AirMediaControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\AppleTvJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IAnalogInputJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IDigitalOutputJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\PduJoinMapBase.cs" />
     <Compile Include="Bridges\JoinMaps\C2nRthsControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\CameraControllerJoinMap.cs" />
@@ -179,16 +185,40 @@
     <Compile Include="Crestron IO\Cards\InternalCardCageController.cs" />
     <Compile Include="Crestron IO\DinCenCn\DinCenCnController.cs" />
     <Compile Include="Crestron IO\DinCenCn\IHasCresnetBranches.cs" />
+    <Compile Include="Crestron IO\DinIo8\DinIo8Controller.cs" />
     <Compile Include="Crestron IO\Inputs\CenIoDigIn104Controller.cs" />
+    <Compile Include="Crestron IO\Inputs\GenericVersiportAnalogInputDevice.cs" />
     <Compile Include="Crestron IO\Inputs\GenericDigitalInputDevice.cs" />
     <Compile Include="Crestron IO\Inputs\GenericVersiportInputDevice.cs" />
+    <Compile Include="Crestron IO\Inputs\IAnalogInput.cs" />
     <Compile Include="Crestron IO\Inputs\IDigitalInput.cs" />
     <Compile Include="Crestron IO\IOPortConfig.cs" />
     <Compile Include="Crestron IO\Ir\CenIoIr104Controller.cs" />
+    <Compile Include="Crestron IO\Outputs\GenericVersiportOutputDevice.cs" />
+    <Compile Include="Crestron IO\Outputs\IDigitalOutput.cs" />
     <Compile Include="Crestron IO\Relay\CenIoRy104Controller.cs" />
     <Compile Include="Crestron IO\Relay\GenericRelayDevice.cs" />
     <Compile Include="Crestron IO\Relay\ISwitchedOutput.cs" />
     <Compile Include="Crestron IO\StatusSign\StatusSignController.cs" />
+    <Compile Include="Devices\PowerInterfaces.cs" />
+    <Compile Include="Web\RequestHandlers\AppDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetFeedbacksForDeviceRequestHandler.cs" />
+    <Compile Include="Web\EssentialsWebApiHelpers.cs" />
+    <Compile Include="Web\RequestHandlers\GetTypesByFilterRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetJoinMapForDeviceKeyRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DefaultRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevListRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevPropsRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevJsonRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\SetDeviceStreamDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DisableAllStreamDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\ShowConfigRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetTypesRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetJoinMapForBridgeKeyRequestHandler.cs" />
+    <Compile Include="Web\EssemtialsWebApi.cs" />
+    <Compile Include="Web\EssentialsWebApiFactory.cs" />
+    <Compile Include="Web\EssentialsWebApiPropertiesConfig.cs" />
+    <Compile Include="Web\RequestHandlers\ReportVersionsRequestHandler.cs" />
     <Compile Include="Device Info\DeviceInfo.cs" />
     <Compile Include="Device Info\DeviceInfoEventArgs.cs" />
     <Compile Include="Device Info\IDeviceInfoProvider.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj.DotSettings

@@ -0,0 +1,3 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Crestron_0020Web_0020Server/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Web/@EntryIndexedValue">False</s:Boolean></wpf:ResourceDictionary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Plugins/PluginLoader.cs

@@ -194,13 +194,13 @@ namespace PepperDash.Essentials
         /// <param name="command"></param>
         public static void ReportAssemblyVersions(string command)
         {
-            Debug.Console(0, "Loaded Assemblies:");
+
+            CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
             foreach (var assembly in LoadedAssemblies)
             {
-                Debug.Console(0, "{0} Version: {1}", assembly.Name, assembly.Version);
+                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
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/GenericQueue.cs

@@ -1,5 +1,6 @@
 using System;
 using Crestron.SimplSharp;
+using Crestron.SimplSharp.Reflection;
 using Crestron.SimplSharpPro.CrestronThread;
 using PepperDash.Core;
 
@@ -187,9 +188,20 @@ namespace PepperDash.Essentials.Core.Queues
                         if (_delayEnabled)
                             Thread.Sleep(_delayTime);
                     }
+                    catch (System.Threading.ThreadAbortException)
+                    {
+                        //swallowing this exception, as it should only happen on shut down
+                    }
                     catch (Exception ex)
                     {
-                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}\r{1}\r{2}", ex.Message, ex.InnerException, ex.StackTrace);
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue: {1}:{0}", ex.Message, ex);
+                        Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.StackTrace);
+
+                        if (ex.InnerException != null)
+                        {
+                            Debug.Console(0, this, Debug.ErrorLogLevel.Error, "---\r\n{0}", ex.InnerException.Message);
+                            Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.InnerException.StackTrace);
+                        }
                     }
                 }
                 else _waitHandle.Wait();
@@ -202,7 +214,7 @@ namespace PepperDash.Essentials.Core.Queues
         {
             if (Disposed)
             {
-                Debug.Console(1, this, "I've been disposed so you can't enqueue any messages.  Are you trying to dispatch a message while the program is stopping?");
+                Debug.Console(1, this, "Queue has been disposed. Enqueuing messages not allowed while program is stopping.");
                 return;
             }
 
@@ -446,7 +458,14 @@ namespace PepperDash_Essentials_Core.Queues
                     }
                     catch (Exception ex)
                     {
-                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}\r{1}\r{2}", ex.Message, ex.InnerException, ex.StackTrace);
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}", ex.Message);
+                        Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.StackTrace);
+
+                        if (ex.InnerException != null)
+                        {
+                            Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}", ex.InnerException.Message);
+                            Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.InnerException.StackTrace);
+                        }
                     }
                 }
                 else _waitHandle.Wait();

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/EssentialsRoomBase.cs

@@ -343,7 +343,7 @@ namespace PepperDash.Essentials.Core
 
         void RoomIsOccupiedFeedback_OutputChange(object sender, EventArgs e)
         {
-            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false)
+            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false  && AllowVacancyTimerToStart())
             {
                 Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Notice: Vacancy Detected");
                 // Trigger the timer when the room is vacant
@@ -362,6 +362,15 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         /// <param name="o"></param>
         public abstract void RoomVacatedForTimeoutPeriod(object o);
+
+        /// <summary>
+        /// Allow the vacancy event from an occupancy sensor to turn the room off.
+        /// </summary>
+        /// <returns>If the timer should be allowed. Defaults to true</returns>
+        protected virtual bool AllowVacancyTimerToStart()
+        {
+            return true;
+        }
     }
         
     /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Secrets/SecretsManager.cs

@@ -148,6 +148,7 @@ namespace PepperDash.Essentials.Core
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, "Secrets provider '{0}' added to SecretsManager", key);
+                return;
             }
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Unable to add Provider '{0}' to Secrets.  Provider with that key already exists", key );
         }
@@ -164,13 +165,13 @@ namespace PepperDash.Essentials.Core
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, "Secrets provider '{0}' added to SecretsManager", key);
-
+                return;
             }
             if (overwrite)
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, Debug.ErrorLogLevel.Notice, "Provider with the key '{0}' already exists in secrets.  Overwriting with new secrets provider.", key);
-
+                return;
             }
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Unable to add Provider '{0}' to Secrets.  Provider with that key already exists", key);
         }

essentials-framework/Essentials Core/PepperDashEssentialsBase/UI/TouchpanelBase.cs

@@ -31,7 +31,7 @@ namespace PepperDash.Essentials.Core.UI
             :base(key, name)
         {
 
-            if (Panel == null)
+            if (panel == null)
             {
                 Debug.Console(0, this, "Panel is not valid. Touchpanel class WILL NOT work correctly");
                 return;
@@ -71,6 +71,8 @@ namespace PepperDash.Essentials.Core.UI
                         return;
                     }
                 }
+
+                Panel.LoadSmartObjects(sgdName);
             });
 
             AddPostActivationAction(() =>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssemtialsWebApi.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+using PepperDash.Core.Web;
+using PepperDash.Essentials.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssemtialsWebApi : EssentialsDevice
+	{
+		private readonly WebApiServer _server;
+
+		///<example>
+		/// http(s)://{ipaddress}/cws/{basePath}
+		/// http(s)://{ipaddress}/VirtualControl/Rooms/{roomId}/cws/{basePath}
+		/// </example>
+		private readonly string _defaultBasePath = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance 
+			? string.Format("/app{0:00}/api", InitialParametersClass.ApplicationNumber) 
+			: "/api";
+
+		private const int DebugTrace = 0;
+		private const int DebugInfo = 1;
+		private const int DebugVerbose = 2;
+
+		/// <summary>
+		/// CWS base path
+		/// </summary>
+		public string BasePath { get; private set; }
+
+		/// <summary>
+		/// Tracks if CWS is registered
+		/// </summary>
+		public bool IsRegistered
+		{
+			get { return _server.IsRegistered; }
+		}
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>		
+		public EssemtialsWebApi(string key, string name)
+			: this(key, name, null)
+		{
+		}
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="config"></param>
+		public EssemtialsWebApi(string key, string name, EssentialsWebApiPropertiesConfig config)
+			: base(key, name)
+		{
+			Key = key;
+
+			if (config == null)
+				BasePath = _defaultBasePath;
+			else
+				BasePath = string.IsNullOrEmpty(config.BasePath) ? _defaultBasePath : config.BasePath;
+
+			_server = new WebApiServer(Key, Name, BasePath);
+		}
+
+		/// <summary>
+		/// Custom activate, add routes
+		/// </summary>
+		/// <returns></returns>
+		public override bool CustomActivate()
+		{
+			var routes = new List<HttpCwsRoute>
+			{
+				new HttpCwsRoute("reportversions")
+				{
+					Name = "ReportVersions",
+					RouteHandler = new ReportVersionsRequestHandler()
+				},
+				new HttpCwsRoute("appdebug")
+				{
+					Name = "AppDebug",
+					RouteHandler = new AppDebugRequestHandler()
+				},
+				new HttpCwsRoute("devlist")
+				{
+					Name = "DevList",
+					RouteHandler = new DevListRequestHandler()
+				},
+				new HttpCwsRoute("devprops")
+				{
+					Name = "DevProps",
+					RouteHandler = new DevPropsRequestHandler()
+				},
+				new HttpCwsRoute("devjson")
+				{
+					Name = "DevJson",
+					RouteHandler = new DevJsonRequestHandler()
+				},
+				new HttpCwsRoute("setdevicestreamdebug")
+				{
+				    Name = "SetDeviceStreamDebug",
+				    RouteHandler = new SetDeviceStreamDebugRequestHandler()
+				},
+				new HttpCwsRoute("disableallstreamdebug")
+				{
+					Name = "DisableAllStreamDebug",
+					RouteHandler = new DisableAllStreamDebugRequestHandler()
+				},
+				new HttpCwsRoute("showconfig")
+				{
+					Name = "ShowConfig",
+					RouteHandler = new ShowConfigRequestHandler()
+				},
+				new HttpCwsRoute("gettypes")
+				{
+					Name = "GetTypes",
+					RouteHandler = new GetTypesRequestHandler()
+				},
+				new HttpCwsRoute("gettypes/{filter}")
+				{
+					Name = "GetTypesByFilter",
+					RouteHandler = new GetTypesByFilterRequestHandler()
+				},
+				new HttpCwsRoute("getjoinmap/{bridgeKey}")
+				{
+					Name = "GetJoinMapsForBridgeKey",
+					RouteHandler = new GetJoinMapForBridgeKeyRequestHandler()
+				},
+				new HttpCwsRoute("getjoinmap/{bridgeKey}/{deviceKey}")
+				{
+					Name = "GetJoinMapsForDeviceKey",
+					RouteHandler = new GetJoinMapForDeviceKeyRequestHandler()
+				},
+				new HttpCwsRoute("feedbacks/{deviceKey}")
+				{
+					Name = "GetFeedbacksForDeviceKey",
+					RouteHandler = new GetFeedbacksForDeviceRequestHandler()
+				}
+			};
+
+			foreach (var route in routes.Where(route => route != null))
+			{
+				var r = route;
+				_server.AddRoute(r);
+			}
+
+			return base.CustomActivate();
+		}
+
+		/// <summary>
+		/// Initializes the CWS class
+		/// </summary>
+		public override void Initialize()
+		{
+			// If running on an appliance
+			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance)
+			{
+				/*
+					WEBSERVER [ON | OFF | TIMEOUT <VALUE IN SECONDS> | MAXSESSIONSPERUSER <Number of sessions>]
+				*/
+				var response = string.Empty;
+				CrestronConsole.SendControlSystemCommand("webserver", ref response);
+				if (response.Contains("OFF")) return;
+
+				var is4Series = eCrestronSeries.Series4 == (Global.ProcessorSeries & eCrestronSeries.Series4);
+				Debug.Console(DebugTrace, Debug.ErrorLogLevel.Notice, "Starting Essentials Web API on {0} Appliance", is4Series ? "4-series" : "3-series");
+
+				_server.Start();
+
+				GetPaths();
+
+				return;
+			}
+
+			// Automatically start CWS when running on a server (Linux OS, Virtual Control)
+			Debug.Console(DebugTrace, Debug.ErrorLogLevel.Notice, "Starting Essentials Web API on Virtual Control Server");
+
+			_server.Start();
+
+			GetPaths();
+		}
+
+		/// <summary>
+		/// Print the available pahts
+		/// </summary>
+		/// <example>
+		/// http(s)://{ipaddress}/cws/{basePath}
+		/// http(s)://{ipaddress}/VirtualControl/Rooms/{roomId}/cws/{basePath}
+		/// </example>
+		public void GetPaths()
+		{
+			Debug.Console(DebugTrace, this, "{0}", 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 
+				? string.Format("http(s)://{0}/VirtualControl/Rooms/{1}/cws{2}", hostname, InitialParametersClass.RoomId, BasePath)
+				: string.Format("http(s)://{0}/cws{1}", currentIp, BasePath);
+			
+			Debug.Console(DebugTrace, this, "Server:{0}", path);
+
+			var routeCollection = _server.GetRouteCollection();
+			if (routeCollection == null)
+			{
+				Debug.Console(DebugTrace, this, "Server route collection is null");
+				return;
+			}
+			Debug.Console(DebugTrace, this, "Configured Routes:");
+			foreach (var route in routeCollection)
+			{
+				Debug.Console(DebugTrace, this, "{0}: {1}/{2}", route.Name, path, route.Url);
+			}
+			Debug.Console(DebugTrace, this, "{0}", new String('-', 50));
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiFactory.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiFactory : EssentialsDeviceFactory<EssemtialsWebApi>
+	{
+		public EssentialsWebApiFactory()
+		{
+			TypeNames = new List<string> { "EssentialsWebApi" };
+		}
+
+		public override EssentialsDevice BuildDevice(DeviceConfig dc)
+		{
+			Debug.Console(1, "Factory Attempting to create new Essentials Web API Server");
+
+			var props = dc.Properties.ToObject<EssentialsWebApiPropertiesConfig>();
+			if (props != null) return new EssemtialsWebApi(dc.Key, dc.Name, props);
+
+			Debug.Console(1, "Factory failed to create new Essentials Web API Server");
+			return null;
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiHelpers.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiHelpers
+	{
+		public static string GetRequestBody(HttpCwsRequest request)
+		{
+			var bytes = new Byte[request.ContentLength];
+
+			request.InputStream.Read(bytes, 0, request.ContentLength);
+
+			return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+		}
+
+		public static object MapToAssemblyObject(LoadedAssembly assembly)
+		{
+			return new
+			{
+				Name = assembly.Name,
+				Version = assembly.Version
+			};
+		}
+
+		public static object MapToDeviceListObject(IKeyed device)
+		{
+			return new
+			{
+				Key = device.Key,
+				Name = (device is IKeyName)
+					? (device as IKeyName).Name
+					: "---"
+			};
+		}
+
+		public static object MapJoinToObject(string key, JoinMapBaseAdvanced join)
+		{
+			var kp = new KeyValuePair<string, JoinMapBaseAdvanced>(key, join);
+
+			return MapJoinToObject(kp);
+		}
+
+		public static object MapJoinToObject(KeyValuePair<string, JoinMapBaseAdvanced> join)
+		{
+			return new
+			{
+				DeviceKey = join.Key,
+				Joins = join.Value.Joins.Select(j => MapJoinDataCompleteToObject(j))
+			};
+		}
+
+		public static object MapJoinDataCompleteToObject(KeyValuePair<string, JoinDataComplete> joinData)
+		{
+			return new
+			{
+				Signal = joinData.Key,
+				Description = joinData.Value.Metadata.Description,
+				JoinNumber = joinData.Value.JoinNumber,
+				JoinSpan = joinData.Value.JoinSpan,
+				JoinType = joinData.Value.Metadata.JoinType.ToString(),
+				JoinCapabilities = joinData.Value.Metadata.JoinCapabilities.ToString()
+			};
+		}
+
+		public static object MapDeviceTypeToObject(string key, DeviceFactoryWrapper device)
+		{
+			var kp = new KeyValuePair<string, DeviceFactoryWrapper>(key, device);
+
+			return MapDeviceTypeToObject(kp);
+		}
+
+		public static object MapDeviceTypeToObject(KeyValuePair<string, DeviceFactoryWrapper> device)
+		{
+			return new
+			{
+				Type = device.Key,
+				Description = device.Value.Description,
+				CType = device.Value.CType == null ? "---": device.Value.CType.ToString()
+			};
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiPropertiesConfig.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiPropertiesConfig
+	{
+		[JsonProperty("basePath")]
+		public string BasePath { get; set; }
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/AppDebugRequestHandler.cs

@@ -0,0 +1,82 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class AppDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>		
+		public AppDebugRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var appDebug = new AppDebug { Level = Debug.Level };
+
+			var body = JsonConvert.SerializeObject(appDebug, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.Write(body, false);
+			context.Response.End();
+		}
+		
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var appDebug = new AppDebug();
+			var requestBody = JsonConvert.DeserializeAnonymousType(data, appDebug);
+
+			Debug.SetDebugLevel(requestBody.Level);
+
+			appDebug.Level = Debug.Level;
+			var responseBody = JsonConvert.SerializeObject(appDebug, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.Write(responseBody, false);
+			context.Response.End();
+		}
+	}
+
+	public class AppDebug
+	{
+		[JsonProperty("level", NullValueHandling = NullValueHandling.Ignore)]
+		public int Level { get; set; }
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DefaultRequestHandler.cs

@@ -0,0 +1,118 @@
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DefaultRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>		
+		public DefaultRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles CONNECT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleConnect(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles DELETE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleDelete(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles HEAD method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleHead(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles OPTIONS method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleOptions(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PATCH method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePatch(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PUT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePut(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles TRACE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleTrace(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevJsonRequestHandler.cs

@@ -0,0 +1,66 @@
+using System;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevJsonRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevJsonRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+			
+			try
+			{
+				DeviceJsonApi.DoDeviceActionWithJson(data);
+
+				context.Response.StatusCode = 200;
+				context.Response.StatusDescription = "OK";
+				context.Response.End();
+			}
+			catch (Exception ex)
+			{
+				Debug.Console(1, "Exception Message: {0}", ex.Message);
+				Debug.Console(2, "Exception Stack Trace: {0}", ex.StackTrace);
+				if(ex.InnerException != null) Debug.Console(2, "Exception Inner: {0}", ex.InnerException);
+
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+			}
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevListRequestHandler.cs

@@ -0,0 +1,51 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevListRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevListRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var allDevices = DeviceManager.AllDevices;
+			if (allDevices == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			allDevices.Sort((a, b) => System.String.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
+
+			var deviceList = allDevices.Select(d => EssentialsWebApiHelpers.MapToDeviceListObject(d)).ToList();
+
+			var js = JsonConvert.SerializeObject(deviceList, Formatting.Indented);			
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevPropsRequestHandler.cs

@@ -0,0 +1,76 @@
+using System.Text;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevPropsRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevPropsRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var o = new DeviceActionWrapper();
+			var body = JsonConvert.DeserializeAnonymousType(data, o);			
+			
+			if (string.IsNullOrEmpty(body.DeviceKey))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceProps = DeviceJsonApi.GetProperties(body.DeviceKey);
+			if (deviceProps == null || deviceProps.ToLower().Contains("no device"))
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";			
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = Encoding.UTF8;
+			context.Response.Write(deviceProps, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DisableAllStreamDebugRequestHandler.cs

@@ -0,0 +1,32 @@
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DisableAllStreamDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DisableAllStreamDebugRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			DeviceManager.DisableAllDeviceStreamDebugging();
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetFeedbacksForDeviceRequestHandler.cs

@@ -0,0 +1,102 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetFeedbacksForDeviceRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetFeedbacksForDeviceRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object deviceObj;
+			if (!routeData.Values.TryGetValue("deviceKey", out deviceObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+
+			var device = DeviceManager.GetDeviceForKey(deviceObj.ToString()) as IHasFeedback;
+			if (device == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var boolFeedback =
+				from feedback in device.Feedbacks.OfType<BoolFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.BoolValue
+				};
+
+			var intFeedback =
+				from feedback in device.Feedbacks.OfType<IntFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.IntValue
+				};
+
+			var stringFeedback = 
+				from feedback in device.Feedbacks.OfType<StringFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.StringValue ?? string.Empty
+				};
+
+			var responseObj = new
+			{
+				BoolValues = boolFeedback,
+				IntValues = intFeedback,
+				SerialValues = stringFeedback
+			};
+
+			var js = JsonConvert.SerializeObject(responseObj, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetJoinMapForBridgeKeyRequestHandler.cs

@@ -0,0 +1,78 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetJoinMapForBridgeKeyRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetJoinMapForBridgeKeyRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object bridgeObj;			
+			if (!routeData.Values.TryGetValue("bridgeKey", out bridgeObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var bridge = DeviceManager.GetDeviceForKey(bridgeObj.ToString()) as EiscApiAdvanced;
+			if (bridge == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var joinMap = bridge.JoinMaps.Select(j => EssentialsWebApiHelpers.MapJoinToObject(j)).ToList();			
+			if (joinMap == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var js = JsonConvert.SerializeObject(joinMap, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}		
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetJoinMapForDeviceKeyRequestHandler.cs

@@ -0,0 +1,95 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetJoinMapForDeviceKeyRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetJoinMapForDeviceKeyRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object bridgeObj;
+			if (!routeData.Values.TryGetValue("bridgeKey", out bridgeObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object deviceObj;
+			if (!routeData.Values.TryGetValue("deviceKey", out deviceObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var bridge = DeviceManager.GetDeviceForKey(bridgeObj.ToString()) as EiscApiAdvanced;
+			if (bridge == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			JoinMapBaseAdvanced deviceJoinMap;
+			if (!bridge.JoinMaps.TryGetValue(deviceObj.ToString(), out deviceJoinMap))
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var joinMap = EssentialsWebApiHelpers.MapJoinToObject(deviceObj.ToString(), deviceJoinMap);
+			var js = JsonConvert.SerializeObject(joinMap, Formatting.Indented, new JsonSerializerSettings
+			{
+				ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
+				NullValueHandling = NullValueHandling.Ignore,
+				MissingMemberHandling = MissingMemberHandling.Ignore,
+				DefaultValueHandling = DefaultValueHandling.Ignore,
+				TypeNameHandling = TypeNameHandling.None
+			});
+			
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetTypesByFilterRequestHandler.cs

@@ -0,0 +1,68 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetTypesByFilterRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetTypesByFilterRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object filterObj;
+			if (!routeData.Values.TryGetValue("filter", out filterObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceFactory = DeviceFactory.GetDeviceFactoryDictionary(filterObj.ToString());
+			if (deviceFactory == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceTypes = deviceFactory.Select(t => EssentialsWebApiHelpers.MapDeviceTypeToObject(t)).ToList();
+			var js = JsonConvert.SerializeObject(deviceTypes, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetTypesRequestHandler.cs

@@ -0,0 +1,58 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetTypesRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetTypesRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceFactory = DeviceFactory.GetDeviceFactoryDictionary(null);
+			if (deviceFactory == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceTypes = deviceFactory.Select(t => EssentialsWebApiHelpers.MapDeviceTypeToObject(t)).ToList();
+			var js = JsonConvert.SerializeObject(deviceTypes, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/ReportVersionsRequestHandler.cs

@@ -0,0 +1,49 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class ReportVersionsRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public ReportVersionsRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var loadAssemblies = PluginLoader.LoadedAssemblies;
+			if (loadAssemblies == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var assemblies = loadAssemblies.Select(a => EssentialsWebApiHelpers.MapToAssemblyObject(a)).ToList();
+
+			var js = JsonConvert.SerializeObject(assemblies, Formatting.Indented);
+			
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);			
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/SetDeviceStreamDebugRequestHandler.cs

@@ -0,0 +1,212 @@
+using System;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class SetDeviceStreamDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Handles CONNECT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleConnect(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles DELETE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleDelete(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles HEAD method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleHead(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles OPTIONS method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleOptions(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PATCH method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePatch(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (data == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var config = new SetDeviceStreamDebugConfig();
+			var body = JsonConvert.DeserializeAnonymousType(data, config);
+			if (body == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			if (string.IsNullOrEmpty(body.DeviceKey) || string.IsNullOrEmpty(body.Setting))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var device = DeviceManager.GetDeviceForKey(body.DeviceKey) as IStreamDebugging;
+			if (device == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+			
+			eStreamDebuggingSetting debugSetting;
+			try
+			{
+				debugSetting = (eStreamDebuggingSetting) Enum.Parse(typeof (eStreamDebuggingSetting), body.Setting, true);				
+			}
+			catch (Exception ex)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			try
+			{
+				var mins = Convert.ToUInt32(body.Timeout);
+				if (mins > 0)
+				{
+					device.StreamDebugging.SetDebuggingWithSpecificTimeout(debugSetting, mins);
+				}
+				else
+				{
+					device.StreamDebugging.SetDebuggingWithDefaultTimeout(debugSetting);
+				}
+
+				context.Response.StatusCode = 200;
+				context.Response.StatusDescription = "OK";
+				context.Response.End();
+			}
+			catch (Exception ex)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+			}
+		}
+
+		/// <summary>
+		/// Handles PUT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePut(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles TRACE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleTrace(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+	}
+
+
+	public class SetDeviceStreamDebugConfig
+	{
+		[JsonProperty("deviceKey", NullValueHandling = NullValueHandling.Include)]
+		public string DeviceKey { get; set; }
+
+		[JsonProperty("setting", NullValueHandling = NullValueHandling.Include)]
+		public string Setting { get; set; }
+
+		[JsonProperty("timeout")]
+		public int Timeout { get; set; }
+
+		public SetDeviceStreamDebugConfig()
+		{
+			DeviceKey = null;
+			Setting = null;
+			Timeout = 15;
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/ShowConfigRequestHandler.cs

@@ -0,0 +1,37 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class ShowConfigRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public ShowConfigRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var config = JsonConvert.SerializeObject(ConfigReader.ConfigObject, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(config, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials DM/Essentials_DM/AirMedia/AirMediaController.cs

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM.AirMedia
     [Description("Wrapper class for an AM-200 or AM-300")]
     public class AirMediaController : CrestronGenericBridgeableBaseDevice, IRoutingNumericWithFeedback, IIROutputPorts, IComPorts
     {
-        public AmX00 AirMedia { get; private set; }
+        public Am3x00 AirMedia { get; private set; }
 
         public DeviceConfig DeviceConfig { get; private set; }
 
@@ -44,7 +44,7 @@ namespace PepperDash.Essentials.DM.AirMedia
         public StringFeedback SerialNumberFeedback { get; private set; }
         public BoolFeedback AutomaticInputRoutingEnabledFeedback { get; private set; }
 
-        public AirMediaController(string key, string name, AmX00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
+        public AirMediaController(string key, string name, Am3x00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
             : base(key, name, device)
         {
 
@@ -95,24 +95,31 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             AirMedia.AirMedia.AirMediaChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(AirMedia_AirMediaChange);
 
-            IsInSessionFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.AirMedia.StatusFeedback.UShortValue == 0));
+            IsInSessionFeedback = new BoolFeedback(() => AirMedia.AirMedia.StatusFeedback.UShortValue == 0);
-            ErrorFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.ErrorFeedback.UShortValue));
+            ErrorFeedback = new IntFeedback(() => AirMedia.AirMedia.ErrorFeedback.UShortValue);
-            NumberOfUsersConnectedFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.NumberOfUsersConnectedFeedback.UShortValue));
+            NumberOfUsersConnectedFeedback = new IntFeedback(() => AirMedia.AirMedia.NumberOfUsersConnectedFeedback.UShortValue);
-            LoginCodeFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.LoginCodeFeedback.UShortValue));
+            LoginCodeFeedback = new IntFeedback(() => AirMedia.AirMedia.LoginCodeFeedback.UShortValue);
-            ConnectionAddressFeedback = new StringFeedback(new Func<string>(() => AirMedia.AirMedia.ConnectionAddressFeedback.StringValue));
+            ConnectionAddressFeedback = new StringFeedback(() => AirMedia.AirMedia.ConnectionAddressFeedback.StringValue);
-            HostnameFeedback = new StringFeedback(new Func<string>(() => AirMedia.AirMedia.HostNameFeedback.StringValue));
+            HostnameFeedback = new StringFeedback(() => AirMedia.AirMedia.HostNameFeedback.StringValue);
 
             // TODO: Figure out if we can actually get the TSID/Serial
-            SerialNumberFeedback = new StringFeedback(new Func<string>(() => "unknown"));
+            SerialNumberFeedback = new StringFeedback(() => "unknown");
 
-            AirMedia.DisplayControl.DisplayControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(DisplayControl_DisplayControlChange);
+            AirMedia.DisplayControl.DisplayControlChange += DisplayControl_DisplayControlChange;
 
-            VideoOutFeedback = new IntFeedback(new Func<int>(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback)));
+            VideoOutFeedback = new IntFeedback(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback));
-            AutomaticInputRoutingEnabledFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue));
+            AutomaticInputRoutingEnabledFeedback = new BoolFeedback(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue);
 
-            AirMedia.HdmiIn.StreamChange += new Crestron.SimplSharpPro.DeviceSupport.StreamEventHandler(HdmiIn_StreamChange);
+            // Not all AirMedia versions support HDMI In like the 3200
+            if (AirMedia.HdmiIn != null)
+            {
+                AirMedia.HdmiIn.StreamChange += HdmiIn_StreamChange;
+                HdmiVideoSyncDetectedFeedback = new BoolFeedback(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue);
+                return;
+            }
 
-            HdmiVideoSyncDetectedFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue));
+            // Return false if the AirMedia device doesn't support HDMI Input
+            HdmiVideoSyncDetectedFeedback = new BoolFeedback(() => false);
         }
 
         public override bool CustomActivate()
@@ -122,7 +129,7 @@ namespace PepperDash.Essentials.DM.AirMedia
             else
                 AirMedia.DisplayControl.DisableAutomaticRouting();
 
-            return base.CustomActivate();
+            return true;
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
@@ -179,30 +186,52 @@ namespace PepperDash.Essentials.DM.AirMedia
         /// <param name="e">Arguments defined as IKeyName sender, output, input, and eRoutingSignalType</param>
         private void OnSwitchChange(RoutingNumericEventArgs e)
         {
-            var newEvent = NumericSwitchChange;
+            var handler = NumericSwitchChange;
-            if (newEvent != null) newEvent(this, e);
+
+            if (handler == null) return;
+                
+            handler(this, e);
         }
 
 
         void AirMedia_AirMediaChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
         {
-            if (args.EventId == AirMediaInputSlot.AirMediaStatusFeedbackEventId)
+            switch (args.EventId)
+            {
+                case AirMediaInputSlot.AirMediaStatusFeedbackEventId:
+                    {
                         IsInSessionFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaErrorFeedbackEventId)
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaErrorFeedbackEventId:
+                    {
                         ErrorFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaNumberOfUserConnectedEventId)
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaNumberOfUserConnectedEventId:
+                    {
                         NumberOfUsersConnectedFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaLoginCodeEventId)
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaLoginCodeEventId:
+                    {
                         LoginCodeFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaConnectionAddressFeedbackEventId)
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaConnectionAddressFeedbackEventId:
+                    {
                         ConnectionAddressFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaHostNameFeedbackEventId)
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaHostNameFeedbackEventId:
+                    {
                         HostnameFeedback.FireUpdate();
+                        break;
+                    }
+            }
         }
 
         void DisplayControl_DisplayControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
-        {
-            if (args.EventId == AmX00.VideoOutFeedbackEventId)
         {
                 VideoOutFeedback.FireUpdate();
 
@@ -211,8 +240,7 @@ namespace PepperDash.Essentials.DM.AirMedia
 
                 OnSwitchChange(new RoutingNumericEventArgs(1, VideoOutFeedback.UShortValue, OutputPorts.First(),
                     localInputPort, eRoutingSignalType.AudioVideo));
-            }
+            
-            else if (args.EventId == AmX00.EnableAutomaticRoutingFeedbackEventId)
                 AutomaticInputRoutingEnabledFeedback.FireUpdate();
         }
 
@@ -342,7 +370,7 @@ namespace PepperDash.Essentials.DM.AirMedia
     {
         public AirMediaControllerFactory()
         {
-            TypeNames = new List<string>() { "am200", "am300" };
+            TypeNames = new List<string>() { "am200", "am300", "am3200" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -351,12 +379,26 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             Debug.Console(1, "Factory Attempting to create new AirMedia Device");
 
-            var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(dc.Properties.ToString());
+            var props = dc.Properties.ToObject<AirMediaPropertiesConfig>();
-            AmX00 amDevice = null;
+            Am3x00 amDevice = null;
-            if (type == "am200")
+            switch (type)
-                amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
+            {
-            else if (type == "am300")
+                case "am200" :
-                amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
+                {
+                    amDevice = new Am200(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+                case "am300" :
+                {
+                    amDevice = new Am300(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+                case "am3200" :
+                {
+                    amDevice = new Am3200(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+            }
 
             return new AirMediaController(dc.Key, dc.Name, amDevice, dc, props);
 

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmBladeChassisController.cs

@@ -22,7 +22,7 @@ namespace PepperDash.Essentials.DM
     /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
     /// 
     /// </summary>
-    public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
+	public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitchWithEndpointOnlineFeedback, IRoutingNumericWithFeedback
     {
         private const string NonePortKey = "inputCard0--None";
 

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs

@@ -23,7 +23,7 @@ namespace PepperDash.Essentials.DM
     /// 
     /// </summary>
     [Description("Wrapper class for all DM-MD chassis variants from 8x8 to 32x32")]
-    public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
+    public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitchWithEndpointOnlineFeedback, IRoutingNumericWithFeedback
     {
         private const string NonePortKey = "inputCard0--None";
         public DMChassisPropertiesConfig PropertiesConfig { get; set; }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/Dge100Controller.cs

@@ -17,11 +17,12 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Essentials.Core.DeviceInfo;
+using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.DM.Endpoints.DGEs
 {
     [Description("Wrapper class for DGE-100")]    
-    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider
+    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider, IBridgeAdvanced
     {
         private const int CtpPort = 41795;
         private readonly Dge100 _dge;
@@ -32,8 +33,11 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
         private DeviceConfig _dc;
 
+		public VideoStatusOutputs VideoStatusFeedbacks { get; private set;  }
+
         CrestronTouchpanelPropertiesConfig PropertiesConfig;        
 
+
         public Dge100Controller(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
             :base(key, name, device)
         {
@@ -49,6 +53,18 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             _dc = dc;
 
             PropertiesConfig = props;
+
+            var videoStatusFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () => _dge.HdmiIn.HdcpSupportOnFeedback.BoolValue,
+                VideoResolutionFeedbackFunc = () => _dge.HdmiIn.VideoAttributes.GetVideoResolutionString(),
+                VideoSyncFeedbackFunc = () => _dge.HdmiIn.SyncDetectedFeedback.BoolValue, 
+            };
+
+			VideoStatusFeedbacks = new VideoStatusOutputs(videoStatusFuncs);
+
+			_dge.HdmiIn.StreamChange += (s,a) => VideoStatusFeedbacks.FireAll();
+			_dge.HdmiIn.VideoAttributes.AttributeChange += (o, a) => VideoStatusFeedbacks.FireAll();
         }		
 
         #region IComPorts Members
@@ -187,6 +203,63 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             handler(this, new DeviceInfoEventArgs(DeviceInfo));
         }
 
+        #endregion
+
+        #region IBridgeAdvanced Members
+
+        public void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new DgeJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DgeJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			//Presses
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOn.JoinNumber, () => _dge.HdmiIn.HdcpSupportOn());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOff.JoinNumber,() => _dge.HdmiIn.HdcpSupportOff());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpToggle.JoinNumber, () => {
+				if(_dge.HdmiIn.HdcpSupportOnFeedback.BoolValue)
+				{
+					_dge.HdmiIn.HdcpSupportOff();
+					return;
+				}
+			
+				_dge.HdmiIn.HdcpSupportOn();
+			});
+
+
+			// Feedbacks
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOn.JoinNumber]);
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOff.JoinNumber]);
+
+			VideoStatusFeedbacks.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution.JoinNumber]);
+			VideoStatusFeedbacks.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SyncDetected.JoinNumber]);
+
+			IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+
+			trilist.OnlineStatusChange += (o, a) =>
+			{
+				if (!a.DeviceOnLine) return;
+
+				VideoStatusFeedbacks.FireAll();
+			};
+        }
+
+        
+
         #endregion
     }
 

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/DgeJoinMap.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    public class DgeJoinMap : JoinMapBaseAdvanced
+    {
+        [JoinName("IsOnline")]
+        public JoinDataComplete IsOnline = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Online", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });        
+
+        [JoinName("CurrentInputResolution")]
+        public JoinDataComplete CurrentInputResolution = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Current Input Resolution", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+		[JoinName("SyncDetected")]
+		public JoinDataComplete SyncDetected = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+			new JoinMetadata { Description = "DGE Sync Detected", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOn")]
+        public JoinDataComplete HdmiInHdcpOn = new JoinDataComplete(new JoinData { JoinNumber = 3, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State On", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOff")]
+        public JoinDataComplete HdmiInHdcpOff = new JoinDataComplete(new JoinData { JoinNumber = 4, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Off", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpToggle")]
+        public JoinDataComplete HdmiInHdcpToggle = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Toggle", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
+
+        public DgeJoinMap(uint joinStart)
+            : this(joinStart, typeof(DgeJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected DgeJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        {
+        }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/DmDge200CController.cs

@@ -58,6 +58,7 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             HdmiOut.Port = _dge.HdmiOut; ;
 
         }
+    }
 
 	public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
 	{
@@ -91,4 +92,3 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 		}
 	}
 }
-}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/EndpointInterfaces.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash_Essentials_DM
+{
+    public interface IHasDmInHdcpSet
+    {
+        void SetDmInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasDmInHdcpGet
+    {
+        IntFeedback DmInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasDmInHdcp : IHasDmInHdcpGet, IHasDmInHdcpSet
+    {
+        eHdcpCapabilityType DmInHdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiInHdcpSet
+    {
+        void SetHdmiInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiInHdcpGet
+    {
+        IntFeedback HdmiInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmiInHdcp : IHasHdmiInHdcpGet, IHasHdmiInHdcpSet
+    {
+        eHdcpCapabilityType HdmiInHdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiIn1HdcpSet
+    {
+        void SetHdmiIn1HdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiIn1HdcpGet
+    {
+        IntFeedback HdmiIn1HdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmiIn1Hdcp : IHasHdmiIn1HdcpGet, IHasHdmiIn1HdcpSet
+    {
+        eHdcpCapabilityType HdmiIn1HdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiIn2HdcpSet
+    {
+        void SetHdmiIn2HdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiIn2HdcpGet
+    {
+        IntFeedback HdmiInIn2HdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmi2InHdcp : IHasHdmiIn2HdcpGet, IHasHdmiIn2HdcpSet
+    {
+        eHdcpCapabilityType Hdmi2InHdcpCapability { get; }
+    }
+
+
+
+    public interface IHasDisplayPortInHdcpGet
+    {
+        IntFeedback DisplayPortInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasDisplayPortInHdcpSet
+    {
+        void SetDisplayPortInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasDisplayPortInHdcp : IHasDisplayPortInHdcpGet, IHasDisplayPortInHdcpSet
+    {
+        eHdcpCapabilityType DisplayPortInHdcpCapability { get; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmHdBaseTEndpointController.cs

@@ -28,6 +28,8 @@ namespace PepperDash.Essentials.DM
 
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HDBaseTSink};
+            PreventRegistration = true;
+            rmc.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs

@@ -6,6 +6,7 @@ using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
@@ -15,7 +16,7 @@ namespace PepperDash.Essentials.DM
     /// </summary>
     [Description("Wrapper Class for DM-RMC-4K-SCALER-C")]
     public class DmRmc4kScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
-		IIROutputPorts, IComPorts, ICec, IRelayPorts
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp
     {
         private readonly DmRmc4kScalerC _rmc;
 
@@ -27,6 +28,12 @@ namespace PepperDash.Essentials.DM
 
         public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
 
+        public EndpointDmInputStreamWithCec DmInput { get; private set; }
+
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+
+
+
         /// <summary>
         ///  Make a Crestron RMC and put it in here
         /// </summary>
@@ -56,6 +63,11 @@ namespace PepperDash.Essentials.DM
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut, BalancedAudioOut };
 
             VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int)_rmc.DmInput.HdcpCapabilityFeedback);
+
+            AddToFeedbackList(DmInHdcpStateFeedback);
+
 
             _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
             _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
@@ -192,5 +204,17 @@ namespace PepperDash.Essentials.DM
         }
 
         #endregion
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
     }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4k100C1GController.cs

@@ -33,6 +33,8 @@ namespace PepperDash.Essentials.DM
 
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+            PreventRegistration = true;
+            rmc.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4kScalerCDspController.cs

@@ -6,6 +6,7 @@ using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
@@ -15,7 +16,7 @@ namespace PepperDash.Essentials.DM
     /// </summary>
     [Description("Wrapper Class for DM-RMC-4K-SCALER-C-DSP")]
     public class DmRmc4kScalerCDspController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
-        IIROutputPorts, IComPorts, ICec, IRelayPorts
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp
     {
         private readonly DmRmc4kScalerCDsp _rmc;
 
@@ -27,6 +28,11 @@ namespace PepperDash.Essentials.DM
 
         public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
 
+        public EndpointDmInputStreamWithCec DmInput { get; private set; }
+
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+
+
         /// <summary>
         ///  Make a Crestron RMC and put it in here
         /// </summary>
@@ -53,6 +59,12 @@ namespace PepperDash.Essentials.DM
 
             VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
 
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int) _rmc.DmInput.HdcpCapabilityFeedback);
+
+            AddToFeedbackList(DmInHdcpStateFeedback);
+
+
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut, BalancedAudioOut};
 
@@ -191,5 +203,17 @@ namespace PepperDash.Essentials.DM
         }
 
         #endregion
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
     }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4kZScalerCController.cs

@@ -9,12 +9,13 @@ using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Core;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
     [Description("Wrapper Class for DM-RMC-4K-Z-SCALER-C")]
     public class DmRmc4kZScalerCController : DmRmcControllerBase, IRmcRoutingWithFeedback,
-        IIROutputPorts, IComPorts, ICec, IRelayPorts
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp, IHasHdmiInHdcp
     {
         private readonly DmRmc4kzScalerC _rmc;
 
@@ -22,6 +23,13 @@ namespace PepperDash.Essentials.DM
         public RoutingInputPort HdmiIn { get; private set; }
         public RoutingOutputPort HdmiOut { get; private set; }
 
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+        public IntFeedback HdmiInHdcpStateFeedback { get; private set; }
+
+        public BoolFeedback HdmiVideoSyncFeedback { get; private set; }
+
+
+
         /// <summary>
         /// The value of the current video source for the HDMI output on the receiver
         /// </summary>
@@ -44,11 +52,11 @@ namespace PepperDash.Essentials.DM
             if (newEvent != null) newEvent(this, e);
         }
 
-
         public DmRmc4kZScalerCController(string key, string name, DmRmc4kzScalerC rmc)
             : base(key, name, rmc)
         {
             _rmc = rmc;
+
             DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.DmCat, 0, this)
             {
@@ -62,6 +70,16 @@ namespace PepperDash.Essentials.DM
             HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.Hdmi, null, this);
 
+            HdmiInHdcpStateFeedback = new IntFeedback("HdmiInHdcpCapability",
+                () => (int)_rmc.HdmiIn.HdcpCapabilityFeedback);
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int)_rmc.DmInput.HdcpCapabilityFeedback);
+            HdmiVideoSyncFeedback = new BoolFeedback("HdmiInVideoSync",
+                () => _rmc.HdmiIn.SyncDetectedFeedback.BoolValue);
+
+            AddToFeedbackList(HdmiInHdcpStateFeedback, DmInHdcpStateFeedback, HdmiVideoSyncFeedback);
+
+
             EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
             EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
             EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
@@ -74,6 +92,8 @@ namespace PepperDash.Essentials.DM
 
             _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
             _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
+            _rmc.HdmiIn.InputStreamChange += InputStreamChangeEvent;
+            _rmc.DmInput.InputStreamChange += InputStreamChangeEvent;
 
             _rmc.OnlineStatusChange += _rmc_OnlineStatusChange;
 
@@ -83,6 +103,20 @@ namespace PepperDash.Essentials.DM
             AudioVideoSourceNumericFeedback = new IntFeedback(() => (ushort)(_rmc.SelectedSourceFeedback));
         }
 
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
+                    if (inputStream == _rmc.HdmiIn) HdmiInHdcpStateFeedback.FireUpdate();
+                    if (inputStream == _rmc.DmInput) DmInHdcpStateFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
+                    if (inputStream == _rmc.HdmiIn) HdmiVideoSyncFeedback.FireUpdate();
+                    break;
+            }
+        }
+
         private void _rmc_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
         {
             AudioVideoSourceNumericFeedback.FireUpdate();
@@ -181,5 +215,31 @@ namespace PepperDash.Essentials.DM
         }
 
         #endregion
+
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
+
+        public eHdcpCapabilityType HdmiInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetHdmiInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.HdmiIn.HdcpCapability = hdcpState;
+        }
+
     }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmcHelper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Cards;
@@ -11,6 +12,7 @@ using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.DeviceInfo;
 using PepperDash.Essentials.DM.Config;
 using PepperDash.Essentials.Core.Config;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
@@ -74,18 +76,79 @@ namespace PepperDash.Essentials.DM
             if (rmc.EdidSerialNumberFeedback != null)
                 rmc.EdidSerialNumberFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidSerialNumber.JoinNumber]);
 
+
             //If the device is an DM-RMC-4K-Z-SCALER-C
-            var routing = rmc as IRmcRouting;
+            var routing = rmc as IRoutingInputsOutputs;
+
+            trilist.UShortInput[joinMap.HdcpInputPortCount.JoinNumber].UShortValue = (ushort)(routing == null
+                ? 1
+                : routing.InputPorts.Count);
 
             if (routing == null)
             {
                 return;
             }
+            var hdcpCapability = eHdcpCapabilityType.HdcpSupportOff;
+            if (routing.InputPorts[DmPortName.HdmiIn] != null)
+            {
+                var hdmiInHdcp = routing as IHasHdmiInHdcp;
+                if (hdmiInHdcp != null)
+                {
+                    if (rmc.Feedbacks["HdmiInHdcpCapability"] != null)
+                    {
+                        var intFeedback = rmc.Feedbacks["HdmiInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState.JoinNumber]);
+                    }
+                    if (rmc.Feedbacks["HdmiInVideoSync"] != null)
+                    {
+                        var boolFeedback = rmc.Feedbacks["HdmiInVideoSync"] as BoolFeedback;
+                        if (boolFeedback != null)
+                            boolFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiInputSync.JoinNumber]);
+                    }
+                    hdcpCapability = hdmiInHdcp.HdmiInHdcpCapability > hdcpCapability
+                        ? hdmiInHdcp.HdmiInHdcpCapability
+                        : hdcpCapability;
 
-            if (routing.AudioVideoSourceNumericFeedback != null)
+                    trilist.SetUShortSigAction(joinMap.Port1HdcpState.JoinNumber, a => hdmiInHdcp.SetHdmiInHdcpState((eHdcpCapabilityType)a));
-                routing.AudioVideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioVideoSource.JoinNumber]);
+                }
+            }
+            if (routing.InputPorts[DmPortName.DmIn] != null)
+            {
+                var dmInHdcp = rmc as IHasDmInHdcp;
 
-            trilist.SetUShortSigAction(joinMap.AudioVideoSource.JoinNumber, a => routing.ExecuteNumericSwitch(a, 1, eRoutingSignalType.AudioVideo));
+                if (dmInHdcp != null)
+                {
+                    if (rmc.Feedbacks["DmInHdcpCapability"] != null)
+                    {
+                        var intFeedback = rmc.Feedbacks["DmInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port2HdcpState.JoinNumber]);
+                    }
+
+                    hdcpCapability = dmInHdcp.DmInHdcpCapability > hdcpCapability
+                        ? dmInHdcp.DmInHdcpCapability
+                        : hdcpCapability;
+
+
+                    trilist.SetUShortSigAction(joinMap.Port2HdcpState.JoinNumber, a => dmInHdcp.SetDmInHdcpState((eHdcpCapabilityType)a));
+                }
+            }
+
+            trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber].UShortValue = (ushort)hdcpCapability;
+
+            trilist.UShortInput[joinMap.HdcpInputPortCount.JoinNumber].UShortValue = (ushort)routing.InputPorts.Count;
+
+            var routingWithFeedback = routing as IRmcRouting;
+            if (routingWithFeedback == null) return;
+
+            if (routingWithFeedback.AudioVideoSourceNumericFeedback != null)
+                routingWithFeedback.AudioVideoSourceNumericFeedback.LinkInputSig(
+                    trilist.UShortInput[joinMap.AudioVideoSource.JoinNumber]);
+
+
+            trilist.SetUShortSigAction(joinMap.AudioVideoSource.JoinNumber,
+                a => routingWithFeedback.ExecuteNumericSwitch(a, 1, eRoutingSignalType.AudioVideo));
         }
 
         #region Implementation of IDeviceInfoProvider
@@ -329,6 +392,9 @@ namespace PepperDash.Essentials.DM
             DmRmcPropertiesConfig props, string pKey, uint ipid)
         {
             var parentDev = DeviceManager.GetDeviceForKey(pKey);
+            CrestronGenericBaseDevice rx;
+            bool useChassisForOfflineFeedback = false;
+
             if (parentDev is DmpsRoutingController)
             {
                 var dmps = parentDev as DmpsRoutingController;
@@ -342,26 +408,37 @@ namespace PepperDash.Essentials.DM
                     return null;
                 }
                 // Must use different constructor for DMPS4K types. No IPID
-                if (Global.ControlSystemIsDmps4kType || typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                if (Global.ControlSystemIsDmps4kType)
                 {
-                    var rmc = GetDmRmcControllerForDmps4k(key, name, typeName, dmps, props.ParentOutputNumber);
+                    rx = GetDmRmcControllerForDmps4k(key, name, typeName, dmps, props.ParentOutputNumber);
-                    Debug.Console(0, "DM endpoint output {0} is for Dmps4k, changing online feedback to chassis", num);
+                    useChassisForOfflineFeedback = true;
-                    rmc.IsOnline.SetValueFunc(() => dmps.OutputEndpointOnlineFeedbacks[num].BoolValue);
+                }
+                else
+                {
+                    rx = GetDmRmcControllerForDmps(key, name, typeName, ipid, dmps, props.ParentOutputNumber);
+                    if (typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                    {
+                        useChassisForOfflineFeedback = true;
+                    }
+                }
+                if (useChassisForOfflineFeedback)
+                {
+                    Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                    rx.IsOnline.SetValueFunc(() => dmps.OutputEndpointOnlineFeedbacks[num].BoolValue);
                     dmps.OutputEndpointOnlineFeedbacks[num].OutputChange += (o, a) =>
                     {
-                        foreach (var feedback in rmc.Feedbacks)
+                        foreach (var feedback in rx.Feedbacks)
                         {
                             if (feedback != null)
                                 feedback.FireUpdate();
                         }
                     };
-                    return rmc;
                 }
-                return GetDmRmcControllerForDmps(key, name, typeName, ipid, dmps, props.ParentOutputNumber);
+                return rx;
             }
-            else if (parentDev is DmChassisController)
+            else if (parentDev is IDmSwitchWithEndpointOnlineFeedback)
             {
-                var controller = parentDev as DmChassisController;
+                var controller = parentDev as IDmSwitchWithEndpointOnlineFeedback;
                 var chassis = controller.Chassis;
                 var num = props.ParentOutputNumber;
                 Debug.Console(1, "Creating DM Chassis device '{0}'. Output number '{1}'.", key, num);
@@ -380,23 +457,33 @@ namespace PepperDash.Essentials.DM
                     if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
                         chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
                         chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps ||
-                        chassis is DmMd128x128 || chassis is DmMd64x64
+                        chassis is DmMd128x128 || chassis is DmMd64x64)
-                        || typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
                     {
-                        var rmc = GetDmRmcControllerForCpu3Chassis(key, name, typeName, chassis, num, parentDev);
+                        rx = GetDmRmcControllerForCpu3Chassis(key, name, typeName, chassis, num, parentDev);
-                        Debug.Console(0, "DM endpoint output {0} is for Cpu3, changing online feedback to chassis", num);
+                        useChassisForOfflineFeedback = true;
-                        rmc.IsOnline.SetValueFunc(() => controller.OutputEndpointOnlineFeedbacks[num].BoolValue);
+                    }
+                    else
+                    {
+                        rx = GetDmRmcControllerForCpu2Chassis(key, name, typeName, ipid, chassis, num, parentDev);
+                        if (typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
+                        }
+                    }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        rx.IsOnline.SetValueFunc(() => controller.OutputEndpointOnlineFeedbacks[num].BoolValue);
                         controller.OutputEndpointOnlineFeedbacks[num].OutputChange += (o, a) =>
                         {
-                                foreach (var feedback in rmc.Feedbacks)
+                            foreach (var feedback in rx.Feedbacks)
                             {
                                 if (feedback != null)
                                     feedback.FireUpdate();
                             }
                         };
-                        return rmc;
                     }
-                    return GetDmRmcControllerForCpu2Chassis(key, name, typeName, ipid, chassis, num, parentDev);
+                    return rx;
                 }
                 catch (Exception e)
                 {
@@ -500,8 +587,6 @@ namespace PepperDash.Essentials.DM
                 return null;
             }
         }
-
-        
     }
 
     public class DmRmcControllerFactory : EssentialsDeviceFactory<DmRmcControllerBase>

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k100Controller.cs

@@ -78,6 +78,8 @@ namespace PepperDash.Essentials.DM
                 IsOnline.SetValueFunc(() => controller.InputEndpointOnlineFeedbacks[num].BoolValue);
                 controller.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => IsOnline.FireUpdate();
             }
+            PreventRegistration = true;
+            tx.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k202CController.cs

@@ -137,15 +137,10 @@ namespace PepperDash.Essentials.DM
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability",
                 () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
 
-            HdcpStateFeedback =
-                new IntFeedback(
-                    () =>
-                        tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
-                            ? (int) tx.HdmiInputs[1].HdcpCapabilityFeedback
-                            : (int) tx.HdmiInputs[2].HdcpCapabilityFeedback);
-
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
 
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
+
             Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
 
             Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs

@@ -145,15 +145,10 @@ namespace PepperDash.Essentials.DM
 
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
 
-            HdcpStateFeedback =
-                new IntFeedback(
-                    () =>
-                        tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
-                            ? (int)tx.HdmiInputs[1].HdcpCapabilityFeedback
-                            : (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
-
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
 
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
+
             Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
 
             Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz100Controller.cs

@@ -72,6 +72,7 @@ namespace PepperDash.Essentials.DM
             HdmiIn.Port = Tx;
 
             PreventRegistration = true;
+            tx.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz302CController.cs

@@ -18,7 +18,7 @@ namespace PepperDash.Essentials.DM
 
 
     [Description("Wrapper class for DM-TX-4K-Z-302-C")]
-    public class DmTx4kz302CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback,
+    public class DmTx4kz302CController : DmTxControllerBase, ITxRoutingWithFeedback,
         IIROutputPorts, IComPorts
     {
         public DmTx4kz302C Tx { get; private set; }
@@ -34,6 +34,7 @@ namespace PepperDash.Essentials.DM
         public IntFeedback AudioSourceNumericFeedback { get; protected set; }
         public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
         public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
+        public IntFeedback DisplayPortInHdcpCapabilityFeedback { get; protected set; }
         public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
         public BoolFeedback Hdmi2VideoSyncFeedback { get; protected set; }
         public BoolFeedback DisplayPortVideoSyncFeedback { get; protected set; }
@@ -120,7 +121,7 @@ namespace PepperDash.Essentials.DM
 
             Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
             Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
-            Tx.DisplayPortInput.InputStreamChange += DisplayPortInputStreamChange;
+            Tx.DisplayPortInput.InputStreamChange += InputStreamChangeEvent;
             Tx.BaseEvent += Tx_BaseEvent;
             Tx.OnlineStatusChange += Tx_OnlineStatusChange;
 
@@ -130,15 +131,32 @@ namespace PepperDash.Essentials.DM
             HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () => (int)tx.HdmiInputs[1].HdcpCapabilityFeedback);
 
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
+            DisplayPortInHdcpCapabilityFeedback = new IntFeedback("DisplayPortInHdcpCapability",
+                () => (int)tx.DisplayPortInput.HdcpCapabilityFeedback);
 
+
+            /*
             HdcpStateFeedback =
                 new IntFeedback(
                     () =>
                         tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
                             ? (int)tx.HdmiInputs[1].HdcpCapabilityFeedback
                             : (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
+             */
+
+            //yeah this is gross - but it's the quickest way to do this...
+            /*
+            HdcpStateFeedback = new IntFeedback(() => {
+                var states = new[] {(int) tx.DisplayPortInput.HdcpCapabilityFeedback, (int) tx.HdmiInputs[1].HdcpCapabilityFeedback, (int) tx.HdmiInputs[2].HdcpCapabilityFeedback};
+
+                return states.Max();
+            });
+             */
 
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+            // I feel like we have had this as a misnomer for so long, that it really needed to be fixed 
+            // All we were doing was reporting the best of the current statuses - not the actual capability of the device.
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
 
             Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
 
@@ -146,20 +164,25 @@ namespace PepperDash.Essentials.DM
 
             DisplayPortVideoSyncFeedback = new BoolFeedback(() => (bool)tx.DisplayPortInput.SyncDetectedFeedback.BoolValue);
 
-
             var combinedFuncs = new VideoStatusFuncsWrapper
             {
                 HdcpActiveFeedbackFunc = () =>
                     (ActualActiveVideoInput == eVst.Hdmi1
                     && tx.HdmiInputs[1].VideoAttributes.HdcpActiveFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Hdmi2
-                    && tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue),
+                    && tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.DisplayPort
+                    && tx.DisplayPortInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
 
                 HdcpStateFeedbackFunc = () =>
                 {
                     if (ActualActiveVideoInput == eVst.Hdmi1)
                         return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString(); 
-                    return ActualActiveVideoInput == eVst.Hdmi2 ? tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString() : "";
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+                    return ActualActiveVideoInput == eVst.DisplayPort
+                        ? tx.DisplayPortInput.VideoAttributes.HdcpStateFeedback.ToString()
+                        : "";
                 },
 
                 VideoResolutionFeedbackFunc = () =>
@@ -168,6 +191,8 @@ namespace PepperDash.Essentials.DM
                         return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
                     if (ActualActiveVideoInput == eVst.Hdmi2)
                         return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.DisplayPort)
+                        return tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString();
                     return ActualActiveVideoInput == eVst.Vga ? tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString() : "";
                 },
                 VideoSyncFeedbackFunc = () =>
@@ -175,6 +200,8 @@ namespace PepperDash.Essentials.DM
                     && tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Hdmi2
                     && tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.DisplayPort
+                    && tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Vga
                     && tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
 
@@ -193,28 +220,15 @@ namespace PepperDash.Essentials.DM
                 AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
                 AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
                 AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiIn1HdcpCapabilityFeedback, HdmiIn2HdcpCapabilityFeedback,
-                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, DisplayPortVideoSyncFeedback);
+                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, DisplayPortVideoSyncFeedback, DisplayPortInHdcpCapabilityFeedback);
 
-            // Set Ports for CEC
             HdmiIn1.Port = Tx.HdmiInputs[1];
             HdmiIn2.Port = Tx.HdmiInputs[2];
+            DisplayPortIn.Port = Tx.DisplayPortInput;
             HdmiLoopOut.Port = Tx.HdmiOutput;
             DmOut.Port = Tx.DmOutput;
         }
 
-        void DisplayPortInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
-            Debug.Console(2, "{0} event {1} stream {2}", Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
-
-            switch (args.EventId)
-            {
-                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
-                    DisplayPortVideoSyncFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-
 
         public override bool CustomActivate()
         {
@@ -326,11 +340,17 @@ namespace PepperDash.Essentials.DM
                 case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
                     if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
                     if (inputStream == Tx.HdmiInputs[2]) HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+                    if (inputStream == Tx.DisplayPortInput) DisplayPortInHdcpCapabilityFeedback.FireUpdate();
+
+                    Debug.Console(2, this, "DisplayPortHDCP Mode Trigger = {0}",
+                        DisplayPortInHdcpCapabilityFeedback.IntValue);
+
                     HdcpStateFeedback.FireUpdate();
                     break;
                 case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
                     if (inputStream == Tx.HdmiInputs[1]) Hdmi1VideoSyncFeedback.FireUpdate();
                     if (inputStream == Tx.HdmiInputs[2]) Hdmi2VideoSyncFeedback.FireUpdate();
+                    if (inputStream == Tx.DisplayPortInput) DisplayPortVideoSyncFeedback.FireUpdate();
                     break;
             }
         }
@@ -413,7 +433,6 @@ namespace PepperDash.Essentials.DM
             }
         }
 
-
         #region IIROutputPorts Members
         public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
         public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTxHelpers.cs

@@ -1,8 +1,6 @@
 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;
@@ -44,7 +42,7 @@ namespace PepperDash.Essentials.DM
             if (typeName.StartsWith("dmtx401"))
                 return new DmTx401CController(key, name, new DmTx401C(dmInput), true);
             if (typeName.StartsWith("hdbasettx"))
-                new HDBaseTTxController(key, name, new HDTx3CB(dmInput));
+                return new HDBaseTTxController(key, name, new HDTx3CB(dmInput));
 
             return null;
         }
@@ -83,6 +81,7 @@ namespace PepperDash.Essentials.DM
         /// <param name="key"></param>
         /// <param name="name"></param>
         /// <param name="props"></param>
+        /// <param name="typeName"></param>
         /// <returns></returns>
         public static BasicDmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
         {
@@ -126,11 +125,12 @@ namespace PepperDash.Essentials.DM
             var parentDev = DeviceManager.GetDeviceForKey(pKey);
             DMInput dmInput;
             BasicDmTxControllerBase tx;
+            bool useChassisForOfflineFeedback = false;
 
-		    if (parentDev is DmChassisController)
+            if (parentDev is IDmSwitchWithEndpointOnlineFeedback)
             {
                 // Get the Crestron chassis and link stuff up
-			    var switchDev = (parentDev as DmChassisController);
+                var switchDev = (parentDev as IDmSwitchWithEndpointOnlineFeedback);
                 var chassis = switchDev.Chassis;
 
                 //Check that the input is within range of this chassis' possible inputs
@@ -155,23 +155,32 @@ namespace PepperDash.Essentials.DM
                         chassis is DmMd128x128 || chassis is DmMd64x64)
                     {
                         tx = GetDmTxForChassisWithoutIpId(key, name, typeName, dmInput);
-                        Debug.Console(0, "DM endpoint output {0} is for Cpu3, changing online feedback to chassis", num);
+                        useChassisForOfflineFeedback = true;
-                        tx.IsOnline.SetValueFunc(() => switchDev.InputEndpointOnlineFeedbacks[num].BoolValue);
-                        switchDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
-                        return tx;
                     }
                     else
                     {
-                        return GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        tx = GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        if (typeName == "hdbasettx" || typeName == "dmtx4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
                         }
                     }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        tx.IsOnline.SetValueFunc(() => switchDev.InputEndpointOnlineFeedbacks[num].BoolValue);
+                        switchDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
+                    }
+                    return tx;
+                }
                 catch (Exception e)
                 {
                     Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device for chassis: {1}", key, e);
                     return null;
                 }
             }
-            else if(parentDev is DmpsRoutingController)
+
+            if (parentDev is DmpsRoutingController)
             {
                 // Get the DMPS chassis and link stuff up
                 var dmpsDev = (parentDev as DmpsRoutingController);
@@ -203,16 +212,24 @@ namespace PepperDash.Essentials.DM
                     if (Global.ControlSystemIsDmps4kType)
                     {
                         tx = GetDmTxForChassisWithoutIpId(key, name, typeName, dmInput);
-                        Debug.Console(0, "DM endpoint output {0} is for DMPS3-4K, changing online feedback to chassis", num);
+                        useChassisForOfflineFeedback = true;
-                        tx.IsOnline.SetValueFunc(() => dmpsDev.InputEndpointOnlineFeedbacks[num].BoolValue);
-                        dmpsDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
-                        return tx;
                     }
                     else
                     {
-                        return GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        tx = GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        if (typeName == "hdbasettx" || typeName == "dmtx4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
                         }
                     }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        tx.IsOnline.SetValueFunc(() => dmpsDev.InputEndpointOnlineFeedbacks[num].BoolValue);
+                        dmpsDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
+                    }
+                    return tx;
+                }
                 catch (Exception e)
                 {
                     Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device for dmps: {1}", key, e);
@@ -220,13 +237,10 @@ namespace PepperDash.Essentials.DM
                 }
             }
 
-            else
-            {
             Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a processor, DM Chassis or DMPS.", key, pKey);
             return null;
         }
     }
-	}
 
     public abstract class BasicDmTxControllerBase : CrestronGenericBridgeableBaseDevice
     {
@@ -264,7 +278,8 @@ namespace PepperDash.Essentials.DM
             };
         }
 
-	    protected DmTxControllerBase(string key, string name, DmHDBasedTEndPoint hardware) : base(key, name, hardware)
+        protected DmTxControllerBase(string key, string name, DmHDBasedTEndPoint hardware)
+            : base(key, name, hardware)
         {
         }
 
@@ -318,8 +333,6 @@ namespace PepperDash.Essentials.DM
                 txR.VideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoInput.JoinNumber]);
                 txR.AudioSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioInput.JoinNumber]);
 
-                trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber].UShortValue = (ushort)tx.HdcpSupportCapability;
-
                 if (txR.InputPorts[DmPortName.HdmiIn] != null)
                 {
                     var inputPort = txR.InputPorts[DmPortName.HdmiIn];
@@ -366,7 +379,7 @@ namespace PepperDash.Essentials.DM
                     {
                         var intFeedback = tx.Feedbacks["HdmiIn2HdcpCapability"] as IntFeedback;
                         if (intFeedback != null)
-                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState.JoinNumber]);
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port2HdcpState.JoinNumber]);
                     }
 
                     if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
@@ -377,6 +390,40 @@ namespace PepperDash.Essentials.DM
                     }
                 }
 
+                if (txR.InputPorts[DmPortName.DisplayPortIn] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.DisplayPortIn];
+
+                    if (tx.Feedbacks["DisplayPortInHdcpCapability"] != null)
+                    {
+
+                        var intFeedback = tx.Feedbacks["DisplayPortInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port3HdcpState.JoinNumber]);
+
+                        if (inputPort.ConnectionType == eRoutingPortConnectionType.DisplayPort && inputPort.Port != null)
+                        {
+                            var port = inputPort.Port as EndpointDisplayPortInput;
+                            SetHdcpCapabilityAction(port, joinMap.Port3HdcpState.JoinNumber, trilist);
+                        }
+                    }
+                }
+
+
+                var hdcpInputPortCount =
+                    (ushort)
+                        txR.InputPorts.Where(
+                            x => (x.Type == eRoutingSignalType.Video) || (x.Type == eRoutingSignalType.AudioVideo))
+                            .Where(
+                                x =>
+                                    (x.ConnectionType == eRoutingPortConnectionType.DmCat) ||
+                                    (x.ConnectionType == eRoutingPortConnectionType.Hdmi) ||
+                                    (x.ConnectionType == eRoutingPortConnectionType.DisplayPort))
+                            .ToList().Count();
+
+                trilist.SetUshort(joinMap.HdcpInputPortCount.JoinNumber, hdcpInputPortCount);
+
             }
 
             var txFreeRun = tx as IHasFreeRun;
@@ -424,14 +471,40 @@ namespace PepperDash.Essentials.DM
                         });
             }
         }
+
+        private void SetHdcpCapabilityAction(EndpointDisplayPortInput port, uint join,
+            BasicTriList trilist)
+        {
+            trilist.SetUShortSigAction(join,
+                s =>
+                {
+                    Debug.Console(0, this, "Trying to set HDCP to {0} on port {1}", s, port.ToString());
+                    port.HdcpCapability = (eHdcpCapabilityType) s;
+                });
+        }
+
     }
 
     public class DmTxControllerFactory : EssentialsDeviceFactory<DmTxControllerBase>
     {
         public DmTxControllerFactory()
         {
-            TypeNames = new List<string>() { "dmtx200c", "dmtx201c", "dmtx201s", "dmtx4k100c", "dmtx4k202c", "dmtx4kz202c", "dmtx4k302c", "dmtx4kz302c",
+            TypeNames = new List<string>
-                "dmtx401c", "dmtx401s", "dmtx4k100c1g", "dmtx4kz100c1g", "hdbasettx" };
+            {
+                "dmtx200c",
+                "dmtx201c",
+                "dmtx201s",
+                "dmtx4k100c",
+                "dmtx4k202c",
+                "dmtx4kz202c",
+                "dmtx4k302c",
+                "dmtx4kz302c",
+                "dmtx401c",
+                "dmtx401s",
+                "dmtx4k100c1g",
+                "dmtx4kz100c1g",
+                "hdbasettx"
+            };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -441,8 +514,8 @@ namespace PepperDash.Essentials.DM
             Debug.Console(1, "Factory Attempting to create new DM-TX Device");
 
             var props = JsonConvert.DeserializeObject
-                <PepperDash.Essentials.DM.Config.DmTxPropertiesConfig>(dc.Properties.ToString());
+                <DmTxPropertiesConfig>(dc.Properties.ToString());
-            return PepperDash.Essentials.DM.DmTxHelper.GetDmTxController(dc.Key, dc.Name, type, props);
+            return DmTxHelper.GetDmTxController(dc.Key, dc.Name, type, props);
         }
     }
 

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/HDBaseTTxController.cs

@@ -52,6 +52,9 @@ namespace PepperDash.Essentials.DM
                 IsOnline.SetValueFunc(() => controller.InputEndpointOnlineFeedbacks[num].BoolValue);
                 controller.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => IsOnline.FireUpdate();
             }
+
+            PreventRegistration = true;
+            tx.Register();
         }
 
         #region IRoutingInputs Members

essentials-framework/Essentials DM/Essentials_DM/IDmSwitch.cs

@@ -16,10 +16,17 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.DM.Config;
 
 namespace PepperDash.Essentials.DM {
-    public interface IDmSwitch {
+    public interface IDmSwitch
+	{
         Switch Chassis { get; }
 
         Dictionary<uint, string> TxDictionary { get; }
         Dictionary<uint, string> RxDictionary { get; }
     }
+
+	public interface IDmSwitchWithEndpointOnlineFeedback : IDmSwitch
+	{
+		Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; }
+		Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; }
+	}
 }

essentials-framework/Essentials DM/Essentials_DM/PepperDash_Essentials_DM.csproj

@@ -105,6 +105,8 @@
     <Compile Include="Chassis\HdMdNxM4kEBridgeableController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
     <Compile Include="Config\InputPropertiesConfig.cs" />
+    <Compile Include="Endpoints\EndpointInterfaces.cs" />
+    <Compile Include="Endpoints\DGEs\DgeJoinMap.cs" />
     <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Cameras/CameraBase.cs

@@ -223,7 +223,7 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
 
                 SendCameraPresetNamesToApi(presetsCamera, joinMap, trilist);
 
-                for (int i = 0; i < joinMap.NumberOfPresets.JoinNumber; i++)
+                for (int i = 0; i < joinMap.NumberOfPresets.JoinSpan; i++)
                 {
                     int tempNum = i;
 

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/VideoCodecBase.cs

@@ -1004,7 +1004,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 		    if (codec.DirectoryRoot != null)
 		    {
-                trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)codec.DirectoryRoot.CurrentDirectoryResults.Count);
+				var contactsCount = codec.DirectoryRoot.CurrentDirectoryResults.Where(c => c.ParentFolderId.Equals("root")).ToList().Count;				
+                trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)contactsCount);
+				Debug.Console(2, this, ">>> contactsCount: {0}", contactsCount);
 
                 var clearBytes = XSigHelpers.ClearOutputs();
 
@@ -1020,7 +1022,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 			codec.DirectoryResultReturned += (sender, args) =>
 			{
-				trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)args.Directory.CurrentDirectoryResults.Count);
+				var isRoot = codec.CurrentDirectoryResultIsNotDirectoryRoot.BoolValue == false;
+				var argsCount = isRoot 
+					? args.Directory.CurrentDirectoryResults.Where(a => a.ParentFolderId.Equals("root")).ToList().Count
+					: args.Directory.CurrentDirectoryResults.Count;
+
+				trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)argsCount);
+				Debug.Console(2, this, ">>> argsCount: {0}", argsCount);
 
 				var clearBytes = XSigHelpers.ClearOutputs();
 
@@ -1191,26 +1199,29 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				? xSigMaxIndex
 				: directory.CurrentDirectoryResults.Count];
 
-	        Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot,
+			Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot, directory.CurrentDirectoryResults.Count, tokenArray.Length);
-	            directory.CurrentDirectoryResults.Count, tokenArray.Length);
 
 			var contacts = directory.CurrentDirectoryResults.Count > xSigMaxIndex
 				? directory.CurrentDirectoryResults.Take(xSigMaxIndex)
 				: directory.CurrentDirectoryResults;
 
+			var contactsToDisplay = isRoot
+				? contacts.Where(c => c.ParentFolderId == "root")
+				: contacts.Where(c => c.ParentFolderId != "root");
+
 			var counterIndex = 1;
-	        foreach (var entry in contacts)
+			foreach (var entry in contactsToDisplay)
 			{
 				var arrayIndex = counterIndex - 1;
 				var entryIndex = counterIndex;
 
-	            Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}", entry.Name, entry.FolderId, entryIndex);
+				Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}, Type: {3}, ParentFolderId: {4}",
+					entry.Name, entry.FolderId, entryIndex, entry.GetType().GetCType().FullName, entry.ParentFolderId);
 
-	            if (entry is DirectoryFolder && entry.ParentFolderId == "root")
+				if (entry is DirectoryFolder)
 				{
 					tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, String.Format("[+] {0}", entry.Name));
 
-	                counterIndex++;
 					counterIndex++;
 
 					continue;
@@ -1222,8 +1233,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			}
 
 			return GetXSigString(tokenArray);
-
-
 		}
 
 	    private void LinkVideoCodecCallControlsToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
@@ -1393,11 +1402,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                 tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, call.IsOnHold);
 
 				//serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
+                tokenArray[stringIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
                 if(call.Duration != null)
                 {
                     // May need to verify correct string format here
@@ -1417,12 +1426,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 
                 //serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
+                tokenArray[stringIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
-                tokenArray[arrayIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
+                tokenArray[stringIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ResponseObjects.cs

@@ -303,11 +303,19 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 					{
 						var contact = new InvitableDirectoryContact { Name = c.ScreenName, ContactId = c.Jid };
 
-                        contact.ContactMethods.Add(new ContactMethod() { Number = c.Jid, Device = eContactMethodDevice.Video, CallType = eContactMethodCallType.Video, ContactMethodId = c.Jid });
+                        contact.ContactMethods.Add(new ContactMethod()
+                        {
+	                        Number = c.Jid, 
+							Device = eContactMethodDevice.Video, 
+							CallType = eContactMethodCallType.Video, 
+							ContactMethodId = c.Jid
+                        });
 
 						if (folders.Count > 0)
 						{
-							contact.ParentFolderId = c.IsZoomRoom ? "rooms" : "contacts";
+							contact.ParentFolderId = c.IsZoomRoom
+								? roomFolder.FolderId // "rooms" 
+								: contactFolder.FolderId; // "contacts"
 						}
 
 						contacts.Add(contact);

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoom.cs

@@ -59,14 +59,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		private CameraBase _selectedCamera;
         private string _lastDialedMeetingNumber;
 
+        private CTimer contactsDebounceTimer;
+
 
 		private readonly ZoomRoomPropertiesConfig _props;
 
 		private bool _meetingPasswordRequired;
 
+        private bool _waitingForUserToAcceptOrRejectIncomingCall;
+
 		public void Poll(string pollString)
 		{
-			if(_meetingPasswordRequired) return;
+			if(_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 			
 			SendText(string.Format("{0}{1}", pollString, SendDelimiter));
 		}
@@ -374,26 +378,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void SelectCamera(string key)
 		{
-			if (Cameras == null)
-			{
-				return;
-			}
-
-			var camera = Cameras.FirstOrDefault(c => c.Key.IndexOf(key, StringComparison.OrdinalIgnoreCase) > -1);
-			if (camera != null)
-			{
-				Debug.Console(1, this, "Selected Camera with key: '{0}'", camera.Key);
-				SelectedCamera = camera;
-
             if (CameraIsMutedFeedback.BoolValue)
             {
                 CameraMuteOff();
             }
-			}
+
-			else
+            SendText(string.Format("zConfiguration Video Camera selectedId: {0}", key));
-			{
-				Debug.Console(1, this, "Unable to select camera with key: '{0}'", key);
-			}
 		}
 
 		public CameraBase FarEndCamera { get; private set; }
@@ -656,8 +646,27 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			{
 				if (a.PropertyName == "SelectedId")
 				{
-					SelectCamera(Configuration.Video.Camera.SelectedId);
+                    if (Cameras == null)
-					// this will in turn fire the affected feedbacks
+                    {
+                        return;
+                    }
+
+                    var camera = Cameras.FirstOrDefault(c => c.Key.IndexOf(Configuration.Video.Camera.SelectedId, StringComparison.OrdinalIgnoreCase) > -1);
+                    if (camera != null)
+                    {
+                        Debug.Console(1, this, "Camera selected with key: '{0}'", camera.Key);
+
+                        SelectedCamera = camera;
+
+                        if (CameraIsMutedFeedback.BoolValue)
+                        {
+                            CameraMuteOff();
+                        }
+                    }
+                    else
+                    {
+                        Debug.Console(1, this, "No camera found with key: '{0}'", Configuration.Video.Camera.SelectedId);
+                    }
 				}
 			};
 
@@ -968,6 +977,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void SendText(string command)
 		{
+            if (_meetingPasswordRequired)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to enter meeting password");
+                return;
+            }
+
+            if (_waitingForUserToAcceptOrRejectIncomingCall)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to accept or reject incoming call");
+                return;
+            }
+
 			if (CommDebuggingIsOn)
 			{
 				Debug.Console(1, this, "Sending: '{0}'", command);
@@ -1363,22 +1384,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 								JsonConvert.PopulateObject(responseObj.ToString(), Status.Phonebook);
 
-								var directoryResults =
+                                UpdateDirectory();
-									zStatus.Phonebook.ConvertZoomContactsToGeneric(Status.Phonebook.Contacts);
-
-								if (!PhonebookSyncState.InitialSyncComplete)
-								{
-									PhonebookSyncState.InitialPhonebookFoldersReceived();
-									PhonebookSyncState.PhonebookRootEntriesReceived();
-									PhonebookSyncState.SetPhonebookHasFolders(true);
-									PhonebookSyncState.SetNumberOfContacts(Status.Phonebook.Contacts.Count);
-								}
-
-								directoryResults.ResultsFolderId = "root";
-
-								DirectoryRoot = directoryResults;
-
-								CurrentDirectoryResult = directoryResults;
 
 								break;
 							}
@@ -1507,34 +1513,35 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 						{
 							case "phonebook":
 							{
+                                zStatus.Contact contact = new zStatus.Contact();
+
 								if (responseObj["Updated Contact"] != null)
 								{                                    
-									var updatedContact =
+                                    contact = responseObj["Updated Contact"].ToObject<zStatus.Contact>();									
-										JsonConvert.DeserializeObject<zStatus.Contact>(
-											responseObj["Updated Contact"].ToString());
-
-									var existingContact =
-										Status.Phonebook.Contacts.FirstOrDefault(c => c.Jid.Equals(updatedContact.Jid));
-
-									if (existingContact != null)
-									{
-										// Update existing contact
-										JsonConvert.PopulateObject(responseObj["Updated Contact"].ToString(),
-											existingContact);
-									}
 								}
 								else if (responseObj["Added Contact"] != null)
 								{
-									var jToken = responseObj["Updated Contact"];
+									contact = responseObj["Added Contact"].ToObject<zStatus.Contact>();
-									if (jToken != null)
-									{
-										var newContact =
-											JsonConvert.DeserializeObject<zStatus.Contact>(
-												jToken.ToString());
-
-										// Add a new contact
-										Status.Phonebook.Contacts.Add(newContact);
 								}
+
+                                var existingContactIndex = Status.Phonebook.Contacts.FindIndex(c => c.Jid.Equals(contact.Jid));
+
+                                if (existingContactIndex > 0)
+                                {                                    
+                                    Status.Phonebook.Contacts[existingContactIndex] = contact;
+                                } 
+                                else 
+                                {                                    
+                                    Status.Phonebook.Contacts.Add(contact);
+                                }
+
+                                if(contactsDebounceTimer == null)
+                                {
+                                    contactsDebounceTimer = new CTimer(o => UpdateDirectory(), 2000);
+                                }
+                                else
+                                {
+                                    contactsDebounceTimer.Reset();
                                 }                                
 
 								break;
@@ -1592,6 +1599,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										Id = incomingCall.callerJID
 									};
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = true;
+
 									ActiveCalls.Add(newCall);
 
 									OnCallStatusChange(newCall);
@@ -1618,6 +1627,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										OnCallStatusChange(existingCall);
 									}
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 									UpdateCallStatus();
 								}
 
@@ -2000,7 +2011,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		/// </summary>
 		private void GetBookings()
 		{
-			if (_meetingPasswordRequired) return;
+			if (_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 
 			SendText("zCommand Bookings List");
 		}
@@ -2229,6 +2240,42 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             }
         }
 
+        private void UpdateDirectory()
+        {
+            Debug.Console(2, this, "Updating directory");
+            var directoryResults = zStatus.Phonebook.ConvertZoomContactsToGeneric(Status.Phonebook.Contacts);
+
+            if (!PhonebookSyncState.InitialSyncComplete)
+            {
+                PhonebookSyncState.InitialPhonebookFoldersReceived();
+                PhonebookSyncState.PhonebookRootEntriesReceived();
+                PhonebookSyncState.SetPhonebookHasFolders(true);
+                PhonebookSyncState.SetNumberOfContacts(Status.Phonebook.Contacts.Count);
+            }
+
+            directoryResults.ResultsFolderId = "root";
+
+            DirectoryRoot = directoryResults;
+
+            CurrentDirectoryResult = directoryResults;
+
+            //
+            if (contactsDebounceTimer != null)
+            {
+                ClearContactDebounceTimer();
+            }
+        }
+
+        private void ClearContactDebounceTimer()
+        {
+            Debug.Console(2, this, "Clearing Timer");
+            if (!contactsDebounceTimer.Disposed && contactsDebounceTimer != null)
+            {
+                contactsDebounceTimer.Dispose();
+                contactsDebounceTimer = null;
+            }
+        }
+
         /// <summary>
         /// Will return true if the host is myself (this zoom room)
         /// </summary>
@@ -2560,7 +2607,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			PasswordRequired += (devices, args) =>
 			{
-                Debug.Console(0, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
+                Debug.Console(2, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
 
 				if (args.LoginAttemptCancelled)
 				{
@@ -2637,6 +2684,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void AcceptCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2646,6 +2695,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void AcceptCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Accept callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Connected;
@@ -2657,6 +2708,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void RejectCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2666,6 +2719,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void RejectCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Reject callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Disconnected;
@@ -2792,16 +2847,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void LeaveMeeting()
         {
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Leave");
         }
 
 		public override void EndCall(CodecActiveCallItem call)
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
 		public override void EndAllCalls()
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
@@ -3451,18 +3515,19 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void SubmitPassword(string password)
         {
+            _meetingPasswordRequired = false;
             Debug.Console(2, this, "Password Submitted: {0}", password);
             Dial(_lastDialedMeetingNumber, password);
-            //OnPasswordRequired(false, false, true, "");		
         }
 
         void OnPasswordRequired(bool lastAttemptIncorrect, bool loginFailed, bool loginCancelled, string message)
         {
+			_meetingPasswordRequired = !loginFailed || !loginCancelled;
+
             var handler = PasswordRequired;
             if (handler != null)
             {	            
-				if(!loginFailed || !loginCancelled)
+				Debug.Console(2, this, "Meeting Password Required: {0}", _meetingPasswordRequired);
-					_meetingPasswordRequired = true;
 
 	            handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
             }

packages.config

@@ -1,3 +1,3 @@
 <packages>
-  <package id="PepperDashCore" version="1.1.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
+	<package id="PepperDashCore" version="1.2.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
 </packages>