fix: update DMPS InputChange event handler

In some configurations, the InputChange handler can throw
a null reference exception due to a Feedback for
the input that triggered the event not existing. The
event handler now checks for the existence of a Feedback
for the input that triggered the event prior to attempting
to call the `FireUpdate` method. Addresses #1136

PepperDashEssentials/ControlSystem.cs

@@ -401,20 +401,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"];
+							var butToken = devConf.Properties["buttons"];
-                            if (butToken != null)
+							if (butToken == null)
-                            {
+							{
-                                var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
+								Debug.Console(0, Debug.ErrorLogLevel.Error,
-                                var tpController = new Essentials.Core.Touchpanels.Mpc3TouchpanelController(devConf.Key, devConf.Name, Global.ControlSystem, buttons);
+									"Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
-                                DeviceManager.AddDevice(tpController);
+								continue;
-                            }
+							}
-                            else
+
-                            {
+							var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
-                                Debug.Console(0, Debug.ErrorLogLevel.Error, "Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
+							var tpController = new Core.Touchpanels.Mpc3TouchpanelController(
-                            }
+									string.Format("{0}-keypadButtons", devConf.Key), devConf.Name, Global.ControlSystem, buttons);
-                            
+
+							DeviceManager.AddDevice(tpController);	
                         }
                         else
                         {

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

@@ -1,144 +1,295 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
+using System.Globalization;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-
+using Newtonsoft.Json;
 using PepperDash.Core;
-using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Core.Touchpanels
 {
-    /// <summary>
+	/// <summary>
-    /// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
+	/// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
-    /// behavior of the keybad buttons
+	/// behavior of the keybad buttons
-    /// </summary>
+	/// </summary>
-    public class Mpc3TouchpanelController : Device
+	public class Mpc3TouchpanelController : Device
-    {
+	{
-        MPC3Basic _Touchpanel;
+		readonly MPC3Basic _touchpanel;
 
-        Dictionary<string, KeypadButton> _Buttons;
+		readonly Dictionary<string, KeypadButton> _buttons;
 
-        public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
+		public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
-            : base(key, name)
+			: base(key, name)
-        {
+		{
-            _Touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
+			_touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
-            _Buttons = buttons;
+			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(() =>
+			AddPostActivationAction(() =>
-                {
+			{
-                    // Link up the button feedbacks to the specified BoolFeedbacks
+				foreach (var button in _buttons)
-                    foreach (var button in _Buttons)
+				{
-                    {
+					var buttonKey = button.Key.ToLower();
-                        var feedbackConfig = button.Value.Feedback;
+					var buttonConfig = button.Value;
-                        var device = DeviceManager.GetDeviceForKey(feedbackConfig.DeviceKey) as Device;
-                        if (device != null)
-                        {
-                            var bKey = button.Key.ToLower();
 
-                            var feedback = device.GetFeedbackProperty(feedbackConfig.FeedbackName);
+					InitializeButton(buttonKey, buttonConfig);
+					InitializeButtonFeedback(buttonKey, buttonConfig);
+				}
+			});
+		}
 
-                            var bFeedback = feedback as BoolFeedback;
+		/// <summary>
-                            var iFeedback = feedback as IntFeedback;
+		/// Enables/disables buttons based on event type configuration 
-                            if (bFeedback != null)
+		/// </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")
+			int buttonNumber;
-                                {
+			TryParseInt(key, out buttonNumber);
-                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackPower);
-                                    continue;
-                                }
-                                else if (bKey == "mute")
-                                {
-                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackMute);
-                                    continue;
-                                }
 
-                                // Link to the Crestron Feedback corresponding to the button number
+			var buttonEventTypes = config.EventTypes;
-                                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);
-                        }
-                    }
-                });
-        }
 
-        void _Touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
+			switch (key)
-        {
+			{
-            Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
+				case ("power"):
-            var type = args.NewButtonState.ToString();
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisablePowerButton();
+						else
+							_touchpanel.EnablePowerButton();
 
-            if (_Buttons.ContainsKey(args.Button.Number.ToString()))
+						break;
-            {
+					}
-                Press(args.Button.Number.ToString(), type);
+				case ("volumeup"):
-            }
+					{
-            else if(_Buttons.ContainsKey(args.Button.Name.ToString()))
+						if (buttonEventTypes == null)
-            {
+							_touchpanel.DisableVolumeUpButton();
-                Press(args.Button.Name.ToString(), type);
-            }
-        }
 
-        /// <summary>
+						break;
-        /// Runs the function associated with this button/type. One of the following strings:
+					}
-        /// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
+				case ("volumedown"):
-        /// </summary>
+					{
-        /// <param name="number"></param>
+						if (buttonEventTypes == null)
-        /// <param name="type"></param>
+							_touchpanel.DisableVolumeDownButton();
-        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 ("volumefeedback"):
+					{
 
-    }
+						break;
+					}
+				case ("mute"):
+					{
+						if (buttonEventTypes == null)
+							_touchpanel.DisableMuteButton();
+						else
+							_touchpanel.EnableMuteButton();
 
-    /// <summary>
+						break;
-    /// Represents the configuration of a keybad buggon
+					}
-    /// </summary>
+				default:
-    public class KeypadButton
+					{
-    {
+						if (buttonNumber == 0)
-        public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
+							break;
-        public KeypadButtonFeedback Feedback { get; set; }
 
-        public KeypadButton()
+						if (buttonEventTypes == null)
-        {
+							_touchpanel.DisableNumericalButton((uint)buttonNumber);
-            EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
+						else
-            Feedback = new KeypadButtonFeedback();
+							_touchpanel.EnableNumericalButton((uint)buttonNumber);
-        }
-    }
 
-    /// <summary>
+						break;
-    /// 
+					}
-    /// </summary>
+			}
-    public class KeypadButtonFeedback
+
-    {
+			Debug.Console(1, this, "Button '{0}' {1}", key, buttonEventTypes == null
-        public string DeviceKey { get; set; }
+				? "is disabled, verify eventTypes are configured."
-        public string FeedbackName { get; set; }
+				: "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; }
+	}
 }

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

@@ -991,28 +991,41 @@ namespace PepperDash.Essentials.DM
                     case (DMInputEventIds.OnlineFeedbackEventId):
                         {
                             Debug.Console(2, this, "DM Input OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
-                            InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+
+							if(!InputEndpointOnlineFeedbacks.ContainsKey(args.Number)){
+								break;
+							}
+							InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.EndpointOnlineEventId):
                         {
                             Debug.Console(2, this, "DM Input EndpointOnlineEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+
+							if(!InputEndpointOnlineFeedbacks.ContainsKey(args.Number)){
+								break;
+							}
                             InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.VideoDetectedEventId):
                         {
                             Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
+
+							if(!VideoInputSyncFeedbacks.ContainsKey(args.Number)){
+								break;
+							}
                             VideoInputSyncFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.InputNameEventId):
                         {
                             Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
-                            if(InputNameFeedbacks.ContainsKey(args.Number))
+                            if(!InputNameFeedbacks.ContainsKey(args.Number))
                             {
-                                InputNameFeedbacks[args.Number].FireUpdate();
+								break;
                             }
+							InputNameFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                 }