feat: Enhance UDPServer initialization in Connect method

Updated the `Connect` method in `GenericUdpServer.cs` to include error handling for hostname parsing. The method now attempts to create a `UDPServer` instance with specified parameters and falls back to default initialization if an error occurs. This improves flexibility and robustness in server setup.

src/PepperDash.Core/Comm/GenericUdpServer.cs

@@ -131,14 +131,14 @@ namespace PepperDash.Core
         /// <param name="key"></param>
         /// <param name="address"></param>
         /// <param name="port"></param>
-        /// <param name="buffefSize"></param>
-        public GenericUdpServer(string key, string address, int port, int buffefSize)
+        /// <param name="bufferSize"></param>
+        public GenericUdpServer(string key, string address, int port, int bufferSize)
             : base(key)
         {
             StreamDebugging = new CommunicationStreamDebugging(key); 
             Hostname = address;
             Port = port;
-            BufferSize = buffefSize;
+            BufferSize = bufferSize;
 
             CrestronEnvironment.ProgramStatusEventHandler += new ProgramStatusEventHandler(CrestronEnvironment_ProgramStatusEventHandler);
             CrestronEnvironment.EthernetEventHandler += new EthernetEventHandler(CrestronEnvironment_EthernetEventHandler);
@@ -194,7 +194,21 @@ namespace PepperDash.Core
         {
             if (Server == null)
             {
-                Server = new UDPServer();
+                try
+                {
+                    var address = IPAddress.Parse(Hostname);
+
+                    Server = new UDPServer(address, Port, BufferSize);
+
+                }
+                catch (Exception ex)
+                {
+                    this.LogError("Error parsing IP Address '{ipAddress}': message: {message}", Hostname, ex.Message);
+                    this.LogInformation("Creating UDPServer with default buffersize");
+
+                    Server = new UDPServer();
+                }
+
             }
 
             if (string.IsNullOrEmpty(Hostname))

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

@@ -1,326 +0,0 @@
-using System;
-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
-    {
-        /// <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>
-        /// Selects a camera from the list of available cameras based on the provided key.
-        /// </summary>
-        /// <param name="key">The unique identifier or name of the camera to select.</param>
-        void SelectCamera(string key);
-    }
-
-    /// <summary>
-    /// Defines the contract for IHasCodecCameras
-    /// </summary>
-    public interface IHasCodecCameras : IHasCameras, IHasFarEndCameraControl
-    {
-
-    }
-
-    /// <summary>
-    /// To be implmented on codecs that can disable their camera(s) to blank the near end video
-    /// </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();
-    }
-
-    /// <summary>
-    /// Describes the ability to mute and unmute camera video
-    /// </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>
-        /// Gets or sets the SelectedCamera
-        /// </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; }
-
-    }
-
-    /// <summary>
-    /// Defines the contract for IAmFarEndCamera
-    /// </summary>
-    public interface IAmFarEndCamera
-    {
-
-    }
-
-    /// <summary>
-    /// Interface for devices that have camera controls
-    /// </summary>
-    public interface IHasCameraControls
-    {
-    }
-
-    /// <summary>
-    /// Defines the contract for IHasCameraPtzControl
-    /// </summary>
-    public interface IHasCameraPtzControl : IHasCameraPanControl, IHasCameraTiltControl, IHasCameraZoomControl
-    {
-        /// <summary>
-        /// Resets the camera position
-        /// </summary>
-        void PositionHome();
-    }
-
-    /// <summary>
-    /// Interface for camera pan control
-    /// </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();
-    }
-
-    /// <summary>
-    /// Defines the contract for IHasCameraTiltControl
-    /// </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();
-    }
-
-    /// <summary>
-    /// Defines the contract for IHasCameraZoomControl
-    /// </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();
-    }
-
-    /// <summary>
-    /// Defines the contract for IHasCameraFocusControl
-    /// </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.Devices.Common/Cameras/Interfaces/CameraSelectedEventArgs.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Event arguments for the CameraSelected event
+    /// </summary>
+    [Obsolete("Use CameraSelectedEventArgs<T> instead. This class will be removed in a future version")]
+    public class CameraSelectedEventArgs : EventArgs
+    {
+        /// Gets or sets the SelectedCamera
+        /// </summary>
+        public CameraBase SelectedCamera { get; private set; }
+
+        /// <summary>
+        /// Constructor for CameraSelectedEventArgs
+        /// </summary>
+        /// <param name="camera"></param>
+        public CameraSelectedEventArgs(CameraBase camera)
+        {
+            SelectedCamera = camera;
+        }
+    }
+
+    /// <summary>
+    /// Event arguments for the CameraSelected event
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class CameraSelectedEventArgs<T> : EventArgs
+    {
+        /// <summary>
+        /// Gets or sets the SelectedCamera
+        /// </summary>
+        public T SelectedCamera { get; private set; }
+
+        /// <summary>
+        /// Constructor for CameraSelectedEventArgs
+        /// </summary>
+        /// <param name="camera"></param>
+        public CameraSelectedEventArgs(T camera)
+        {
+            SelectedCamera = camera;
+        }
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IAmFarEndCamera.cs

@@ -0,0 +1,12 @@
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Defines the contract for IAmFarEndCamera
+    /// </summary>
+    public interface IAmFarEndCamera : IKeyName
+    {
+
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/ICameraCapabilities.cs

@@ -0,0 +1,86 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for camera capabilities
+    /// </summary>
+    public interface ICameraCapabilities: IKeyName
+    {
+        /// <summary>
+        /// Indicates whether the camera can pan
+        /// </summary>
+        [JsonProperty("canPan", NullValueHandling = NullValueHandling.Ignore)]
+        bool CanPan { get;  }
+
+        /// <summary>
+        /// Indicates whether the camera can tilt
+        /// </summary>
+        [JsonProperty("canTilt", NullValueHandling = NullValueHandling.Ignore)]
+         bool CanTilt { get; }
+
+        /// <summary>
+        /// Indicates whether the camera can zoom
+        /// </summary>
+        [JsonProperty("canZoom", NullValueHandling = NullValueHandling.Ignore)]
+        bool CanZoom { get;  }
+
+
+        /// <summary>
+        /// Indicates whether the camera can focus
+        /// </summary>
+        [JsonProperty("canFocus", NullValueHandling = NullValueHandling.Ignore)]
+        bool CanFocus { get;  }
+    }
+
+    /// <summary>
+    /// Indicates the capabilities of a camera
+    /// </summary>
+    public class CameraCapabilities : ICameraCapabilities
+    {
+
+        /// <summary>
+        /// Unique Key
+        /// </summary>
+        [JsonProperty("key", NullValueHandling = NullValueHandling.Ignore)]
+        public string Key { get; set; }
+
+        /// <summary>
+        /// Isn't it obvious :)
+        /// </summary>
+        [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
+        public string Name { get; set; }
+
+
+        /// <summary>
+        /// Indicates whether the camera can pan
+        /// </summary>
+        [JsonProperty("canPan", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CanPan { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera can tilt
+        /// </summary>
+        [JsonProperty("canTilt", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CanTilt { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera can zoom
+        /// </summary>
+        [JsonProperty("canZoom", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CanZoom { get; set; }
+
+
+        /// <summary>
+        /// Indicates whether the camera can focus
+        /// </summary>
+        [JsonProperty("canFocus", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CanFocus { get; set; }
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasAutoFocusMode.cs

@@ -0,0 +1,24 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for devices that have auto focus mode control
+    /// </summary>
+    public interface IHasAutoFocusMode : IHasCameraControls
+    {
+        /// <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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraAutoMode.cs

@@ -0,0 +1,31 @@
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+
+    /// <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.Devices.Common/Cameras/Interfaces/IHasCameraControls.cs

@@ -0,0 +1,13 @@
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+
+    /// <summary>
+    /// Interface for devices that have camera controls
+    /// </summary>
+    public interface IHasCameraControls : IKeyName
+    {
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraFocusControl.cs

@@ -0,0 +1,29 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Defines the contract for IHasCameraFocusControl
+    /// </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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraMute.cs

@@ -0,0 +1,31 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Describes the ability to mute and unmute camera video
+    /// </summary>
+    public interface IHasCameraMute : IKeyName
+    {
+        /// <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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraMuteWithUnmuteRequest.cs

@@ -0,0 +1,16 @@
+using System;
+
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <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;
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraOff.cs

@@ -0,0 +1,27 @@
+using PepperDash.Essentials.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+
+
+    /// <summary>
+    /// To be implmented on codecs that can disable their camera(s) to blank the near end video
+    /// </summary>
+    public interface IHasCameraOff : IHasCameraControls
+    {
+        /// <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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraPanControl.cs

@@ -0,0 +1,24 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for camera pan control
+    /// </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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraPtzControl.cs

@@ -0,0 +1,14 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Defines the contract for IHasCameraPtzControl
+    /// </summary>
+    public interface IHasCameraPtzControl : IHasCameraPanControl, IHasCameraTiltControl, IHasCameraZoomControl
+    {
+        /// <summary>
+        /// Resets the camera position
+        /// </summary>
+        void PositionHome();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraTiltControl.cs

@@ -0,0 +1,24 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Defines the contract for IHasCameraTiltControl
+    /// </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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameraZoomControl.cs

@@ -0,0 +1,24 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Defines the contract for IHasCameraZoomControl
+    /// </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();
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCameras.cs

@@ -0,0 +1,41 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for devices that have cameras
+    /// </summary>
+    [Obsolete("Use IHasCamerasWithControls instead. This interface will be removed in a future version")]
+    public interface IHasCameras : IKeyName
+    {
+        /// <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>
+        /// Selects a camera from the list of available cameras based on the provided key.
+        /// </summary>
+        /// <param name="key">The unique identifier or name of the camera to select.</param>
+        void SelectCamera(string key);
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCamerasWithControls.cs

@@ -0,0 +1,40 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for devices that have cameras with controls
+    /// </summary>
+    public interface IHasCamerasWithControls : IKeyName, IKeyed
+    {
+        /// <summary>
+        /// List of cameras on the device. This should be a list of IHasCameraControls objects
+        /// </summary>
+        
+        List<IHasCameraControls> Cameras { get; }
+
+        /// <summary>
+        /// The currently selected camera. This should be an IHasCameraControls object
+        /// </summary>
+        IHasCameraControls SelectedCamera { get; }
+
+        /// <summary>
+        /// Feedback that indicates the currently selected camera
+        /// </summary>
+        StringFeedback SelectedCameraFeedback { get; }
+
+        /// <summary>
+        /// Event that is raised when a camera is selected
+        /// </summary>
+        event EventHandler<CameraSelectedEventArgs<IHasCameraControls>> CameraSelected;
+
+        /// <summary>
+        /// Selects a camera from the list of available cameras based on the provided key.
+        /// </summary>
+        /// <param name="key"></param>
+        void SelectCamera(string key);
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasCodecCameras.cs

@@ -0,0 +1,13 @@
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+
+    /// <summary>
+    /// Defines the contract for IHasCodecCameras
+    /// </summary>
+    public interface IHasCodecCameras : IHasCameras, IHasFarEndCameraControl
+    {
+
+    }
+
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/IHasFarEndCameraControl.cs

@@ -0,0 +1,23 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+
+namespace PepperDash.Essentials.Devices.Common.Cameras
+{
+    /// <summary>
+    /// Interface for devices that have a far end camera control
+    /// </summary>
+    public interface IHasFarEndCameraControl : IKeyName
+    {
+        /// <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; }
+
+    }
+}

src/PepperDash.Essentials.Devices.Common/Cameras/Interfaces/eCameraControlMode.cs

@@ -0,0 +1,24 @@
+
+
+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
+    }
+
+}

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

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Devices.Common.Cameras;
 
@@ -9,12 +11,12 @@ namespace PepperDash.Essentials.AppServer.Messengers
     /// <summary>
     /// Messenger for a CameraBase device
     /// </summary>
-    public class CameraBaseMessenger : MessengerBase
+    public class CameraBaseMessenger<T> : MessengerBase where T : IKeyed
     {
         /// <summary>
         /// Gets or sets the Camera
         /// </summary>
-        public CameraBase Camera { get; set; }
+        public T Camera { get; set; }
 
         /// <summary>
         /// Constructor
@@ -22,10 +24,13 @@ namespace PepperDash.Essentials.AppServer.Messengers
         /// <param name="key"></param>
         /// <param name="camera"></param>
         /// <param name="messagePath"></param>
-        public CameraBaseMessenger(string key, CameraBase camera, string messagePath)
-            : base(key, messagePath, camera)
+        public CameraBaseMessenger(string key, T camera, string messagePath)
+            : base(key, messagePath, camera as IKeyName)
         {
-            Camera = camera ?? throw new ArgumentNullException("camera");
+            if (camera == null)
+                throw new ArgumentNullException(nameof(camera));
+
+            Camera = camera;
 
 
             if (Camera is IHasCameraPresets presetsCamera)
@@ -178,19 +183,44 @@ namespace PepperDash.Essentials.AppServer.Messengers
         private void SendCameraFullMessageObject(string id = null)
         {
             var presetList = new List<CameraPreset>();
+            CameraCapabilities capabilities = null;
 
             if (Camera is IHasCameraPresets presetsCamera)
                 presetList = presetsCamera.Presets;
 
-            PostStatusMessage(JToken.FromObject(new
+            if (Camera is ICameraCapabilities cameraCapabilities)
+                capabilities = new CameraCapabilities
+                {
+                    CanPan = cameraCapabilities.CanPan,
+                    CanTilt = cameraCapabilities.CanTilt,
+                    CanZoom = cameraCapabilities.CanZoom,
+                    CanFocus = cameraCapabilities.CanFocus
+
+                };
+
+            if (Camera is CameraBase cameraBase)
+                capabilities = new CameraCapabilities
+                {
+                    CanPan = cameraBase.CanPan,
+                    CanTilt = cameraBase.CanTilt,
+                    CanZoom = cameraBase.CanZoom,
+                    CanFocus = cameraBase.CanFocus
+                    
+                };
+
+            var message = new CameraStateMessage
             {
-                cameraManualSupported = Camera is IHasCameraControls,
-                cameraAutoSupported = Camera is IHasCameraAutoMode,
-                cameraOffSupported = Camera is IHasCameraOff,
-                cameraMode = GetCameraMode(),
-                hasPresets = Camera is IHasCameraPresets,
-                presets = presetList
-            }), id
+                CameraManualSupported = Camera is IHasCameraControls,
+                CameraAutoSupported = Camera is IHasCameraAutoMode,
+                CameraOffSupported = Camera is IHasCameraOff,
+                CameraMode = (eCameraControlMode)Enum.Parse(typeof(eCameraControlMode), GetCameraMode(), true),
+                HasPresets = Camera is IHasCameraPresets,
+                Presets = presetList,
+                Capabilities = capabilities,
+                IsFarEnd = Camera is IAmFarEndCamera
+            };
+
+            PostStatusMessage(message, id
             );
         }
 
@@ -210,4 +240,59 @@ namespace PepperDash.Essentials.AppServer.Messengers
             return m;
         }
     }
+
+    /// <summary>
+    /// State message for a camera device
+    /// </summary>
+    public class CameraStateMessage : DeviceStateMessageBase
+    {
+        /// <summary>
+        /// Indicates whether the camera supports manual control
+        /// </summary>
+        [JsonProperty("cameraManualSupported", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CameraManualSupported { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera supports auto control
+        /// </summary>
+        [JsonProperty("cameraAutoSupported", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CameraAutoSupported { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera supports off control
+        /// </summary>
+        [JsonProperty("cameraOffSupported", NullValueHandling = NullValueHandling.Ignore)]
+        public bool CameraOffSupported { get; set; }
+
+        /// <summary>
+        /// Indicates the current camera control mode
+        /// </summary>
+        [JsonProperty("cameraMode", NullValueHandling = NullValueHandling.Ignore)]
+        [JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+        public eCameraControlMode CameraMode { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera has presets
+        /// </summary>
+        [JsonProperty("hasPresets", NullValueHandling = NullValueHandling.Ignore)]
+        public bool HasPresets { get; set; }
+
+        /// <summary>
+        /// List of presets if the camera supports them
+        /// </summary>
+        [JsonProperty("presets", NullValueHandling = NullValueHandling.Ignore)]
+        public List<CameraPreset> Presets { get; set; }
+
+        /// <summary>
+        /// Indicates the capabilities of the camera
+        /// </summary>
+        [JsonProperty("capabilities", NullValueHandling = NullValueHandling.Ignore)]
+        public CameraCapabilities Capabilities { get; set; }
+
+        /// <summary>
+        /// Indicates whether the camera is a far end camera
+        /// </summary>
+        [JsonProperty("isFarEnd", NullValueHandling = NullValueHandling.Ignore)]
+        public bool IsFarEnd { get; set; }
+    }
 }

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

@@ -1,17 +1,14 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
 using PepperDash.Essentials.Devices.Common.Cameras;
+using System;
+using System.Collections.Generic;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
     /// <summary>
     /// Messenger for devices that implement the IHasCameras interface.
     /// </summary>
+    [Obsolete("Use IHasCamerasWithControlsMessenger instead. This class will be removed in a future version")]
     public class IHasCamerasMessenger : MessengerBase
     {
         /// <summary>

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

@@ -0,0 +1,137 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Core.Logging;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Devices.Common.Cameras;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PepperDash.Essentials.AppServer.Messengers
+{
+    /// <summary>
+    /// Messenger for devices that implement the IHasCameras interface.
+    /// </summary>
+    public class IHasCamerasWithControlMessenger : MessengerBase
+    {
+        /// <summary>
+        /// Device being bridged that implements IHasCameras interface.
+        /// </summary>
+        public IHasCamerasWithControls 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 IHasCamerasWithControlMessenger(string key, string messagePath, IHasCamerasWithControls cameraController)
+            : base(key, messagePath, cameraController)
+        {
+            CameraController = cameraController ?? throw new ArgumentNullException("cameraController");
+            CameraController.CameraSelected += CameraController_CameraSelected;
+        }
+
+        private void CameraController_CameraSelected(object sender, CameraSelectedEventArgs<IHasCameraControls> e)
+        {
+            var selectedCamera = new KeyName
+            {
+                Key = e.SelectedCamera.Key,
+                Name = e.SelectedCamera.Name
+            };
+
+            PostStatusMessage(new IHasCamerasWithControlsStateMessage
+            {
+                SelectedCamera = selectedCamera
+            });
+        }
+
+        /// <summary>
+        /// Registers the actions for this messenger.
+        /// </summary>
+        /// <exception cref="ArgumentException"></exception>
+        protected override void RegisterActions()
+        {
+            base.RegisterActions();
+
+            AddAction("/fullStatus", (id, context) => SendFullStatus(id));
+
+            AddAction("/cameraListStatus", (id, content) => SendFullStatus(id));
+
+            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(string clientId)
+        {
+            var cameraList = new List<IKeyName>();
+            KeyName selectedCamera = null;
+
+            foreach (var cam in CameraController.Cameras)
+            {
+                cameraList.Add(new KeyName{
+                    Key = cam.Key,
+                    Name = cam.Name
+                });
+            }
+
+            if (CameraController.SelectedCamera != null)
+            {
+                selectedCamera = new KeyName
+                {
+                    Key = CameraController.SelectedCamera.Key,
+                    Name = CameraController.SelectedCamera.Name
+                };
+            }
+
+            var state = new IHasCamerasWithControlsStateMessage
+            {
+                CameraList = cameraList,
+                SelectedCamera = selectedCamera
+            };
+
+            PostStatusMessage(state, clientId);
+        }
+    }
+
+    /// <summary>
+    /// State message for devices that implement the IHasCameras interface.
+    /// </summary>
+    public class IHasCamerasWithControlsStateMessage : DeviceStateMessageBase
+    {
+        /// <summary>
+        /// List of cameras available in the device.
+        /// </summary>
+        [JsonProperty("cameraList", NullValueHandling = NullValueHandling.Ignore)]
+        public List<IKeyName> CameraList { get; set; }
+
+        /// <summary>
+        /// The currently selected camera on the device.
+        /// </summary>
+        [JsonProperty("selectedCamera", NullValueHandling = NullValueHandling.Ignore)]
+        public IKeyName SelectedCamera { get; set; }
+    }
+
+    class KeyName : IKeyName
+    {
+        public string Key { get; set; }
+        public string Name { get; set; }
+        public KeyName()
+        {
+            Key = "";
+            Name = "";
+        }
+    }
+}

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

@@ -16,6 +16,8 @@ namespace PepperDash.Essentials.AppServer.Messengers
 
         private readonly string _propName;
 
+        private List<string> _itemKeys = new List<string>();
+
         /// <summary>
         /// Constructs a messenger for a device that implements ISelectableItems<typeparamref name="TKey"/>
         /// </summary>
@@ -39,9 +41,35 @@ namespace PepperDash.Essentials.AppServer.Messengers
 
             AddAction("/itemsStatus", (id, content) => SendFullStatus(id));
 
+            AddAction("/selectItem", (id, content) =>
+            {
+                try
+                {
+                    var key = content.ToObject<TKey>();
+
+                    if (key == null)
+                    {
+                        this.LogError("No key specified to select");
+                        return;
+                    }
+                    if (itemDevice.Items.ContainsKey((TKey)Convert.ChangeType(key, typeof(TKey))))
+                    {
+                        itemDevice.Items[(TKey)Convert.ChangeType(key, typeof(TKey))].Select();
+                    }
+                    else
+                    {
+                        this.LogError("Key {0} not found in items", key);
+                    }
+                }
+                catch (Exception e)
+                {
+                    this.LogError("Error selecting item: {0}", e.Message);
+                }
+            });
+
             itemDevice.ItemsUpdated += (sender, args) =>
             {
-                SendFullStatus();
+                SetItems();
             };
 
             itemDevice.CurrentItemChanged += (sender, args) =>
@@ -49,23 +77,47 @@ namespace PepperDash.Essentials.AppServer.Messengers
                 SendFullStatus();
             };
 
-            foreach (var input in itemDevice.Items)
+            SetItems();
+        }
+
+        /// <summary>
+        /// Sets the items and registers their update events
+        /// </summary>
+        private void SetItems()
+        {
+            if (_itemKeys != null && _itemKeys.Count > 0)
             {
-                var key = input.Key;
-                var localItem = input.Value;
+                /// Clear out any existing item actions
+                foreach (var item in _itemKeys)
+                {
+                    RemoveAction($"/{item}");
+                }
+
+                _itemKeys.Clear();
+            }
+
+            foreach (var item in itemDevice.Items)
+            {
+                var key = item.Key;
+                var localItem = item.Value;
 
                 AddAction($"/{key}", (id, content) =>
                 {
                     localItem.Select();
                 });
 
-                localItem.ItemUpdated += (sender, args) =>
-                {
-                    SendFullStatus();
-                };
+                _itemKeys.Add(key.ToString());
+
+                localItem.ItemUpdated -= LocalItem_ItemUpdated;
+                localItem.ItemUpdated += LocalItem_ItemUpdated;
             }
         }
 
+        private void LocalItem_ItemUpdated(object sender, EventArgs e)
+        {
+            SendFullStatus();
+        }
+
         private void SendFullStatus(string id = null)
         {
             try

src/PepperDash.Essentials.MobileControl/MobileControlSystemController.cs

@@ -405,14 +405,15 @@ namespace PepperDash.Essentials
                         messengerAdded = true;
                     }
 
-                    if (device is CameraBase cameraDevice)
+                    // Default to IHasCameraControls if CameraBase and IHasCameraControls
+                    if (device is CameraBase cameraDevice && !(device is IHasCameraControls))
                     {
                         this.LogVerbose(
                             "Adding CameraBaseMessenger for {deviceKey}",
                             device.Key
                         );
 
-                        var cameraMessenger = new CameraBaseMessenger(
+                        var cameraMessenger = new CameraBaseMessenger<CameraBase>(
                             $"{device.Key}-cameraBase-{Key}",
                             cameraDevice,
                             $"/device/{device.Key}"
@@ -423,6 +424,21 @@ namespace PepperDash.Essentials
                         messengerAdded = true;
                     }
 
+                    if (device is IHasCameraControls cameraControlDev)
+                    {
+                        this.LogVerbose(
+                            "Adding IHasCamerasWithControlMessenger for {deviceKey}",
+                            device.Key
+                        );
+                        var cameraControlMessenger = new CameraBaseMessenger<IHasCameraControls>(
+                            $"{device.Key}-hasCamerasWithControls-{Key}",
+                            cameraControlDev,
+                            $"/device/{device.Key}"
+                        );
+                        AddDefaultDeviceMessenger(cameraControlMessenger);
+                        messengerAdded = true;
+                    }
+
                     if (device is BlueJeansPc)
                     {
                         this.LogVerbose(
@@ -975,6 +991,19 @@ namespace PepperDash.Essentials
                         messengerAdded = true;
                     }
 
+                    if (device is IHasCamerasWithControls cameras2)
+                    {
+                        this.LogVerbose("Adding IHasCamerasWithControlsMessenger for {deviceKey}", device.Key
+                        );
+                        var messenger = new IHasCamerasWithControlMessenger(
+                            $"{device.Key}-cameras-{Key}",
+                            $"/device/{device.Key}",
+                            cameras2
+                        );
+                        AddDefaultDeviceMessenger(messenger);
+                        messengerAdded = true;
+                    }
+
                     this.LogVerbose("Trying to cast to generic device for device: {key}", device.Key);
 
                     if (device is EssentialsDevice)
@@ -2233,8 +2262,21 @@ namespace PepperDash.Essentials
                 return;
             }
 
+            if (_roomCombiner.CurrentScenario == null)
+            {
+                var message = new MobileControlMessage
+                {
+                    Type = "/system/roomKey",
+                    ClientId = clientId,
+                    Content = roomKey
+                };
+                SendMessageObject(message);
+                return;
+            }
+
             if (!_roomCombiner.CurrentScenario.UiMap.ContainsKey(roomKey))
             {
+
                 this.LogWarning(
                     "Unable to find correct roomKey for {roomKey} in current scenario. Returning {roomKey} as roomKey", roomKey);