fix: debounce device info events

In some cases, multiple device info update events are triggering,
causing the queue to be flooded with multiple unneccessary messages containing the same info.
This clogs the queue and makes it harder for UIs to come online when Essentials restarts,
especially in systems with a lot of NVX devices.

The events are now debounced. If there are no new messages for 1 second, then the MC message
is sent out.

.gitignore

@@ -393,5 +393,4 @@ essentials-framework/Essentials Interfaces/PepperDash_Essentials_Interfaces/Pepp
 /._PepperDash.Essentials.sln
 .vscode/settings.json
 _site/
-api/
-*.DS_Store
+api/

src/PepperDash.Core/Device.cs

@@ -11,35 +11,35 @@ namespace PepperDash.Core
 	public class Device : IKeyName
 	{
 
-        /// <summary>
-        /// Unique Key
-        /// </summary>
+		/// <summary>
+		/// Unique Key
+		/// </summary>
 		public string Key { get; protected set; }
 		/// <summary>
 		/// Name of the devie
 		/// </summary>
-        public string Name { get; protected set; }
-        /// <summary>
-        /// 
-        /// </summary>
+		public string Name { get; protected set; }
+		/// <summary>
+		/// 
+		/// </summary>
 		public bool Enabled { get; protected set; }
 
-        ///// <summary>
-        ///// A place to store reference to the original config object, if any. These values should 
-        ///// NOT be used as properties on the device as they are all publicly-settable values.
-        ///// </summary>
-        //public DeviceConfig Config { get; private set; }
-        ///// <summary>
-        ///// Helper method to check if Config exists
-        ///// </summary>
-        //public bool HasConfig { get { return Config != null; } }
+		///// <summary>
+		///// A place to store reference to the original config object, if any. These values should 
+		///// NOT be used as properties on the device as they are all publicly-settable values.
+		///// </summary>
+		//public DeviceConfig Config { get; private set; }
+		///// <summary>
+		///// Helper method to check if Config exists
+		///// </summary>
+		//public bool HasConfig { get { return Config != null; } }
 
 		List<Action> _PreActivationActions;
 		List<Action> _PostActivationActions;
 
-        /// <summary>
-        /// 
-        /// </summary>
+		/// <summary>
+		/// 
+		/// </summary>
 		public static Device DefaultDevice { get { return _DefaultDevice; } }
 		static Device _DefaultDevice = new Device("Default", "Default");
 
@@ -54,27 +54,27 @@ namespace PepperDash.Core
 			Name = "";
 		}
 
-        /// <summary>
-        /// Constructor with key and name
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="name"></param>
+		/// <summary>
+		/// Constructor with key and name
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
 		public Device(string key, string name) : this(key)
 		{
 			Name = name;
 
 		}
 
-        //public Device(DeviceConfig config)
-        //    : this(config.Key, config.Name)
-        //{
-        //    Config = config;
-        //}
+		//public Device(DeviceConfig config)
+		//    : this(config.Key, config.Name)
+		//{
+		//    Config = config;
+		//}
 
-        /// <summary>
-        /// Adds a pre activation action
-        /// </summary>
-        /// <param name="act"></param>
+		/// <summary>
+		/// Adds a pre activation action
+		/// </summary>
+		/// <param name="act"></param>
 		public void AddPreActivationAction(Action act)
 		{
 			if (_PreActivationActions == null)
@@ -82,10 +82,10 @@ namespace PepperDash.Core
 			_PreActivationActions.Add(act);
 		}
 
-        /// <summary>
-        /// Adds a post activation action
-        /// </summary>
-        /// <param name="act"></param>
+		/// <summary>
+		/// Adds a post activation action
+		/// </summary>
+		/// <param name="act"></param>
 		public void AddPostActivationAction(Action act)
 		{
 			if (_PostActivationActions == null)
@@ -93,55 +93,58 @@ namespace PepperDash.Core
 			_PostActivationActions.Add(act);
 		}
 
