#1145 moves LoadTieLines() to after device activation sequence

Add secureTcpClient to comm factory

PepperDashEssentials/ControlSystem.cs

@@ -337,19 +337,20 @@ namespace PepperDash.Essentials
 		void Load()
 		{
 			LoadDevices();
-			LoadTieLines();
 			LoadRooms();
 			LoadLogoServer();
 
 			DeviceManager.ActivateAll();
 
+            LoadTieLines();
+
 		    var mobileControl = GetMobileControlDevice();
 
 		    if (mobileControl == null) return;
 
             mobileControl.LinkSystemMonitorToAppServer();
-		    
-		}
+
+        }
 
         /// <summary>
         /// Reads all devices from config and adds them to DeviceManager
@@ -401,20 +402,21 @@ namespace PepperDash.Essentials
                         }
                         else if (this.ControllerPrompt.IndexOf("mpc3", StringComparison.OrdinalIgnoreCase) > -1)
                         {
-                            Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");
+							Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");
 
-                            var butToken = devConf.Properties["buttons"];
-                            if (butToken != null)
-                            {
-                                var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
-                                var tpController = new Essentials.Core.Touchpanels.Mpc3TouchpanelController(devConf.Key, devConf.Name, Global.ControlSystem, buttons);
-                                DeviceManager.AddDevice(tpController);
-                            }
-                            else
-                            {
-                                Debug.Console(0, Debug.ErrorLogLevel.Error, "Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
-                            }
-                            
+							var butToken = devConf.Properties["buttons"];
+							if (butToken == null)
+							{
+								Debug.Console(0, Debug.ErrorLogLevel.Error,
+									"Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
+								continue;
+							}
+
+							var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
+							var tpController = new Core.Touchpanels.Mpc3TouchpanelController(
+									string.Format("{0}-keypadButtons", devConf.Key), devConf.Name, Global.ControlSystem, buttons);
+
+							DeviceManager.AddDevice(tpController);	
                         }
                         else
                         {

PepperDashEssentials/Room/Types/Interfaces/IEssentialsHuddleSpaceRoom.cs

@@ -7,7 +7,8 @@ using PepperDash.Essentials.Room.Config;
 
 namespace PepperDash.Essentials
 {
-    public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute, IHasDefaultDisplay, IHasCurrentVolumeControls
+    public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute, IHasDefaultDisplay, IHasCurrentVolumeControls, IRoomOccupancy,
+        IEmergency, IMicrophonePrivacy
     {
         bool ExcludeFromGlobalFunctions { get; }
 

PepperDashEssentials/Room/Types/Interfaces/IEssentialsHuddleVtc1Room.cs

@@ -8,7 +8,8 @@ using PepperDash.Essentials.Devices.Common.AudioCodec;
 namespace PepperDash.Essentials
 {
     public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange,
-         IPrivacy, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback
+         IPrivacy, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback,
+        IRoomOccupancy, IEmergency, IMicrophonePrivacy
     {
         EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
 

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

@@ -81,6 +81,15 @@ namespace PepperDash.Essentials.Core
                         }
 					case eControlMethod.Telnet:
 						break;
+					case eControlMethod.SecureTcpIp:
+						{
+							var secureTcp = new GenericSecureTcpIpClient(deviceConfig.Key + "-secureTcp", c.Address, c.Port, c.BufferSize);
+							secureTcp.AutoReconnect = c.AutoReconnect;
+							if (secureTcp.AutoReconnect)
+								secureTcp.AutoReconnectIntervalMs = c.AutoReconnectIntervalMs;
+							comm = secureTcp;
+							break;
+						}
 					default:
 						break;
 				}				

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

@@ -72,6 +72,10 @@ namespace PepperDash.Essentials.Core
     {
         IBasicVolumeControls CurrentVolumeControls { get; }
 		event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
+
+        void SetDefaultLevels();
+
+        bool ZeroVolumeWhenSwtichingVolumeDevices { get; }
 	}
 
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -148,15 +148,20 @@ namespace PepperDash.Essentials.Core.Fusion
                     ReadGuidFile(guidFilePath);
                 }
 
-                if (Room.RoomOccupancy != null)
+                var occupancyRoom = Room as IRoomOccupancy;
+
+                if (occupancyRoom != null)
                 {
-                    if (Room.OccupancyStatusProviderIsRemote)
+                    if (occupancyRoom.RoomOccupancy != null)
                     {
-                        SetUpRemoteOccupancy();
-                    }
-                    else
-                    {
-                        SetUpLocalOccupancy();
+                        if (occupancyRoom.OccupancyStatusProviderIsRemote)
+                        {
+                            SetUpRemoteOccupancy();
+                        }
+                        else
+                        {
+                            SetUpLocalOccupancy();
+                        }
                     }
                 }
 
@@ -1523,10 +1528,15 @@ namespace PepperDash.Essentials.Core.Fusion
             // Tie to method on occupancy object
             //occSensorShutdownMinutes.OutputSig.UserObject(new Action(ushort)(b => Room.OccupancyObj.SetShutdownMinutes(b));
 
+            var occRoom = Room as IRoomOccupancy;
 
+            if (occRoom != null)
+            {
+                occRoom.RoomOccupancy.RoomIsOccupiedFeedback.LinkInputSig(occSensorAsset.RoomOccupied.InputSig);
+                occRoom.RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += RoomIsOccupiedFeedback_OutputChange;
+            }
             RoomOccupancyRemoteStringFeedback = new StringFeedback(() => _roomOccupancyRemoteString);
-            Room.RoomOccupancy.RoomIsOccupiedFeedback.LinkInputSig(occSensorAsset.RoomOccupied.InputSig);
-            Room.RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += RoomIsOccupiedFeedback_OutputChange;
+            
             RoomOccupancyRemoteStringFeedback.LinkInputSig(occSensorAsset.RoomOccupancyInfo.InputSig);
 
             //}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Behaviours/RoomOnToDefaultSourceWhenOccupied.cs

@@ -38,7 +38,7 @@ namespace PepperDash.Essentials.Core
 
         ScheduledEventGroup FeatureEventGroup;
 
-        public IEssentialsRoom Room { get; private set; }
+        public IRoomOccupancy Room { get; private set; }
 
         private Fusion.EssentialsHuddleSpaceFusionSystemControllerBase FusionRoom;
 
@@ -84,7 +84,7 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         void SetUpDevice()
         {
-            Room = DeviceManager.GetDeviceForKey(PropertiesConfig.RoomKey) as IEssentialsRoom;
+            Room = DeviceManager.GetDeviceForKey(PropertiesConfig.RoomKey) as IRoomOccupancy;
 
             if (Room != null)
             {
@@ -235,12 +235,23 @@ namespace PepperDash.Essentials.Core
 
                 if (FeatureEnabled)
                 {
-                    // Check room power state first
-                    if (!Room.OnFeedback.BoolValue)
-                    {
-                        Debug.Console(1, this, "Powering Room on to default source");
-                        Room.RunDefaultPresentRoute();
+                    var essentialsRoom = Room as IEssentialsRoom;
+
+                    if (essentialsRoom != null) {
+                        if (!essentialsRoom.OnFeedback.BoolValue)
+                        {
+                            Debug.Console(1, this, "Powering Room on to default source");
+
+                            var defaultRouteRoom = Room as IRunDefaultPresentRoute;
+
+                            if (defaultRouteRoom != null)
+                            {
+                                defaultRouteRoom.RunDefaultPresentRoute();
+                            }
+                        }
                     }
+                    // Check room power state first
+                    
                 }
             }
         }

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

@@ -17,15 +17,10 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public interface IEssentialsRoom : IKeyName, IReconfigurableDevice, IRunDefaultPresentRoute, IEnvironmentalControls
     {
-        BoolFeedback OnFeedback { get; }
-
-        event EventHandler<EventArgs> RoomOccupancyIsSet;
+        BoolFeedback OnFeedback { get; }        
 
         BoolFeedback IsWarmingUpFeedback { get; }
-        BoolFeedback IsCoolingDownFeedback { get; }
-
-        IOccupancyStatusProvider RoomOccupancy { get; }
-        bool OccupancyStatusProviderIsRemote { get; }
+        BoolFeedback IsCoolingDownFeedback { get; }        
 
         bool IsMobileControlEnabled { get; }
         IMobileControlRoomBridge MobileControlRoomBridge { get; }
@@ -35,31 +30,16 @@ namespace PepperDash.Essentials.Core
         SecondsCountdownTimer ShutdownPromptTimer { get; }
         int ShutdownPromptSeconds { get; }
         int ShutdownVacancySeconds { get; }
-        eShutdownType ShutdownType { get; }
-
-        EssentialsRoomEmergencyBase Emergency { get; }
-
-        Core.Privacy.MicrophonePrivacyController MicrophonePrivacy { get; }
+        eShutdownType ShutdownType { get; }      
 
         string LogoUrlLightBkgnd { get; }
         string LogoUrlDarkBkgnd { get; }
 
-        eVacancyMode VacancyMode { get; }
+        void StartShutdown(eShutdownType type);        
 
-        bool ZeroVolumeWhenSwtichingVolumeDevices { get; }
+        void Shutdown();        
 
-        void StartShutdown(eShutdownType type);
-        void StartRoomVacancyTimer(eVacancyMode mode);
-
-        void Shutdown();
-
-        void SetRoomOccupancy(IOccupancyStatusProvider statusProvider, int timeoutMinutes);
-
-        void PowerOnToDefaultOrLastSource();
-
-        void SetDefaultLevels();
-
-        void RoomVacatedForTimeoutPeriod(object o);
+        void PowerOnToDefaultOrLastSource();               
     }
 
 }

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

@@ -41,7 +41,6 @@ namespace PepperDash.Essentials.Core
         void RunRouteAction(string routeKey, string sourceListKey);
 
         void RunRouteAction(string routeKey, string sourceListKey, Action successCallback);
-
     }
 
     /// <summary>
@@ -78,4 +77,30 @@ namespace PepperDash.Essentials.Core
         bool HasEnvironmentalControlDevices { get; }
     }
 
+    public interface IRoomOccupancy:IKeyed
+    {
+        IOccupancyStatusProvider RoomOccupancy { get; }
+        bool OccupancyStatusProviderIsRemote { get; }
+
+        void SetRoomOccupancy(IOccupancyStatusProvider statusProvider, int timeoutMinutes);
+
+        void RoomVacatedForTimeoutPeriod(object o);
+
+        void StartRoomVacancyTimer(eVacancyMode mode);
+
+        eVacancyMode VacancyMode { get; }
+
+        event EventHandler<EventArgs> RoomOccupancyIsSet;
+    }
+
+    public interface IEmergency
+    {
+        EssentialsRoomEmergencyBase Emergency { get; }
+    }
+
+    public interface IMicrophonePrivacy
+    {
+        Core.Privacy.MicrophonePrivacyController MicrophonePrivacy { get; }
+    }
+
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/Mpc3Touchpanel.cs

@@ -1,144 +1,295 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
+using System.Collections.Generic;
+using System.Globalization;
 using Crestron.SimplSharpPro;
-
+using Newtonsoft.Json;
 using PepperDash.Core;
-using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Core.Touchpanels
 {
-    /// <summary>
-    /// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
-    /// behavior of the keybad buttons
-    /// </summary>
-    public class Mpc3TouchpanelController : Device
-    {
-        MPC3Basic _Touchpanel;
+	/// <summary>
+	/// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
+	/// behavior of the keybad buttons
+	/// </summary>
+	public class Mpc3TouchpanelController : Device
+	{
+		readonly MPC3Basic _touchpanel;
 
-        Dictionary<string, KeypadButton> _Buttons;
+		readonly Dictionary<string, KeypadButton> _buttons;
 
-        public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
-            : base(key, name)
-        {
-            _Touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
-            _Buttons = buttons;
+		public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
+			: base(key, name)
+		{
+			_touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
+			if (_touchpanel == null)
+			{
+				Debug.Console(1, this, "Failed to construct MPC3 Touchpanel Controller with key {0}, check configuration", key);
+				return;
+			}
 
-            _Touchpanel.ButtonStateChange += new Crestron.SimplSharpPro.DeviceSupport.ButtonEventHandler(_Touchpanel_ButtonStateChange);
+			_touchpanel.ButtonStateChange += _touchpanel_ButtonStateChange;
+			_buttons = buttons;
+			if (_buttons == null)
+			{
+				Debug.Console(1, this,
+					"Button properties are null, failed to setup MPC3 Touch Controller, check configuration");
+				return;
+			}
 
-            AddPostActivationAction(() =>
-                {
-                    // Link up the button feedbacks to the specified BoolFeedbacks
-                    foreach (var button in _Buttons)
-                    {
-                        var feedbackConfig = button.Value.Feedback;
-                        var device = DeviceManager.GetDeviceForKey(feedbackConfig.DeviceKey) as Device;
-                        if (device != null)
-                        {
-                            var bKey = button.Key.ToLower();
+			AddPostActivationAction(() =>
+			{
+				foreach (var button in _buttons)
+				{
+					var buttonKey = button.Key.ToLower();
+					var buttonConfig = button.Value;
 
-                            var feedback = device.GetFeedbackProperty(feedbackConfig.FeedbackName);
+					InitializeButton(buttonKey, buttonConfig);
+					InitializeButtonFeedback(buttonKey, buttonConfig);
+				}
+			});
+		}
 
-                            var bFeedback = feedback as BoolFeedback;
-                            var iFeedback = feedback as IntFeedback;
-                            if (bFeedback != null)
-                            {
+		/// <summary>
+		/// Enables/disables buttons based on event type configuration 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="config"></param>
+		public void InitializeButton(string key, KeypadButton config)
+		{
+			if (config == null)
+			{
+				Debug.Console(1, this, "Button '{0}' config is null, unable to initialize", key);
+				return;
+			}
 
-                                if (bKey == "power")
-                                {
-                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackPower);
-                                    continue;
-                                }
-                                else if (bKey == "mute")
-                                {
-                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackMute);
-                                    continue;
-                                }
+			int buttonNumber;
+			TryParseInt(key, out buttonNumber);
 
-                                // Link to the Crestron Feedback corresponding to the button number
-                                bFeedback.LinkCrestronFeedback(_Touchpanel.Feedbacks[UInt16.Parse(button.Key)]);
-                            }
-                            else if (iFeedback != null)
-                            {
-                                if (bKey == "volumefeedback")
-                                {
-                                    var volFeedback = feedback as IntFeedback;
-                                    // TODO: Figure out how to subsribe to a volume IntFeedback and link it to the voluem
-                                    volFeedback.LinkInputSig(_Touchpanel.VolumeBargraph);
-                                }
-                            }
-                            else
-                            {
-                                Debug.Console(1, this, "Unable to get BoolFeedback with name: {0} from device: {1}", feedbackConfig.FeedbackName, device.Key);
-                            }
-                        }
-                        else
-                        {
-                            Debug.Console(1, this, "Unable to get device with key: {0}", feedbackConfig.DeviceKey);
-                        }
-                    }
-                });
-        }
+			var buttonEventTypes = config.EventTypes;
 
-        void _Touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
-        {
-            Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
-            var type = args.NewButtonState.ToString();
+			switch (key)
+			{
+				case ("power"):
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisablePowerButton();
+						else
+							_touchpanel.EnablePowerButton();
 
-            if (_Buttons.ContainsKey(args.Button.Number.ToString()))
-            {
-                Press(args.Button.Number.ToString(), type);
-            }
-            else if(_Buttons.ContainsKey(args.Button.Name.ToString()))
-            {
-                Press(args.Button.Name.ToString(), type);
-            }
-        }
+						break;
+					}
+				case ("volumeup"):
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisableVolumeUpButton();
 
-        /// <summary>
-        /// Runs the function associated with this button/type. One of the following strings:
-        /// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
-        /// </summary>
-        /// <param name="number"></param>
-        /// <param name="type"></param>
-        public void Press(string number, string type)
-        {
-            // TODO: In future, consider modifying this to generate actions at device activation time
-            //       to prevent the need to dynamically call the method via reflection on each button press
-            if (!_Buttons.ContainsKey(number)) { return; }
-            var but = _Buttons[number];
-            if (but.EventTypes.ContainsKey(type))
-            {
-                foreach (var a in but.EventTypes[type]) { DeviceJsonApi.DoDeviceAction(a); }
-            }
-        }
+						break;
+					}
+				case ("volumedown"):
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisableVolumeDownButton();
 
+						break;
+					}
+				case ("volumefeedback"):
+					{
 
-    }
+						break;
+					}
+				case ("mute"):
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisableMuteButton();
+						else
+							_touchpanel.EnableMuteButton();
 
-    /// <summary>
-    /// Represents the configuration of a keybad buggon
-    /// </summary>
-    public class KeypadButton
-    {
-        public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
-        public KeypadButtonFeedback Feedback { get; set; }
+						break;
+					}
+				default:
+					{
+						if (buttonNumber == 0)
+							break;
 
-        public KeypadButton()
-        {
-            EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
-            Feedback = new KeypadButtonFeedback();
-        }
-    }
+						if (buttonEventTypes == null)
+							_touchpanel.DisableNumericalButton((uint)buttonNumber);
+						else
+							_touchpanel.EnableNumericalButton((uint)buttonNumber);
 
-    /// <summary>
-    /// 
-    /// </summary>
-    public class KeypadButtonFeedback
-    {
-        public string DeviceKey { get; set; }
-        public string FeedbackName { get; set; }
-    }
+						break;
+					}
+			}
+
+			Debug.Console(1, this, "Button '{0}' {1}", key, buttonEventTypes == null
+				? "is disabled, verify eventTypes are configured."
+				: "is enabled");
+		}
+
+		/// <summary>
+		/// Links button feedback if configured
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="config"></param>
+		public void InitializeButtonFeedback(string key, KeypadButton config)
+		{
+			if (config == null)
+			{
+				Debug.Console(1, this, "Button '{0}' config is null, unable to initialize feedback", key);
+				return;
+			}
+
+			int buttonNumber;
+			TryParseInt(key, out buttonNumber);
+
+			// Link up the button feedbacks to the specified device feedback
+			var buttonFeedback = config.Feedback;
+			if (buttonFeedback == null)
+			{
+				Debug.Console(1, this, "Button '{0}' feedback not configured and will not be implemented. Verify feedback is configured if required.", key);
+				return;
+			}
+
+			var device = DeviceManager.GetDeviceForKey(buttonFeedback.DeviceKey) as Device;
+			if (device == null)
+			{
+				Debug.Console(1, this, "Button '{0}' feedback device with key '{0}' not found, feedback will not be implemented.  Verify feedback deviceKey is properly configured.",
+					buttonFeedback.DeviceKey);
+				return;
+			}
+
+			// TODO [ ] verify if this can replace the current method
+			var deviceFeedback = device.GetFeedbackProperty(buttonFeedback.FeedbackName);
+			Debug.Console(0, this, "deviceFeedback.GetType().Name: '{0}'", deviceFeedback.GetType().Name);
+			//switch (feedback.GetType().Name.ToLower())
+			//{
+			//    case("boolfeedback"):
+			//    {
+			//        break;
+			//    }
+			//    case("intfeedback"):
+			//    {
+			//        break;
+			//    }
+			//    case("stringfeedback"):
+			//    {
+			//        break;
+			//    }
+			//}
+
+			var boolFeedback = deviceFeedback as BoolFeedback;
+			var intFeedback = deviceFeedback as IntFeedback;
+
+			switch (key)
+			{
+				case ("power"):
+					{
+						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.FeedbackPower);
+						break;
+					}
+				case ("volumeup"):
+				case ("volumedown"):
+				case ("volumefeedback"):
+					{
+						if (intFeedback != null)
+						{
+							var volumeFeedback = intFeedback;
+							volumeFeedback.LinkInputSig(_touchpanel.VolumeBargraph);
+						}
+						break;
+					}
+				case ("mute"):
+					{
+						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.FeedbackMute);
+						break;
+					}
+				default:
+					{
+						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.Feedbacks[(uint)buttonNumber]);
+						break;
+					}
+			}
+		}
+
+		/// <summary>
+		/// Try parse int helper method
+		/// </summary>
+		/// <param name="str"></param>
+		/// <param name="result"></param>
+		/// <returns></returns>
+		public bool TryParseInt(string str, out int result)
+		{
+			try
+			{
+				result = int.Parse(str);
+				return true;
+			}
+			catch
+			{
+				result = 0;
+				return false;
+			}
+		}
+
+		private void _touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
+		{
+			Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
+			var type = args.NewButtonState.ToString();
+
+			if (_buttons.ContainsKey(args.Button.Number.ToString(CultureInfo.InvariantCulture)))
+			{
+				Press(args.Button.Number.ToString(CultureInfo.InvariantCulture), type);
+			}
+			else if (_buttons.ContainsKey(args.Button.Name.ToString()))
+			{
+				Press(args.Button.Name.ToString(), type);
+			}
+		}
+
+		/// <summary>
+		/// Runs the function associated with this button/type. One of the following strings:
+		/// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
+		/// </summary>
+		/// <param name="buttonKey"></param>
+		/// <param name="type"></param>
+		public void Press(string buttonKey, string type)
+		{
+			// TODO: In future, consider modifying this to generate actions at device activation time
+			//       to prevent the need to dynamically call the method via reflection on each button press
+			if (!_buttons.ContainsKey(buttonKey)) return;
+
+			var button = _buttons[buttonKey];
+			if (!button.EventTypes.ContainsKey(type)) return;
+
+			foreach (var eventType in button.EventTypes[type]) DeviceJsonApi.DoDeviceAction(eventType);
+		}
+	}
+
+	/// <summary>
+	/// Represents the configuration of a keypad button
+	/// </summary>
+	public class KeypadButton
+	{
+		[JsonProperty("eventTypes")]
+		public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
+
+		[JsonProperty("feedback")]
+		public KeypadButtonFeedback Feedback { get; set; }
+
+		public KeypadButton()
+		{
+			EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
+			Feedback = new KeypadButtonFeedback();
+		}
+	}
+
+	/// <summary>
+	/// Represents the configuration of a keypad button feedback
+	/// </summary>
+	public class KeypadButtonFeedback
+	{
+		[JsonProperty("deviceKey")]
+		public string DeviceKey { get; set; }
+
+		[JsonProperty("feedbackName")]
+		public string FeedbackName { get; set; }
+	}
 }