-        /// <summary>
-        /// Executes the preactivation actions
-        /// </summary>
-        public void PreActivate()
-        {
-            if (_PreActivationActions != null)
-                _PreActivationActions.ForEach(a => {
+		/// <summary>
+		/// Executes the preactivation actions
+		/// </summary>
+		public void PreActivate()
+		{
+			if (_PreActivationActions != null)
+				_PreActivationActions.ForEach(a =>
+				{
 					try
 					{
 						a.Invoke();
-					} catch (Exception e)
-					{ 
+					}
+					catch (Exception e)
+					{
 						Debug.LogMessage(e, "Error in PreActivationAction: " + e.Message, this);
 					}
-            });
-        }
+				});
+		}
 
 		/// <summary>
 		/// Gets this device ready to be used in the system. Runs any added pre-activation items, and
 		/// all post-activation at end. Classes needing additional logic to 
 		/// run should override CustomActivate()
 		/// </summary>
-		public bool Activate() 
+		public bool Activate()
 		{
-            //if (_PreActivationActions != null)
-            //    _PreActivationActions.ForEach(a => a.Invoke());
+			//if (_PreActivationActions != null)
+			//    _PreActivationActions.ForEach(a => a.Invoke());
 			var result = CustomActivate();
-            //if(result && _PostActivationActions != null)
-            //    _PostActivationActions.ForEach(a => a.Invoke());
-			return result; 	
+			//if(result && _PostActivationActions != null)
+			//    _PostActivationActions.ForEach(a => a.Invoke());
+			return result;
 		}
 
-        /// <summary>
-        /// Executes the postactivation actions
-        /// </summary>
-        public void PostActivate()
-        {
-            if (_PostActivationActions != null)
-                _PostActivationActions.ForEach(a => {
-                    try
-                    {
-                        a.Invoke();
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.LogMessage(e, "Error in PostActivationAction: " + e.Message, this);
-                    }
-                });
-        }
+		/// <summary>
+		/// Executes the postactivation actions
+		/// </summary>
+		public void PostActivate()
+		{
+			if (_PostActivationActions != null)
+				_PostActivationActions.ForEach(a =>
+				{
+					try
+					{
+						a.Invoke();
+					}
+					catch (Exception e)
+					{
+						Debug.LogMessage(e, "Error in PostActivationAction: " + e.Message, this);
+					}
+				});
+		}
 
 		/// <summary>
 		/// Called in between Pre and PostActivationActions when Activate() is called. 
@@ -158,14 +161,14 @@ namespace PepperDash.Core
 		/// <returns></returns>
 		public virtual bool Deactivate() { return true; }
 
-        /// <summary>
-        /// Call this method to start communications with a device. Overriding classes do not need to call base.Initialize()
-        /// </summary>
-	    public virtual void Initialize()
-	    {
-	    }
+		/// <summary>
+		/// Call this method to start communications with a device. Overriding classes do not need to call base.Initialize()
+		/// </summary>
+		public virtual void Initialize()
+		{
+		}
 
-	    /// <summary>
+		/// <summary>
 		/// Helper method to check object for bool value false and fire an Action method
 		/// </summary>
 		/// <param name="o">Should be of type bool, others will be ignored</param>
@@ -175,5 +178,15 @@ namespace PepperDash.Core
 			if (o is bool && !(bool)o) a();
 		}
 
+        /// <summary>
+        /// Returns a string representation of the object, including its key and name.
+        /// </summary>
+        /// <remarks>The returned string is formatted as "{Key} - {Name}". If the <c>Name</c> property is
+        /// null or empty,  "---" is used in place of the name.</remarks>
+        /// <returns>A string that represents the object, containing the key and name in the format "{Key} - {Name}".</returns>
+		public override string ToString()
+		{
+			return string.Format("{0} - {1}", Key, string.IsNullOrEmpty(Name) ? "---" : Name);
+		}
 	}
 }

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

@@ -248,7 +248,7 @@ namespace PepperDash.Essentials.Core
 
             foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
             {
-                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}{Environment.NewLine}");
+                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}\r\n");
             }
         }
 

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

@@ -20,19 +20,20 @@ namespace PepperDash.Essentials.Core
         public event EventHandler Initialized;
 
         private bool _isInitialized;
-        public bool IsInitialized { 
+        public bool IsInitialized
+        {
             get { return _isInitialized; }
-            private set 
-            { 
+            private set
+            {
                 if (_isInitialized == value) return;
-                
+
                 _isInitialized = value;
 
                 if (_isInitialized)
                 {
                     Initialized?.Invoke(this, new EventArgs());
                 }
-            } 
+            }
         }
 
         protected EssentialsDevice(string key)
@@ -80,8 +81,9 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Override this method to build and create custom Mobile Control Messengers during the Activation phase
         /// </summary>
-        protected virtual void CreateMobileControlMessengers() {
-           
+        protected virtual void CreateMobileControlMessengers()
+        {
+
         }
     }
 

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

@@ -9,15 +9,10 @@ using PepperDash.Essentials.Core.Devices;
 
 namespace PepperDash.Essentials.Core
 {
-    /// <summary>
-    /// Represents a level control item in a list, which can be used to control volume or mute functionality.
-    /// </summary>
     public class LevelControlListItem : AudioControlListItemBase
     {
 
-        /// <summary>
-        /// A reference to the IBasicVolumeWithFeedback device for control.
-        /// </summary>
+
         [JsonIgnore]
         public IBasicVolumeWithFeedback LevelControl
         {
@@ -60,7 +55,7 @@ namespace PepperDash.Essentials.Core
         {
             get
             {
-                if (string.IsNullOrEmpty(ItemKey)) return ParentDeviceKey;
+                if(string.IsNullOrEmpty(ItemKey)) return ParentDeviceKey;
                 else
                 {
                     return DeviceManager.AllDevices.
@@ -75,39 +70,13 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("type")]
         [JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
         public eLevelControlType Type { get; set; }
-
-
-        /// <summary>
-        /// Indicates if the item is a mic or not.
-        /// </summary>
-        [JsonProperty("isMic", NullValueHandling = NullValueHandling.Ignore)]
-        public bool? IsMic { get; set; }
-
-        /// <summary>
-        /// Indicates if the item should show the raw level in the UI.
-        /// </summary>
-        [JsonProperty("showRawLevel", NullValueHandling = NullValueHandling.Ignore)]
-        public bool? ShowRawLevel { get; set; }
     }
 
-    /// <summary>
-    /// Indicates the type of level control item.
-    /// </summary>
     [Flags]
     public enum eLevelControlType
     {
-        /// <summary>
-        /// Indicates that the item is a level control only
-        /// </summary>
         Level = 1,
-        /// <summary>
-        /// Indicates that the item is a mute control only
-        /// </summary>
         Mute = 2,
-        /// <summary>
-        /// Indicates that the item is both a level and mute control
-        /// </summary>
         LevelAndMute = Level | Mute,
     }
-
 }

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

@@ -10,18 +10,7 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public enum eSourceListItemType
     {
-        /// <summary>
-        /// Represents a typical route.
-        /// </summary>
-        Route,
-        /// <summary>
-        /// Represents an off route.
-        /// </summary>
-        Off,
-        /// <summary>
-        /// Represents some other type of route
-        /// </summary>
-        Other,
+        Route, Off, Other, SomethingAwesomerThanThese
     }
 
     /// <summary>
@@ -29,9 +18,6 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class SourceListItem
     {
-        /// <summary>
-        /// The key of the source item, which is used to identify it in the DeviceManager
-        /// </summary>
         [JsonProperty("sourceKey")]
         public string SourceKey { get; set; }
 
@@ -131,9 +117,6 @@ namespace PepperDash.Essentials.Core
 		[JsonProperty("disableRoutedSharing")]
         public bool DisableRoutedSharing { get; set; }
 
-        /// <summary>
-        /// 
-        /// </summary>
         [JsonProperty("destinations")]
         public List<eSourceListItemDestinationTypes> Destinations { get; set; }
         /// <summary>
@@ -166,56 +149,31 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("disableSimpleRouting")]
         public bool DisableSimpleRouting { get; set; }
 
-        /// <summary>
-        /// Default constructor for SourceListItem, initializes the Icon to "Blank"
-        /// </summary>
         public SourceListItem()
         {
             Icon = "Blank";
         }
 
-        /// <summary>
-        /// Returns a string representation of the SourceListItem, including the SourceKey and Name
-        /// </summary>
-        /// <returns></returns>
         public override string ToString()
         {
             return $"{SourceKey}:{Name}";
         }
     }
 
-    /// <summary>
-    /// Represents a route in a source list item, which defines the source and destination keys and the type of signal being routed
-    /// </summary>
     public class SourceRouteListItem
     {
-        /// <summary>
-        /// The key of the source device to route from
-        /// </summary>
         [JsonProperty("sourceKey")]
         public string SourceKey { get; set; }
 
-        /// <summary>
-        /// The key of the source port to route from
-        /// </summary>
         [JsonProperty("sourcePortKey")]
         public string SourcePortKey { get; set; }
 
-        /// <summary>
-        /// The key of the destination device to route to
-        /// </summary>
         [JsonProperty("destinationKey")]
         public string DestinationKey { get; set; }
 
-        /// <summary>
-        /// The key of the destination port to route to
-        /// </summary>
         [JsonProperty("destinationPortKey")]
         public string DestinationPortKey { get; set; }
 
-        /// <summary>
-        /// The type of signal being routed, such as audio or video
-        /// </summary>
         [JsonProperty("type")]
         public eRoutingSignalType Type { get; set; }
     }
@@ -225,85 +183,15 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public enum eSourceListItemDestinationTypes
     {
-        /// <summary>
-        /// Default display, used for the main video output in a room
-        /// </summary>
         defaultDisplay,
-        /// <summary>
-        /// Left display
-        /// </summary>
         leftDisplay,
-        /// <summary>
-        /// Right display
-        /// </summary>
         rightDisplay,
-        /// <summary>
-        /// Center display
-        /// </summary>
         centerDisplay,
-        /// <summary>
-        /// Program audio, used for the main audio output in a room
-        /// </summary>
         programAudio,
-        /// <summary>
-        /// Codec content, used for sharing content to the far end in a video call
-        /// </summary>
         codecContent,
-        /// <summary>
-        /// Front left display, used for rooms with multiple displays
-        /// </summary>
         frontLeftDisplay,
-        /// <summary>
-        /// Front right display, used for rooms with multiple displays
-        /// </summary>
         frontRightDisplay,
-        /// <summary>
-        /// Rear left display, used for rooms with multiple displays
-        /// </summary>
         rearLeftDisplay,
-        /// <summary>
-        /// Rear right display, used for rooms with multiple displays
-        /// </summary>
         rearRightDisplay,
-        /// <summary>
-        /// Auxiliary display 1, used for additional displays in a room
-        /// </summary>
-        auxDisplay1,
-        /// <summary>
-        /// Auxiliary display 2, used for additional displays in a room
-        /// </summary>
-        auxDisplay2,
-        /// <summary>
-        /// Auxiliary display 3, used for additional displays in a room
-        /// </summary>
-        auxDisplay3,
-        /// <summary>
-        /// Auxiliary display 4, used for additional displays in a room
-        /// </summary>
-        auxDisplay4,
-        /// <summary>
-        /// Auxiliary display 5, used for additional displays in a room
-        /// </summary>
-        auxDisplay5,
-        /// <summary>
-        /// Auxiliary display 6, used for additional displays in a room
-        /// </summary>
-        auxDisplay6,
-        /// <summary>
-        /// Auxiliary display 7, used for additional displays in a room
-        /// </summary>
-        auxDisplay7,
-        /// <summary>
-        /// Auxiliary display 8, used for additional displays in a room
-        /// </summary>
-        auxDisplay8,
-        /// <summary>
-        /// Auxiliary display 9, used for additional displays in a room
-        /// </summary>
-        auxDisplay9,
-        /// <summary>
-        /// Auxiliary display 10, used for additional displays in a room
-        /// </summary>
-        auxDisplay10,
     }
 }

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

@@ -7,14 +7,8 @@
     {        
     }
 
-    /// <summary>
-    /// For fixed-source endpoint devices with an input port
-    /// </summary>
     public interface IRoutingSinkWithInputPort :IRoutingSink
     {
-        /// <summary>
-        /// Gets the current input port for this routing sink.
-        /// </summary>
         RoutingInputPort CurrentInputPort { get; }
     }
     /*/// <summary>

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

@@ -3,60 +3,29 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using PepperDash.Core;
+
 using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Devices.Common.Cameras
 {
-    /// <summary>
-    /// Enum for camera control modes
-    /// </summary>
     public enum eCameraControlMode
-    {
-        /// <summary>
-        /// Manual control mode, where the camera is controlled directly by the user or system
-        /// </summary>
+    {       
         Manual = 0,
-        /// <summary>
-        /// Off control mode, where the camera is turned off or disabled
-        /// </summary>
         Off,
-        /// <summary>
-        ///  Auto control mode, where the camera automatically adjusts settings based on the environment or conditions
-        /// </summary>
         Auto
     }
 
 
-    /// <summary>
-    /// Interface for devices that have cameras
-    /// </summary>
-    public interface IHasCameras : IKeyName
+    public interface IHasCameras
     {
-        /// <summary>
-        /// Event that is raised when a camera is selected
-        /// </summary>
         event EventHandler<CameraSelectedEventArgs> CameraSelected;
 
-        /// <summary>
-        /// List of cameras on the device.  This should be a list of CameraBase objects
-        /// </summary>
         List<CameraBase> Cameras { get; }
 
-        /// <summary>
-        /// The currently selected camera.  This should be a CameraBase object
-        /// </summary>
         CameraBase SelectedCamera { get; }
 
-        /// <summary>
-        /// Feedback that indicates the currently selected camera
-        /// </summary>
         StringFeedback SelectedCameraFeedback { get; }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="key"></param>
         void SelectCamera(string key);
     }
 
@@ -73,14 +42,7 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraOff
     {
-        /// <summary>
-        /// Feedback that indicates whether the camera is off
-        /// </summary>
         BoolFeedback CameraIsOffFeedback { get; }
-
-        /// <summary>
-        /// Turns the camera off, blanking the near end video
-        /// </summary>
         void CameraOff();
     }
 
@@ -89,71 +51,31 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraMute
     {
-        /// <summary>
-        /// Feedback that indicates whether the camera is muted
-        /// </summary>
         BoolFeedback CameraIsMutedFeedback { get; }
-
-        /// <summary>
-        /// Mutes the camera video, preventing it from being sent to the far end
-        /// </summary>
         void CameraMuteOn();
-
-        /// <summary>
-        /// Unmutes the camera video, allowing it to be sent to the far end
-        /// </summary>
         void CameraMuteOff();
-
-        /// <summary>
-        /// Toggles the camera mute state. If the camera is muted, it will be unmuted, and vice versa.
-        /// </summary>
         void CameraMuteToggle();
     }
 
-    /// <summary>
-    /// Interface for devices that can mute and unmute their camera video, with an event for unmute requests
-    /// </summary>
     public interface IHasCameraMuteWithUnmuteReqeust : IHasCameraMute
     {
-        /// <summary>
-        /// Event that is raised when a video unmute is requested, typically by the far end
-        /// </summary>
         event EventHandler VideoUnmuteRequested;
     }
 
-    /// <summary>
-    /// Event arguments for the CameraSelected event
-    /// </summary>
     public class CameraSelectedEventArgs : EventArgs
     {
-        /// <summary>
-        /// The selected camera
-        /// </summary>
         public CameraBase SelectedCamera { get; private set; }
 
-        /// <summary>
-        /// Constructor for CameraSelectedEventArgs
-        /// </summary>
-        /// <param name="camera"></param>
         public CameraSelectedEventArgs(CameraBase camera)
         {
             SelectedCamera = camera;
         }
     }
 
-    /// <summary>
-    /// Interface for devices that have a far end camera control
-    /// </summary>
     public interface IHasFarEndCameraControl
     {
-        /// <summary>
-        /// Gets the far end camera, which is typically a CameraBase object that represents the camera at the far end of a call
-        /// </summary>
         CameraBase FarEndCamera { get; }
 
-        /// <summary>
-        /// Feedback that indicates whether the far end camera is being controlled
-        /// </summary>
         BoolFeedback ControllingFarEndCameraFeedback { get; }
 
     }
@@ -166,9 +88,6 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
 
     }
 
-    /// <summary>
-    /// Interface for devices that have camera controls
-    /// </summary>
     public interface IHasCameraControls
     {
     }
@@ -189,19 +108,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraPanControl : IHasCameraControls
     {
-        /// <summary>
-        /// Pans the camera left
-        /// </summary>
         void PanLeft();
-
-        /// <summary>
-        /// Pans the camera right
-        /// </summary>
         void PanRight();
-
-        /// <summary>
-        /// Stops the camera pan movement
-        /// </summary>
         void PanStop();
     }
 
@@ -210,19 +118,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraTiltControl : IHasCameraControls
     {
-        /// <summary>
-        /// Tilts the camera down
-        /// </summary>
         void TiltDown();
-
-        /// <summary>
-        /// Tilts the camera up
-        /// </summary>
         void TiltUp();
-
-        /// <summary>
-        /// Stops the camera tilt movement
-        /// </summary>
         void TiltStop();
     }
 
@@ -231,19 +128,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraZoomControl : IHasCameraControls
     {
-        /// <summary>
-        /// Zooms the camera in
-        /// </summary>
         void ZoomIn();
-
-        /// <summary>
-        /// Zooms the camera out
-        /// </summary>
         void ZoomOut();
-
-        /// <summary>
-        /// Stops the camera zoom movement
-        /// </summary>
         void ZoomStop();
     }
 
@@ -252,71 +138,25 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraFocusControl : IHasCameraControls
     {
-        /// <summary>
-        /// Focuses the camera near
-        /// </summary>
         void FocusNear();
-
-        /// <summary>
-        /// Focuses the camera far
-        /// </summary>
         void FocusFar();
-
-        /// <summary>
-        /// Stops the camera focus movement
-        /// </summary>
         void FocusStop();
 
-        /// <summary>
-        /// Triggers the camera's auto focus functionality, if available.
-        /// </summary>
         void TriggerAutoFocus();
     }
 
-    /// <summary>
-    /// Interface for devices that have auto focus mode control
-    /// </summary>
     public interface IHasAutoFocusMode
     {
-        /// <summary>
-        /// Sets the focus mode to auto or manual, or toggles between them.
-        /// </summary>
         void SetFocusModeAuto();
-
-        /// <summary>
-        /// Sets the focus mode to manual, allowing for manual focus adjustments.
-        /// </summary>
         void SetFocusModeManual();
-
-        /// <summary>
-        /// Toggles the focus mode between auto and manual.
-        /// </summary>
         void ToggleFocusMode();
     }
 
-    /// <summary>
-    /// Interface for devices that have camera auto mode control
-    /// </summary>
     public interface IHasCameraAutoMode : IHasCameraControls
     {
-        /// <summary>
-        /// Enables or disables the camera's auto mode, which may include automatic adjustments for focus, exposure, and other settings.
-        /// </summary>
         void CameraAutoModeOn();
-
-        /// <summary>
-        /// Disables the camera's auto mode, allowing for manual control of camera settings.
-        /// </summary>
         void CameraAutoModeOff();
-
-        /// <summary>
-        /// Toggles the camera's auto mode state. If the camera is in auto mode, it will switch to manual mode, and vice versa.
-        /// </summary>
         void CameraAutoModeToggle();
-
-        /// <summary>
-        /// Feedback that indicates whether the camera's auto mode is currently enabled.
-        /// </summary>
         BoolFeedback CameraAutoModeIsOnFeedback { get; }
     }
 

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/CameraBaseMessenger.cs

@@ -6,14 +6,11 @@ using System.Collections.Generic;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
-    /// <summary>
-    /// Messenger for a CameraBase device
-    /// </summary>
     public class CameraBaseMessenger : MessengerBase
     {
         /// <summary>
         /// Device being bridged
-        /// </summary>  
+        /// </summary>
         public CameraBase Camera { get; set; }
 
         /// <summary>
@@ -48,9 +45,6 @@ namespace PepperDash.Essentials.AppServer.Messengers
             );
         }
 
-        /// <summary>
-        /// Registers the actions for this messenger.  This is called by the base class
-        /// </summary>
         protected override void RegisterActions()
         {
             base.RegisterActions();

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/DeviceInfoMessenger.cs

@@ -2,27 +2,69 @@
 using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.DeviceInfo;
+using System.Timers;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
+    /// <summary>
+    /// Facilitates communication of device information by providing mechanisms for status updates and  device
+    /// information reporting.
+    /// </summary>
+    /// <remarks>The <see cref="DeviceInfoMessenger"/> class integrates with an <see
+    /// cref="IDeviceInfoProvider"/> to  manage device-specific information. It uses a debounce timer to limit the
+    /// frequency of updates,  ensuring efficient communication. The timer is initialized with a 1-second interval and
+    /// is disabled  by default. This class also subscribes to device information change events and provides actions for
+    /// reporting full device status and triggering updates.</remarks>
     public class DeviceInfoMessenger : MessengerBase
     {
         private readonly IDeviceInfoProvider _deviceInfoProvider;
+
+        private readonly Timer debounceTimer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeviceInfoMessenger"/> class, which facilitates communication
+        /// of device information.
+        /// </summary>
+        /// <remarks>The messenger uses a debounce timer to limit the frequency of certain operations. The
+        /// timer is initialized with a 1-second interval and is disabled by default.</remarks>
+        /// <param name="key">A unique identifier for the messenger instance.</param>
+        /// <param name="messagePath">The path used for sending and receiving messages.</param>
+        /// <param name="device">An implementation of <see cref="IDeviceInfoProvider"/> that provides device-specific information.</param>
         public DeviceInfoMessenger(string key, string messagePath, IDeviceInfoProvider device) : base(key, messagePath, device as Device)
         {
             _deviceInfoProvider = device;
-        }
 
+            debounceTimer = new Timer(1000)
+            {
+                Enabled = false,
+                AutoReset = false
+            };
+
+            debounceTimer.Elapsed += DebounceTimer_Elapsed;
+        }
+
+        private void DebounceTimer_Elapsed(object sender, ElapsedEventArgs e)
+        {
+            PostStatusMessage(JToken.FromObject(new
+            {
+                deviceInfo = _deviceInfoProvider.DeviceInfo
+            }));
+        }
+
+        /// <summary>
+        /// Registers actions and event handlers for device information updates and status reporting.
+        /// </summary>
+        /// <remarks>This method sets up actions for handling device status updates and reporting full
+        /// device status. It also subscribes to the <see cref="IDeviceInfoProvider.DeviceInfoChanged"/> event to
+        /// trigger debounced updates when the device information changes.</remarks>
         protected override void RegisterActions()
         {
             base.RegisterActions();
 
             _deviceInfoProvider.DeviceInfoChanged += (o, a) =>
             {
-                PostStatusMessage(JToken.FromObject(new
-                {
-                    deviceInfo = a.DeviceInfo
-                }));
+                debounceTimer.Stop();
+                debounceTimer.Start();
             };
 
             AddAction("/fullStatus", (id, context) => PostStatusMessage(new DeviceInfoStateMessage
@@ -34,6 +76,12 @@ namespace PepperDash.Essentials.AppServer.Messengers
         }
     }
 
+    /// <summary>
+    /// Represents a message containing the state information of a device, including detailed device information.
+    /// </summary>
+    /// <remarks>This class is used to encapsulate the state of a device along with its associated
+    /// information. It extends <see cref="DeviceStateMessageBase"/> to provide additional details about the
+    /// device.</remarks>
     public class DeviceInfoStateMessage : DeviceStateMessageBase
     {
         [JsonProperty("deviceInfo")]

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/IHasCamerasMessenger.cs

@@ -1,104 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using PepperDash.Essentials.Devices.Common.Cameras;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PepperDash.Essentials.AppServer.Messengers
-{
-    /// <summary>
-    /// Messenger for devices that implement the IHasCameras interface.
-    /// </summary>
-    public class IHasCamerasMessenger : MessengerBase
-    {
-        /// <summary>
-        /// Device being bridged that implements IHasCameras interface.
-        /// </summary>
-        public IHasCameras CameraController { get; private set; }
-
-        /// <summary>
-        /// Messenger for devices that implement IHasCameras interface.
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="cameraController"></param>
-        /// <param name="messagePath"></param>
-        /// <exception cref="ArgumentNullException"></exception>
-        public IHasCamerasMessenger(string key, string messagePath , IHasCameras cameraController)
-            : base(key, messagePath, cameraController)
-        {
-            CameraController = cameraController ?? throw new ArgumentNullException("cameraController");
-            CameraController.CameraSelected += CameraController_CameraSelected;
-        }
-
-        private void CameraController_CameraSelected(object sender, CameraSelectedEventArgs e)
-        {
-            PostStatusMessage(new IHasCamerasStateMessage
-            {
-                SelectedCamera = e.SelectedCamera
-            });
-        }
-
-        /// <summary>
-        /// Registers the actions for this messenger.
-        /// </summary>
-        /// <exception cref="ArgumentException"></exception>
-        protected override void RegisterActions()
-        {
-            base.RegisterActions();
-
-            AddAction("/fullStatus", (id, context) =>
-            {
-                SendFullStatus();
-            });
-
-            AddAction("/selectCamera", (id, content) =>
-            {
-                var cameraKey = content?.ToObject<string>();
-
-                if (!string.IsNullOrEmpty(cameraKey))
-                {
-                    CameraController.SelectCamera(cameraKey);
-                }
-                else
-                {
-                    throw new ArgumentException("Content must be a string representing the camera key");
-                }
-            });
-        }
-
-        private void SendFullStatus()
-        {
-            var state = new IHasCamerasStateMessage
-            {
-                CameraList = CameraController.Cameras,
-                SelectedCamera = CameraController.SelectedCamera
-            };
-
-            PostStatusMessage(state);
-        }
-
-
-    }
-
-    /// <summary>
-    /// State message for devices that implement the IHasCameras interface.
-    /// </summary>
-    public class IHasCamerasStateMessage : DeviceStateMessageBase
-    {
-        /// <summary>
-        /// List of cameras available in the device.
-        /// </summary>
-        [JsonProperty("cameraList", NullValueHandling = NullValueHandling.Ignore)]
-        public List<CameraBase> CameraList { get; set; }
-
-        /// <summary>
-        /// The currently selected camera on the device.
-        /// </summary>
-        [JsonProperty("selectedCamera", NullValueHandling = NullValueHandling.Ignore)]
-        public CameraBase SelectedCamera { get; set; }
-
-    }
-}

src/PepperDash.Essentials.MobileControl/MobileControlSystemController.cs

@@ -907,19 +907,6 @@ namespace PepperDash.Essentials
                         messengerAdded = true;
                     }
 
-                    if (device is IHasCameras cameras)
-                    {
-                        this.LogVerbose("Adding IHasCamerasMessenger for {deviceKey}", device.Key
-                        );
-                        var messenger = new IHasCamerasMessenger(
-                            $"{device.Key}-cameras-{Key}",
-                            $"/device/{device.Key}",
-                            cameras
-                        );
-                        AddDefaultDeviceMessenger(messenger);
-                        messengerAdded = true;
-                    }
-
                     this.LogVerbose("Trying to cast to generic device for device: {key}", device.Key);
 
                     if (device is EssentialsDevice)