feat: add generic soft codec device

Updated package names for Core and Devices Common to be valid names and match existing 2.0.0 packages

src/PepperDash.Essentials.Core/Bridges/JoinMaps/GenericIrControllerJoinMap.cs

@@ -1,6 +1,6 @@
 using PepperDash.Essentials.Core;
 
-namespace PepperDash_Essentials_Core.Bridges.JoinMaps
+namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 {
 		public sealed class GenericIrControllerJoinMap : JoinMapBaseAdvanced
 		{

src/PepperDash.Essentials.Core/Bridges/JoinMaps/HdPsXxxControllerJoinMap.cs

@@ -1,7 +1,7 @@
 using System;
 using PepperDash.Essentials.Core;
 
-namespace PepperDash_Essentials_Core.Bridges
+namespace PepperDash.Essentials.Core.Bridges
 {
 	public class HdPsXxxControllerJoinMap : JoinMapBaseAdvanced
 	{

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IHasInputs.cs

@@ -0,0 +1,24 @@
+using PepperDash.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+
+    /// <summary>
+    /// Describes a device that has selectable inputs
+    /// </summary>
+    /// <typeparam name="TKey">the type to use as the key for each input item. Most likely an enum or string</typeparam>\
+    /// <example>
+    /// See MockDisplay for example implemntation
+    /// </example>
+    public interface IHasInputs<TKey, TSelector>: IKeyName
+    {
+        ISelectableItems<TKey> Inputs { get; }
+
+        void SetInput(TSelector selector);
+    }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IHasSurroundSoundModes.cs

@@ -0,0 +1,20 @@
+using PepperDash.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+    /// <summary>
+    /// Describes a device that has selectable surround sound modes
+    /// </summary>
+    /// <typeparam name="TKey">the type to use as the key for each input item. Most likely an enum or string</typeparam>
+    public interface IHasSurroundSoundModes<TKey, TSelector>: IKeyName
+    {
+        ISelectableItems<TKey> SurroundSoundModes { get; }
+
+        void SetSurroundSoundMode(TSelector selector);
+    }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/ILevelControls.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+    public interface ILevelControls
+    {
+        Dictionary<string, IBasicVolumeWithFeedback> LevelControlPoints { get; }
+    }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IMobileControl.cs

@@ -6,6 +6,13 @@ using PepperDash.Core;
 namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
 {
     /// <summary>
+    /// Use this interface on a device or room if it uses custom Mobile Control messengers
+    /// </summary>
+    public interface ICustomMobileControl : IKeyed
+    {
+    }
+
+    /*/// <summary>
     /// Describes a MobileControlSystemController
     /// </summary>
     public interface IMobileControl : IKeyed
@@ -13,16 +20,24 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         void CreateMobileControlRoomBridge(IEssentialsRoom room, IMobileControl parent);
 
         void LinkSystemMonitorToAppServer();
-    }
+    }*/
 
     /// <summary>
     /// Describes a MobileSystemController that accepts IEssentialsRoom
     /// </summary>
-    public interface IMobileControl3 : IMobileControl
-    {       
+    public interface IMobileControl : IKeyed
+    {
+        string Host { get; }
+
+        string ClientAppUrl { get; }
+
+        string SystemUuid { get; }
+
+        BoolFeedback ApiOnlineAndAuthorized { get;}
+
         void SendMessageObject(IMobileControlMessage o);
 
-        void AddAction(string key, Action<string, JToken> action);
+        void AddAction<T>(T messenger, Action<string, string, JToken> action) where T:IMobileControlMessenger;
 
         void RemoveAction(string key);
 
@@ -36,9 +51,11 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// </summary>
     public interface IMobileControlMessenger: IKeyed
     {
-        IMobileControl3 AppServerController { get; }
+        IMobileControl AppServerController { get; }
         string MessagePath { get; }
-        void RegisterWithAppServer(IMobileControl3 appServerController);
+
+        string DeviceKey { get; }
+        void RegisterWithAppServer(IMobileControl appServerController);
     }
 
     public interface IMobileControlMessage
@@ -57,7 +74,7 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// <summary>
     /// Describes a MobileControl Room Bridge
     /// </summary>
-    public interface IMobileControlRoomBridge : IKeyed
+    public interface IMobileControlRoomMessenger : IKeyed
     {
         event EventHandler<EventArgs> UserCodeChanged;
 
@@ -78,5 +95,15 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         string RoomName { get; }
 
         string AppUrl { get; }
+
+        void UpdateAppUrl(string url);
     }
+
+    public interface IMobileControlAction
+    {
+       IMobileControlMessenger Messenger { get; }
+
+       Action<string,string, JToken> Action { get; }
+    }
+
 }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/ISelectableItem.cs

@@ -0,0 +1,19 @@
+using System;
+using Newtonsoft.Json;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+
+    /// <summary>
+    /// Describes an item that can be selected
+    /// </summary>
+    public interface ISelectableItem : IKeyName
+    {
+        event EventHandler ItemUpdated;
+
+        [JsonProperty("isSelected")]
+        bool IsSelected { get; set;  }
+        void Select();
+    }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/ISelectableItems.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+    /// <summary>
+    /// Describes a collection of items that can be selected
+    /// </summary>
+    /// <typeparam name="TKey">type for the keys in the collection.  Probably a string or enum</typeparam>
+    public interface ISelectableItems<TKey>
+    {
+        event EventHandler ItemsUpdated;
+        event EventHandler CurrentItemChanged;
+
+        [JsonProperty("items")]
+        Dictionary<TKey, ISelectableItem> Items { get; set; }
+
+        [JsonProperty("currentItem")]
+        string CurrentItem { get; set; }
+    }
+}

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

@@ -48,6 +48,20 @@ namespace PepperDash.Essentials.Core
                 }
             });
         }
+
+        public override bool CustomActivate()
+        {
+            CreateMobileControlMessengers();
+
+            return base.CustomActivate();
+        }
+
+        /// <summary>
+        /// Override this method to build and create custom Mobile Control Messengers during the Activation phase
+        /// </summary>
+        protected virtual void CreateMobileControlMessengers() {
+           
+        }
     }
 
     [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]

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

@@ -8,7 +8,7 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
-using PepperDash_Essentials_Core.Bridges.JoinMaps;
+using PepperDash.Essentials.Core.Bridges.JoinMaps;
 
 namespace PepperDash.Essentials.Core.Devices
 {

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

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

src/PepperDash.Essentials.Core/PepperDash.Essentials.Core.csproj

@@ -7,10 +7,10 @@
     <TargetFrameworks>net472;net6</TargetFrameworks>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
     <OutputPath>bin\$(Configuration)\</OutputPath>
-    <AssemblyName>PepperDash.Essentials.Core</AssemblyName>
+    <AssemblyName>PepperDash_Essentials_Core</AssemblyName>
     <RootNamespace>PepperDash.Essentials.Core</RootNamespace>
     <Title>PepperDash Essentials Core</Title>
-    <PackageId>$(AssemblyName)</PackageId>
+    <PackageId>PepperDash.Essentials.Core</PackageId>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>full</DebugType>
@@ -23,7 +23,7 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-beta-385" />
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-392" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Crestron\CrestronGenericBaseDevice.cs.orig" />

src/PepperDash.Essentials.Core/Plugins/PluginLoader.cs

@@ -357,6 +357,7 @@ namespace PepperDash.Essentials
                     try
                     {
                         types = assy.GetTypes();
+                        Debug.Console(1, $"Got types for assembly {assy.GetName().Name}");
                     }
                     catch (TypeLoadException e)
                     {
@@ -370,6 +371,10 @@ namespace PepperDash.Essentials
                     {
                         try
                         {
+                            //Debug.Console(0, $"Checking if type {type.Name} is IPluginDeviceFactory");
+
+                            //Debug.Console(0, $"{type.Name} is plugin factory: {typeof(IPluginDeviceFactory).IsAssignableFrom(type) && !type.IsAbstract}");                           
+                           
                             if (typeof (IPluginDeviceFactory).IsAssignableFrom(type) && !type.IsAbstract)
                             {
                                 var plugin =

src/PepperDash.Essentials.Core/Room/Config/EssentialsDualDisplayRoomPropertiesConfig.cs

@@ -0,0 +1,8 @@
+
+namespace PepperDash.Essentials.Room.Config
+{
+    public class EssentialsDualDisplayRoomPropertiesConfig : EssentialsNDisplayRoomPropertiesConfig
+    {
+
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsHuddleRoomPropertiesConfig.cs

@@ -0,0 +1,34 @@
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsHuddleRoomPropertiesConfig : EssentialsRoomPropertiesConfig
+    {
+        /// <summary>
+        /// The key of the default display device
+        /// </summary>
+        [JsonProperty("defaultDisplayKey")]
+        public string DefaultDisplayKey { get; set; }
+
+        /// <summary>
+        /// The key of the default audio device
+        /// </summary>
+        [JsonProperty("defaultAudioKey")]
+        public string DefaultAudioKey { get; set; }
+
+        /// <summary>
+        /// The key of the source list for the room
+        /// </summary>
+        [JsonProperty("sourceListKey")]
+        public string SourceListKey { get; set; }
+
+        /// <summary>
+        /// The key of the default source item from the source list
+        /// </summary>
+        [JsonProperty("defaultSourceItem")]
+        public string DefaultSourceItem { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsHuddleVtc1PropertiesConfig.cs

@@ -0,0 +1,13 @@
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Room.Config
+{
+
+    public class EssentialsHuddleVtc1PropertiesConfig : EssentialsConferenceRoomPropertiesConfig
+    {
+		[JsonProperty("defaultDisplayKey")]
+		public string DefaultDisplayKey { get; set; }
+
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsNDisplayRoomPropertiesConfig.cs

@@ -0,0 +1,34 @@
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsNDisplayRoomPropertiesConfig : EssentialsConferenceRoomPropertiesConfig
+    {
+        [JsonProperty("defaultAudioBehavior")]
+        public string DefaultAudioBehavior { get; set; }
+        [JsonProperty("defaultVideoBehavior")]
+        public string DefaultVideoBehavior { get; set; }
+        [JsonProperty("displays")]
+        public Dictionary<eSourceListItemDestinationTypes, DisplayItem> Displays { get; set; }
+
+        public EssentialsNDisplayRoomPropertiesConfig()
+        {
+            Displays = new Dictionary<eSourceListItemDestinationTypes, DisplayItem>();
+        }
+
+    }
+
+    public class DisplayItem : IKeyName
+    {
+        public string Key { get; set; }
+        public string Name { get; set; }
+    }
+
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsPresentationPropertiesConfig.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsPresentationRoomPropertiesConfig : EssentialsRoomPropertiesConfig
+    {
+        public string DefaultAudioBehavior { get; set; }
+        public string DefaultAudioKey { get; set; }
+        public string DefaultVideoBehavior { get; set; }
+        public List<string> DisplayKeys { get; set; }
+        public string SourceListKey { get; set; }
+        public bool HasDsp { get; set; }
+
+        public EssentialsPresentationRoomPropertiesConfig()
+        {
+            DisplayKeys = new List<string>();
+        }
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsRoomConfig.cs

@@ -0,0 +1,364 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Privacy;
+
+namespace PepperDash.Essentials.Room.Config
+{
+	public class EssentialsRoomConfigHelper
+	{
+        /// <summary>
+        /// Gets and operating, standalone emergegncy object that can be plugged into a room.
+        /// Returns null if there is no emergency defined
+        /// </summary>
+        public static EssentialsRoomEmergencyBase GetEmergency(EssentialsRoomPropertiesConfig props, IEssentialsRoom room)
+        {
+            // This emergency 
+            var emergency = props.Emergency;
+            if (emergency != null)
+            {
+                //switch on emergency type here.  Right now only contact and shutdown
+                var e = new EssentialsRoomEmergencyContactClosure(room.Key + "-emergency", props.Emergency, room);
+                DeviceManager.AddDevice(e);
+            }
+            return null;
+        }
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="props"></param>
+		/// <param name="room"></param>
+		/// <returns></returns>
+		public static MicrophonePrivacyController GetMicrophonePrivacy(
+			EssentialsRoomPropertiesConfig props, IPrivacy room)
+		{
+			var microphonePrivacy = props.MicrophonePrivacy;
+			if (microphonePrivacy == null)
+			{
+				Debug.Console(0, "Cannot create microphone privacy with null properties");
+				return null;
+			}
+			// Get the MicrophonePrivacy device from the device manager
+			var mP = (DeviceManager.GetDeviceForKey(props.MicrophonePrivacy.DeviceKey) as MicrophonePrivacyController);
+			// Set this room as the IPrivacy device
+			if (mP == null)
+			{
+				Debug.Console(0, "ERROR: Selected device {0} is not MicrophonePrivacyController", props.MicrophonePrivacy.DeviceKey);
+				return null;
+			}
+			mP.SetPrivacyDevice(room);
+
+			var behaviour = props.MicrophonePrivacy.Behaviour.ToLower();
+
+			if (behaviour == null)
+			{
+				Debug.Console(0, "WARNING: No behaviour defined for MicrophonePrivacyController");
+				return null;
+			}
+			if (behaviour == "trackroomstate")
+			{
+				// Tie LED enable to room power state
+                var essRoom = room as IEssentialsRoom;
+                essRoom.OnFeedback.OutputChange += (o, a) =>
+				{
+                    if (essRoom.OnFeedback.BoolValue)
+						mP.EnableLeds = true;
+					else
+						mP.EnableLeds = false;
+				};
+
+                mP.EnableLeds = essRoom.OnFeedback.BoolValue;
+			}
+			else if (behaviour == "trackcallstate")
+			{
+				// Tie LED enable to room power state
+                var inCallRoom = room as IHasInCallFeedback;
+                inCallRoom.InCallFeedback.OutputChange += (o, a) =>
+				{
+                    if (inCallRoom.InCallFeedback.BoolValue)
+						mP.EnableLeds = true;
+					else
+						mP.EnableLeds = false;
+				};
+
+                mP.EnableLeds = inCallRoom.InCallFeedback.BoolValue;
+			}
+
+			return mP;
+		}
+	
+	}
+
+    /// <summary>
+    /// 
+    /// </summary>
+	public class EssentialsRoomPropertiesConfig
+	{
+		[JsonProperty("addresses")]
+		public EssentialsRoomAddressPropertiesConfig Addresses { get; set; }
+
+		[JsonProperty("description")]
+		public string Description { get; set; }
+
+		[JsonProperty("emergency")]
+		public EssentialsRoomEmergencyConfig Emergency { get; set; }
+
+		[JsonProperty("help")]
+		public EssentialsHelpPropertiesConfig Help { get; set; }
+
+		[JsonProperty("helpMessage")]
+		public string HelpMessage { get; set; }
+
+        /// <summary>
+        /// Read this value to get the help message.  It checks for the old and new config format.
+        /// </summary>
+        public string HelpMessageForDisplay
+        {
+            get
+            {
+                if(Help != null && !string.IsNullOrEmpty(Help.Message))
+                {
+                    return Help.Message;
+                }
+                else
+                {
+                    return HelpMessage; 
+                }
+            }
+        }
+
+		[JsonProperty("environment")]
+		public EssentialsEnvironmentPropertiesConfig Environment { get; set; }
+
+		[JsonProperty("logo")]
+		public EssentialsLogoPropertiesConfig LogoLight { get; set; }
+
+        [JsonProperty("logoDark")]
+        public EssentialsLogoPropertiesConfig LogoDark { get; set; }
+	
+		[JsonProperty("microphonePrivacy")]
+		public EssentialsRoomMicrophonePrivacyConfig MicrophonePrivacy { get; set; }
+
+		[JsonProperty("occupancy")]
+		public EssentialsRoomOccSensorConfig Occupancy { get; set; }
+
+		[JsonProperty("oneButtonMeeting")]
+		public EssentialsOneButtonMeetingPropertiesConfig OneButtonMeeting { get; set; }
+
+		[JsonProperty("shutdownVacancySeconds")]
+		public int ShutdownVacancySeconds { get; set; }
+
+		[JsonProperty("shutdownPromptSeconds")]
+		public int ShutdownPromptSeconds { get; set; }
+
+		[JsonProperty("tech")]
+		public EssentialsRoomTechConfig Tech { get; set; }
+
+		[JsonProperty("volumes")]
+		public EssentialsRoomVolumesConfig Volumes { get; set; }
+
+        [JsonProperty("fusion")]
+        public EssentialsRoomFusionConfig Fusion { get; set; }
+
+        [JsonProperty("essentialsRoomUiBehaviorConfig", NullValueHandling=NullValueHandling.Ignore)]
+        public EssentialsRoomUiBehaviorConfig UiBehavior { get; set; }
+
+		[JsonProperty("zeroVolumeWhenSwtichingVolumeDevices")]
+		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; set; }
+
+        /// <summary>
+        /// Indicates if this room represents a combination of other rooms
+        /// </summary>
+        [JsonProperty("isRoomCombinationScenario")]
+        public bool IsRoomCombinationScenario { get; set; }
+
+        public EssentialsRoomPropertiesConfig()
+        {
+            LogoLight = new EssentialsLogoPropertiesConfig();
+            LogoDark = new EssentialsLogoPropertiesConfig();
+        }
+	}
+
+    public class EssentialsRoomUiBehaviorConfig
+    {
+        [JsonProperty("disableActivityButtonsWhileWarmingCooling")]
+        public bool DisableActivityButtonsWhileWarmingCooling { get; set; }
+    }
+
+    public class EssentialsAvRoomPropertiesConfig : EssentialsRoomPropertiesConfig
+    {
+        [JsonProperty("defaultAudioKey")]
+        public string DefaultAudioKey { get; set; }
+        [JsonProperty("sourceListKey")]
+        public string SourceListKey { get; set; }
+        [JsonProperty("destinationListKey")]
+        public string DestinationListKey { get; set; }
+        [JsonProperty("defaultSourceItem")]
+        public string DefaultSourceItem { get; set; }
+        /// <summary>
+        /// Indicates if the room supports advanced sharing
+        /// </summary>
+        [JsonProperty("supportsAdvancedSharing")]
+        public bool SupportsAdvancedSharing { get; set; }
+        /// <summary>
+        /// Indicates if non-tech users can change the share mode
+        /// </summary>
+        [JsonProperty("userCanChangeShareMode")]
+        public bool UserCanChangeShareMode { get; set; }
+    }
+
+    public class EssentialsConferenceRoomPropertiesConfig : EssentialsAvRoomPropertiesConfig
+    {
+        [JsonProperty("videoCodecKey")]
+        public string VideoCodecKey { get; set; }
+        [JsonProperty("audioCodecKey")]
+        public string AudioCodecKey { get; set; }
+    }
+
+	public class EssentialsEnvironmentPropertiesConfig
+	{
+		public bool Enabled { get; set; }
+
+        [JsonProperty("deviceKeys")]
+        public List<string> DeviceKeys { get; set; }
+
+        public EssentialsEnvironmentPropertiesConfig()
+        {
+            DeviceKeys = new List<string>();
+        }
+
+	}
+
+    public class EssentialsRoomFusionConfig
+    {
+        public uint IpIdInt
+        {
+            get
+            {
+                try 
+                {
+                    return Convert.ToUInt32(IpId, 16);
+                }
+                catch (Exception)
+                {
+                    throw new FormatException(string.Format("ERROR:Unable to convert IP ID: {0} to hex.  Error:\n{1}", IpId));
+                }
+          
+            }
+        }
+
+        [JsonProperty("ipId")]
+        public string IpId { get; set; }
+
+        [JsonProperty("joinMapKey")]
+        public string JoinMapKey { get; set; }
+
+    }
+
+    public class EssentialsRoomMicrophonePrivacyConfig
+    {
+		[JsonProperty("deviceKey")]
+		public string DeviceKey { get; set; }
+
+		[JsonProperty("behaviour")]
+		public string Behaviour { get; set; }
+    }
+
+    /// <summary>
+    /// Properties for the help text box
+    /// </summary>
+    public class EssentialsHelpPropertiesConfig
+    {
+		[JsonProperty("message")]
+		public string Message { get; set; }
+
+		[JsonProperty("showCallButton")]
+		public bool ShowCallButton { get; set; }
+        
+		/// <summary>
+        /// Defaults to "Call Help Desk"
+        /// </summary>
+		[JsonProperty("callButtonText")]
+		public string CallButtonText { get; set; }
+
+        public EssentialsHelpPropertiesConfig()
+        {
+            CallButtonText = "Call Help Desk";
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsOneButtonMeetingPropertiesConfig
+    {
+		[JsonProperty("enable")]
+		public bool Enable { get; set; }
+    }
+
+    public class EssentialsRoomAddressPropertiesConfig
+    {
+		[JsonProperty("phoneNumber")]
+		public string PhoneNumber { get; set; }
+
+		[JsonProperty("sipAddress")]
+		public string SipAddress { get; set; }
+    }
+
+
+    /// <summary>
+    /// Properties for the room's logo on panels
+    /// </summary>
+    public class EssentialsLogoPropertiesConfig
+    {
+		[JsonProperty("type")]
+		public string Type { get; set; }
+
+		[JsonProperty("url")]
+		public string Url { get; set; }
+        /// <summary>
+        /// Gets either the custom URL, a local-to-processor URL, or null if it's a default logo
+        /// </summary>
+        public string GetLogoUrlLight()
+        {
+            if (Type == "url")
+                return Url;
+            if (Type == "system")
+                return string.Format("http://{0}:8080/logo.png", 
+                    CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0));
+            return null;
+        }
+
+        public string GetLogoUrlDark()
+        {
+            if (Type == "url")
+                return Url;
+            if (Type == "system")
+                return string.Format("http://{0}:8080/logo-dark.png",
+                    CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0));
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Represents occupancy sensor(s) setup for a room
+    /// </summary>
+    public class EssentialsRoomOccSensorConfig
+    {
+		[JsonProperty("deviceKey")]
+		public string DeviceKey { get; set; }
+
+		[JsonProperty("timeoutMinutes")]
+		public int TimeoutMinutes { get; set; }
+    }
+
+	public class EssentialsRoomTechConfig
+	{
+		[JsonProperty("password")]
+		public string Password { get; set; }
+	}
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsRoomEmergencyConfig.cs

@@ -0,0 +1,30 @@
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsRoomEmergencyConfig
+    {
+        public EssentialsRoomEmergencyTriggerConfig Trigger { get; set; }
+
+        public string Behavior { get; set; }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsRoomEmergencyTriggerConfig
+    {
+        /// <summary>
+        /// contact,
+        /// </summary>
+        public string Type { get; set; }
+        /// <summary>
+        /// Input number if contact
+        /// </summary>
+        public int Number { get; set; }
+
+        public bool TriggerOnClose { get; set; }
+
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsTechRoomConfig.cs

@@ -0,0 +1,77 @@
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using PepperDash.Essentials.Room.Config;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    public class EssentialsTechRoomConfig
+    {
+        /// <summary>
+        /// The key of the dummy device used to enable routing
+        /// </summary>
+        [JsonProperty("dummySourceKey")]
+        public string DummySourceKey { get; set; }
+
+        /// <summary>
+        /// The keys of the displays assigned to this room
+        /// </summary>
+        [JsonProperty("displays")]
+        public List<string> Displays { get; set; }
+        
+        /// <summary>
+        /// The keys of the tuners assinged to this room
+        /// </summary>
+        [JsonProperty("tuners")]
+        public List<string> Tuners { get; set; }
+
+        /// <summary>
+        /// PIN to access the room as a normal user
+        /// </summary>
+        [JsonProperty("userPin")]
+        public string UserPin { get; set; }
+
+        /// <summary>
+        /// PIN to access the room as a tech user
+        /// </summary>
+        [JsonProperty("techPin")]
+        public string TechPin { get; set; }
+
+        /// <summary>
+        /// Name of the presets file.  Path prefix is assumed to be /html/presets/lists/
+        /// </summary>
+        [JsonProperty("presetsFileName")]
+        public string PresetsFileName { get; set; }
+
+        [JsonProperty("scheduledEvents")]
+        public List<ScheduledEventConfig> ScheduledEvents { get; set; }
+
+        /// <summary>
+        /// Indicates that the room is the primary when true
+        /// </summary>
+        [JsonProperty("isPrimary")]
+        public bool IsPrimary { get; set; }
+
+        /// <summary>
+        /// Indicates which tuners should mirror preset recall when two rooms are configured in a primary->secondary scenario
+        /// </summary>
+        [JsonProperty("mirroredTuners")]
+        public Dictionary<uint, string> MirroredTuners { get; set; }
+
+        [JsonProperty("helpMessage")]
+        public string HelpMessage { get; set; }
+
+        /// <summary>
+        /// Indicates the room 
+        /// </summary>
+        [JsonProperty("isTvPresetsProvider")] 
+        public bool IsTvPresetsProvider;
+
+        public EssentialsTechRoomConfig()
+        {
+            Displays = new List<string>();
+            Tuners = new List<string>();
+            ScheduledEvents = new List<ScheduledEventConfig>();
+        }
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/EssentialsVolumeLevelConfig.cs

@@ -0,0 +1,91 @@
+using System;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsRoomVolumesConfig
+    {
+        public EssentialsVolumeLevelConfig Master { get; set; }
+        public EssentialsVolumeLevelConfig Program { get; set; }
+        public EssentialsVolumeLevelConfig AudioCallRx { get; set; }
+        public EssentialsVolumeLevelConfig AudioCallTx { get; set; }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsVolumeLevelConfig
+    {
+        public string DeviceKey { get; set; }
+        public string Label { get; set; }
+        public int Level { get; set; }
+
+        /// <summary>
+        /// Helper to get the device associated with key - one timer.
+        /// </summary>
+        public IBasicVolumeWithFeedback GetDevice()
+        {
+            throw new NotImplementedException("This method references DM CHASSIS Directly");
+            /*
+            // DM output card format: deviceKey--output~number, dm8x8-1--output~4
+            var match = Regex.Match(DeviceKey, @"([-_\w]+)--(\w+)~(\d+)");
+            if (match.Success)
+            {
+                var devKey = match.Groups[1].Value;
+                var chassis = DeviceManager.GetDeviceForKey(devKey) as DmChassisController;
+                if (chassis != null)
+                {
+                    var outputNum = Convert.ToUInt32(match.Groups[3].Value);
+                    if (chassis.VolumeControls.ContainsKey(outputNum)) // should always...
+                        return chassis.VolumeControls[outputNum];
+                }
+                // No volume for some reason. We have failed as developers
+                return null;
+            }
+
+            // DSP/DMPS format: deviceKey--levelName, biampTesira-1--master
+            match = Regex.Match(DeviceKey, @"([-_\w]+)--(.+)");
+            if (match.Success)
+            {
+                var devKey = match.Groups[1].Value;
+                var dsp = DeviceManager.GetDeviceForKey(devKey) as BiampTesiraForteDsp;
+                if (dsp != null)
+                {
+                    var levelTag = match.Groups[2].Value;
+                    if (dsp.LevelControlPoints.ContainsKey(levelTag)) // should always...
+                        return dsp.LevelControlPoints[levelTag];
+                }
+
+                var dmps = DeviceManager.GetDeviceForKey(devKey) as DmpsAudioOutputController;
+                if (dmps != null)
+                {
+                    var levelTag = match.Groups[2].Value;
+                    switch (levelTag)
+                    {
+                        case "master":
+                            return dmps.MasterVolumeLevel;
+                        case "source":
+                            return dmps.SourceVolumeLevel;
+                        case "micsmaster":
+                            return dmps.MicsMasterVolumeLevel;
+                        case "codec1":
+                            return dmps.Codec1VolumeLevel;
+                        case "codec2":
+                            return dmps.Codec2VolumeLevel;
+                        default:
+                            return dmps.MasterVolumeLevel;
+                    }
+                }
+                // No volume for some reason. We have failed as developers
+                return null;
+            }
+
+            return null;
+        }
+             * */
+        }
+    }
+}

src/PepperDash.Essentials.Core/Room/Config/SimplRoomPropertiesConfig.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Room.Config
+{
+	public class SimplRoomPropertiesConfig : EssentialsHuddleVtc1PropertiesConfig
+	{
+		[JsonProperty("roomPhoneNumber")]
+		public string RoomPhoneNumber { get; set; }
+		[JsonProperty("roomURI")]
+		public string RoomURI { get; set; }
+		[JsonProperty("speedDials")]
+		public List<SimplSpeedDial> SpeedDials { get; set; }
+		[JsonProperty("volumeSliderNames")]
+		public List<string> VolumeSliderNames { get; set; }
+	}
+
+	public class SimplSpeedDial
+	{
+		[JsonProperty("name")]
+		public string Name { get; set; }
+		[JsonProperty("number")]
+		public string Number { get; set; }
+	}
+}

src/PepperDash.Essentials.Core/Room/EsentialsRoomEmergencyContactClosure.cs

@@ -0,0 +1,47 @@
+using System;
+using Crestron.SimplSharpPro;
+using PepperDash.Essentials.Room.Config;
+
+namespace PepperDash.Essentials.Core
+{
+    public class EssentialsRoomEmergencyContactClosure : EssentialsRoomEmergencyBase
+    {
+        IEssentialsRoom Room;
+        string Behavior;
+        bool TriggerOnClose;
+
+        public EssentialsRoomEmergencyContactClosure(string key, EssentialsRoomEmergencyConfig config, IEssentialsRoom room) :
+            base(key)
+        {
+            Room = room;
+            var cs = Global.ControlSystem;
+
+            if (config.Trigger.Type.Equals("contact", StringComparison.OrdinalIgnoreCase))
+            {
+                var portNum = (uint)config.Trigger.Number;
+                if (portNum <= cs.NumberOfDigitalInputPorts)
+                {
+                    cs.DigitalInputPorts[portNum].Register();
+                    cs.DigitalInputPorts[portNum].StateChange += EsentialsRoomEmergencyContactClosure_StateChange;
+                }
+            }
+            Behavior = config.Behavior;
+            TriggerOnClose = config.Trigger.TriggerOnClose;
+        }
+
+        void EsentialsRoomEmergencyContactClosure_StateChange(DigitalInput digitalInput, DigitalInputEventArgs args)
+        {
+            if (args.State && TriggerOnClose || !args.State && !TriggerOnClose)
+                RunEmergencyBehavior();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void RunEmergencyBehavior()
+        {
+            if (Behavior.Equals("shutdown"))
+                Room.Shutdown();
+        }
+    }
+}

src/PepperDash.Essentials.Core/Room/EssentialsRoomBase.cs

@@ -18,8 +18,6 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public abstract class EssentialsRoomBase : ReconfigurableDevice, IEssentialsRoom
     {
-
-
         /// <summary>
         ///
         /// </summary>
@@ -58,7 +56,7 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// The bridge for this room if Mobile Control is enabled
         /// </summary>
-        public IMobileControlRoomBridge MobileControlRoomBridge { get; private set; }
+        public IMobileControlRoomMessenger MobileControlRoomBridge { get; private set; }
 
         /// <summary>
         /// The config name of the source list
@@ -79,6 +77,8 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 
+        public string DestinationListKey { get; private set; }
+
         protected const string _defaultSourceListKey = "default";
 
         /// <summary>
@@ -194,6 +194,14 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        protected void SetDestinationListKey(string destinationListKey)
+        {
+            if (!string.IsNullOrEmpty(destinationListKey))
+            {
+                DestinationListKey = destinationListKey;
+            }
+        }
+
         /// <summary>
         /// If mobile control is enabled, sets the appropriate properties
         /// </summary>
@@ -209,7 +217,7 @@ namespace PepperDash.Essentials.Core
             }
             else
             {
-                MobileControlRoomBridge = mcBridge as IMobileControlRoomBridge;
+                MobileControlRoomBridge = mcBridge as IMobileControlRoomMessenger;
                 Debug.Console(1, this, "*********************Mobile Control Bridge found and enabled for this room");
                 IsMobileControlEnabled = true;
             }

src/PepperDash.Essentials.Core/Room/IEssentialsRoom.cs

@@ -23,10 +23,12 @@ namespace PepperDash.Essentials.Core
         BoolFeedback IsCoolingDownFeedback { get; }        
 
         bool IsMobileControlEnabled { get; }
-        IMobileControlRoomBridge MobileControlRoomBridge { get; }
+        IMobileControlRoomMessenger MobileControlRoomBridge { get; }
 
         string SourceListKey { get; }
 
+        string DestinationListKey { get; }
+
         SecondsCountdownTimer ShutdownPromptTimer { get; }
         int ShutdownPromptSeconds { get; }
         int ShutdownVacancySeconds { get; }

src/PepperDash.Essentials.Core/Room/Interfaces.cs

@@ -48,7 +48,7 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public interface IRunDirectRouteAction
     {
-        void RunDirectRoute(string sourceKey, string destinationKey);
+        void RunDirectRoute(string sourceKey, string destinationKey, eRoutingSignalType type = eRoutingSignalType.AudioVideo);
     }
 
     /// <summary>

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

@@ -0,0 +1,16 @@
+using PepperDash.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public interface IVideoSync: IKeyed
+    {
+        bool VideoSyncDetected { get; }
+
+        event EventHandler VideoSyncChanged;
+    }
+}

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

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public interface IMatrixRouting
+    {
+        Dictionary<string, IRoutingInputSlot> InputSlots { get; }
+        Dictionary<string, IRoutingOutputSlot> OutputSlots { get; }
+
+        void Route(string inputSlotKey, string outputSlotKey, eRoutingSignalType type);
+    }
+}

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

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public interface IRoutingInputSlot: IRoutingSlot, IOnline, IVideoSync
+    {
+        string TxDeviceKey { get; }
+    }
+}

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

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public interface IRoutingOutputSlot:IRoutingSlot
+    {
+        event EventHandler OutputSlotChanged;
+
+        string RxDeviceKey { get; }
+
+        Dictionary<eRoutingSignalType, IRoutingInputSlot> CurrentRoutes { get; }
+    }
+}

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

@@ -0,0 +1,16 @@
+using PepperDash.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public interface IRoutingSlot:IKeyName
+    {
+        int SlotNumber { get; }
+
+        eRoutingSignalType SupportedSignalTypes { get; }
+    }
+}

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

@@ -36,7 +36,8 @@ namespace PepperDash.Essentials.Core
 		Video = 2,     
 		AudioVideo = Audio | Video,
         UsbOutput = 8,
-        UsbInput = 16
+        UsbInput = 16,
+        SecondaryAudio = 32
 	}
 
 	public enum eRoutingPortConnectionType

src/PepperDash.Essentials.Core/Web/EssentialsWebApi.cs

@@ -11,7 +11,7 @@ namespace PepperDash.Essentials.Core.Web
 {
 	public class EssentialsWebApi : EssentialsDevice
 	{
-		private readonly WebApiServer _server;
+		private readonly WebApiServer _server;        
 
 		///<example>
 		/// http(s)://{ipaddress}/cws/{basePath}
@@ -67,8 +67,6 @@ namespace PepperDash.Essentials.Core.Web
 			_server = new WebApiServer(Key, Name, BasePath);
 
 			SetupRoutes();
-
-			Initialize();
 		}
 
 		private void SetupRoutes()
@@ -168,10 +166,27 @@ namespace PepperDash.Essentials.Core.Web
 
             };
 
-            foreach (var route in routes.Where(route => route != null))
+            AddRoute(routes);
+        }
+
+        /// <summary>
+        /// Add a single route to the API. MUST be done during the activation phase
+        /// </summary>
+        /// <param name="route"></param>
+        public void AddRoute(HttpCwsRoute route)
+        {
+            _server.AddRoute(route);
+        }
+
+        /// <summary>
+        /// Add a collection of routes to the API. MUST be done during the activation phase
+        /// </summary>
+        /// <param name="routes"></param>
+        public void AddRoute(List<HttpCwsRoute> routes)
+        {
+            foreach (var route in routes)
             {
-                var r = route;
-                _server.AddRoute(r);
+                AddRoute(route);
             }
         }
 

src/PepperDash.Essentials.Devices.Common/DSP/DspBase.cs

@@ -6,12 +6,13 @@ using Crestron.SimplSharp;
 using PepperDash.Essentials.Devices.Common.Codec;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
 
 namespace PepperDash.Essentials.Devices.Common.DSP
 {
-	public abstract class DspBase : EssentialsDevice
+	public abstract class DspBase : EssentialsDevice, ILevelControls
 	{
-		public Dictionary<string, DspControlPoint> LevelControlPoints { get; private set; }
+		public Dictionary<string,IBasicVolumeWithFeedback> LevelControlPoints { get; private set; }
 
         public Dictionary<string, DspControlPoint> DialerControlPoints { get; private set; }
 
@@ -40,15 +41,36 @@ namespace PepperDash.Essentials.Devices.Common.DSP
 		// Typical presets:
 		// call default preset to restore levels and mutes
 
-	public abstract class DspControlPoint 
+	public abstract class DspControlPoint :IKeyed
 	{
-         string Key { get; set; }
+        public string Key { get; }
+
+        protected DspControlPoint(string key) => Key = key;
 	}
 
+    public abstract class DspLevelControlPoint :DspControlPoint, IBasicVolumeWithFeedback
+    {
+        public BoolFeedback MuteFeedback { get; }
+        public IntFeedback VolumeLevelFeedback { get; }
 
-	public class DspDialerBase
+        protected DspLevelControlPoint(string key, Func<bool> muteFeedbackFunc, Func<int> volumeLevelFeedbackFunc) : base(key)
+        {
+            MuteFeedback = new BoolFeedback(muteFeedbackFunc);
+            VolumeLevelFeedback = new IntFeedback(volumeLevelFeedbackFunc);
+        }
+
+        public abstract void MuteOff();
+        public abstract void MuteOn();
+        public abstract void MuteToggle();
+        public abstract void SetVolume(ushort level);
+        public abstract void VolumeDown(bool pressRelease);
+        public abstract void VolumeUp(bool pressRelease);
+    }
+
+
+    public abstract class DspDialerBase:DspControlPoint
 	{
-
+        protected DspDialerBase(string key) : base(key) { }
 	}
 
 

src/PepperDash.Essentials.Devices.Common/Displays/DisplayBase.cs

@@ -8,10 +8,16 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using Feedback = PepperDash.Essentials.Core.Feedback;
 using Newtonsoft.Json;
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
 
 namespace PepperDash.Essentials.Devices.Common.Displays
 {
-    public abstract class DisplayBase : EssentialsDevice, IHasFeedback, IRoutingSinkWithSwitching, IHasPowerControl, IWarmingCooling, IUsageTracking
+    public abstract class DisplayBase : EssentialsDevice
+        , IHasFeedback
+        , IRoutingSinkWithSwitching
+        , IHasPowerControl
+        , IWarmingCooling
+        , IUsageTracking
 	{
         public event SourceInfoChangeHandler CurrentSourceChange;
 

src/PepperDash.Essentials.Devices.Common/Displays/MockDisplay.cs

@@ -1,21 +1,19 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
 using PepperDash.Essentials.Core.Routing;
 
 namespace PepperDash.Essentials.Devices.Common.Displays
 {
-    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced
-
+    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced, IHasInputs<string, string>
 	{
-		public RoutingInputPort HdmiIn1 { get; private set; }
-		public RoutingInputPort HdmiIn2 { get; private set; }
-		public RoutingInputPort HdmiIn3 { get; private set; }
-		public RoutingInputPort ComponentIn1 { get; private set; }
-		public RoutingInputPort VgaIn1 { get; private set; }
+        public ISelectableItems<string> Inputs { get; private set; }
 
 		bool _PowerIsOn;
 		bool _IsWarmingUp;
@@ -53,7 +51,7 @@ namespace PepperDash.Essentials.Devices.Common.Displays
                 };
             }
         }
-        protected override Func<string> CurrentInputFeedbackFunc { get { return () => "Not Implemented"; } }
+        protected override Func<string> CurrentInputFeedbackFunc { get { return () => Inputs.CurrentItem; } }
 
         int VolumeHeldRepeatInterval = 200;
         ushort VolumeInterval = 655;
@@ -63,17 +61,31 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 		public MockDisplay(string key, string name)
 			: base(key, name)
 		{
-			HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			ComponentIn1 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Component, null, this);
-			VgaIn1 = new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Composite, null, this);
-			InputPorts.AddRange(new[] { HdmiIn1, HdmiIn2, HdmiIn3, ComponentIn1, VgaIn1 });
+            Inputs = new MockDisplayInputs
+            {
+                Items = new Dictionary<string, ISelectableItem>
+				{
+					{ "HDMI1", new MockDisplayInput ( "HDMI1", "HDMI 1",this ) },
+					{ "HDMI2", new MockDisplayInput ("HDMI2", "HDMI 2",this ) },
+					{ "HDMI3", new MockDisplayInput ("HDMI3", "HDMI 3",this ) },
+					{ "HDMI4", new MockDisplayInput ("HDMI4", "HDMI 4",this )},
+					{ "DP", new MockDisplayInput ("DP", "DisplayPort", this ) }
+				}
+            };
+
+			Inputs.CurrentItemChanged += (o, a) => CurrentInputFeedback.FireUpdate();
+           
+            var hdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, "HDMI1", this);
+			var hdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, "HDMI2", this);
+			var hdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, "HDMI3", this);
+			var hdmiIn4 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, "HDMI4", this);
+			var dpIn = new RoutingInputPort(RoutingPortNames.DisplayPortIn, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.DisplayPort, "DP", this);
+			InputPorts.AddRange(new[] { hdmiIn1, hdmiIn2, hdmiIn3, hdmiIn4, dpIn });
 
 			VolumeLevelFeedback = new IntFeedback(() => { return _FakeVolumeLevel; });
 			MuteFeedback = new BoolFeedback("MuteOn", () => _IsMuted);
@@ -135,13 +147,43 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 		    {
 		        PowerOn();
 		    }
+
+			if (!Inputs.Items.TryGetValue(selector.ToString(), out var input))
+				return;
+
+			input.Select();
 		}
 
+        public void SetInput(string selector)
+        {
+			ISelectableItem currentInput = null;
+
+			try
+			{
+				currentInput = Inputs.Items.SingleOrDefault(Inputs => Inputs.Value.IsSelected).Value;
+			}
+			catch { }
+			
+
+            if (currentInput != null)
+            {
+                Debug.Console(2, this, "SetInput: {0}", selector);
+                currentInput.IsSelected = false;
+            }
+
+			if (!Inputs.Items.TryGetValue(selector, out var input))
+                return;
+
+			input.IsSelected = true;
+
+			Inputs.CurrentItem = selector;
+        }
 
 
-		#region IBasicVolumeWithFeedback Members
 
-		public IntFeedback VolumeLevelFeedback { get; private set; }
+        #region IBasicVolumeWithFeedback Members
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
 
 		public void SetVolume(ushort level)
 		{
@@ -163,11 +205,12 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 
 		public BoolFeedback MuteFeedback { get; private set; }
 
-		#endregion
 
-		#region IBasicVolumeControls Members
+        #endregion
 
-		public void VolumeUp(bool pressRelease)
+        #region IBasicVolumeControls Members
+
+        public void VolumeUp(bool pressRelease)
 		{
             //while (pressRelease)
             //{
@@ -207,5 +250,7 @@ namespace PepperDash.Essentials.Devices.Common.Displays
 	    {
 	        LinkDisplayToApi(this, trilist, joinStart, joinMapKey, bridge);
 	    }
-	}
+
+
+    }
 }

src/PepperDash.Essentials.Devices.Common/Displays/MockDisplayInputs.cs

@@ -0,0 +1,97 @@
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Displays
+{
+    public class MockDisplayInputs : ISelectableItems<string>
+    {
+        private Dictionary<string, ISelectableItem> _items;
+
+        public Dictionary<string, ISelectableItem> Items
+        {
+            get
+            {
+                return _items;
+            }
+            set
+            {
+                if (_items == value)
+                    return;
+
+                _items = value;
+
+                ItemsUpdated?.Invoke(this, null);
+            }
+        }
+
+        private string _currentItem;
+
+        public string CurrentItem
+        { 
+            get
+            {
+                return _currentItem;
+            }
+            set
+            {
+                if (_currentItem == value)
+                    return;
+
+                _currentItem = value;
+
+                CurrentItemChanged?.Invoke(this, null);
+            }
+        }
+
+        public event EventHandler ItemsUpdated;
+        public event EventHandler CurrentItemChanged;
+    }
+
+    public class MockDisplayInput : ISelectableItem
+    {
+        private IHasInputs<string, string> _parent;
+
+
+        private bool _isSelected;
+        
+        public bool IsSelected
+        {
+            get
+            {
+                return _isSelected;
+            }
+            set
+            {
+                if (_isSelected == value)
+                    return;
+
+                _isSelected = value;
+
+                ItemUpdated?.Invoke(this, null);
+            }
+        }
+
+        public string Name { get; set; }
+
+        public string Key { get; set; }
+
+        public event EventHandler ItemUpdated;
+
+        public MockDisplayInput(string key, string name, MockDisplay parent)
+        {
+            Key = key;
+            Name = name;
+            _parent = parent;
+        }
+
+        public void Select()
+        {
+            _parent.SetInput(Key);
+        }
+    }
+}

src/PepperDash.Essentials.Devices.Common/Generic/GenericSink.cs

@@ -0,0 +1,62 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Routing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.Generic
+{
+    public class GenericSink : EssentialsDevice, IRoutingSink
+    {
+        public GenericSink(string key, string name) : base(key, name)
+        {
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+
+            var inputPort = new RoutingInputPort($"{Key}-{RoutingPortNames.AnyVideoIn}", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null, this);
+
+            InputPorts.Add(inputPort);
+
+        }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+
+        public string CurrentSourceInfoKey { get; set; }
+
+        private SourceListItem _currentSource;
+        public SourceListItem CurrentSourceInfo {
+            get => _currentSource;
+            set {
+                if(value == _currentSource)
+                {
+                    return;
+                }
+
+                CurrentSourceChange?.Invoke(_currentSource, ChangeType.WillChange);
+
+                _currentSource = value;
+
+                CurrentSourceChange?.Invoke(_currentSource, ChangeType.DidChange);
+            }
+        }
+
+        public event SourceInfoChangeHandler CurrentSourceChange;
+    }
+
+    public class GenericSinkFactory : EssentialsDeviceFactory<GenericSink>
+    {
+        public GenericSinkFactory()
+        {
+            TypeNames = new List<string>() { "genericsink", "genericdestination" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new Generic Source Device");
+            return new GenericSource(dc.Key, dc.Name);
+        }
+    }
+}

src/PepperDash.Essentials.Devices.Common/Generic/GenericSource.cs

@@ -54,5 +54,4 @@ namespace PepperDash.Essentials.Devices.Common
             return new GenericSource(dc.Key, dc.Name);
         }
     }
-
 }

src/PepperDash.Essentials.Devices.Common/Lighting/LightingBase.cs

@@ -0,0 +1,142 @@
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Lighting;
+
+namespace PepperDash.Essentials.Devices.Common.Lighting
+{
+    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
+    public abstract class LightingBase : EssentialsBridgeableDevice, ILightingScenes
+    {
+        #region ILightingScenes Members
+
+        public event EventHandler<LightingSceneChangeEventArgs> LightingSceneChange;
+
+        public List<LightingScene> LightingScenes { get; protected set; }
+
+        public LightingScene CurrentLightingScene { get; protected set; }
+		
+		public IntFeedback CurrentLightingSceneFeedback { get; protected set; }
+
+        #endregion
+
+        protected LightingBase(string key, string name)
+            : base(key, name)
+        {
+            LightingScenes = new List<LightingScene>();
+
+            CurrentLightingScene = new LightingScene();
+			//CurrentLightingSceneFeedback = new IntFeedback(() => { return int.Parse(this.CurrentLightingScene.ID); });
+        }
+
+        public abstract void SelectScene(LightingScene scene);
+
+        public void SimulateSceneSelect(string sceneName)
+        {
+            Debug.Console(1, this, "Simulating selection of scene '{0}'", sceneName);
+
+            var scene = LightingScenes.FirstOrDefault(s => s.Name.Equals(sceneName));
+
+            if (scene != null)
+            {
+                CurrentLightingScene = scene;
+                OnLightingSceneChange();
+            }
+        }
+
+        /// <summary>
+        /// Sets the IsActive property on each scene and fires the LightingSceneChange event
+        /// </summary>
+        protected void OnLightingSceneChange()
+        {
+            foreach (var scene in LightingScenes)
+            {
+                if (scene == CurrentLightingScene)
+                    scene.IsActive = true;
+					
+                else
+                    scene.IsActive = false;
+            }
+
+            var handler = LightingSceneChange;
+            if (handler != null)
+            {
+                handler(this, new LightingSceneChangeEventArgs(CurrentLightingScene));
+            }
+        }
+
+	    protected GenericLightingJoinMap LinkLightingToApi(LightingBase lightingDevice, BasicTriList trilist, uint joinStart,
+		    string joinMapKey, EiscApiAdvanced bridge)
+	    {
+			var joinMap = new GenericLightingJoinMap(joinStart);
+
+			var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+			if (!string.IsNullOrEmpty(joinMapSerialized))
+				joinMap = JsonConvert.DeserializeObject<GenericLightingJoinMap>(joinMapSerialized);
+
+			if (bridge != null)
+			{
+				bridge.AddJoinMap(Key, joinMap);
+			}
+			else
+			{
+				Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+			}
+
+		    return LinkLightingToApi(lightingDevice, trilist, joinMap);
+	    }
+
+      protected GenericLightingJoinMap LinkLightingToApi(LightingBase lightingDevice, BasicTriList trilist, GenericLightingJoinMap joinMap)
+      {
+        Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+        Debug.Console(0, "Linking to Lighting Type {0}", lightingDevice.GetType().Name.ToString());
+
+        // GenericLighitng Actions & FeedBack
+        trilist.SetUShortSigAction(joinMap.SelectScene.JoinNumber, u => lightingDevice.SelectScene(lightingDevice.LightingScenes[u]));
+
+        var sceneIndex = 0;
+        foreach (var scene in lightingDevice.LightingScenes)
+        {
+          var index = sceneIndex;
+
+          trilist.SetSigTrueAction((uint)(joinMap.SelectSceneDirect.JoinNumber + index), () => lightingDevice.SelectScene(lightingDevice.LightingScenes[index]));
+          scene.IsActiveFeedback.LinkInputSig(trilist.BooleanInput[(uint)(joinMap.SelectSceneDirect.JoinNumber + index)]);
+          trilist.StringInput[(uint)(joinMap.SelectSceneDirect.JoinNumber + index)].StringValue = scene.Name;
+          trilist.BooleanInput[(uint)(joinMap.ButtonVisibility.JoinNumber + index)].BoolValue = true;
+
+          sceneIndex++;
+        }
+
+        trilist.OnlineStatusChange += (sender, args) =>
+        {
+          if (!args.DeviceOnLine) return;
+
+          sceneIndex = 0;
+          foreach (var scene in lightingDevice.LightingScenes)
+          {
+            var index = sceneIndex;
+
+            trilist.StringInput[(uint) (joinMap.SelectSceneDirect.JoinNumber + index)].StringValue = scene.Name;
+            trilist.BooleanInput[(uint) (joinMap.ButtonVisibility.JoinNumber + index)].BoolValue = true;
+            scene.IsActiveFeedback.FireUpdate();
+
+            sceneIndex++;
+          }
+        };
+
+        return joinMap;
+      }
+    }
+}

src/PepperDash.Essentials.Devices.Common/PepperDash.Essentials.Devices.Common.csproj

@@ -7,11 +7,11 @@
     <TargetFrameworks>net472;net6</TargetFrameworks>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
     <OutputPath>bin\$(Configuration)\</OutputPath>
-    <AssemblyName>PepperDash.Essentials.Devices.Common</AssemblyName>
+    <AssemblyName>Essentials Devices Common</AssemblyName>
     <RootNamespace>PepperDash.Essentials.Devices.Common</RootNamespace>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>PepperDash Essentials Devices Common</Title>
-    <PackageId>$(AssemblyName)</PackageId>
+    <PackageId>PepperDash.Essentials.Devices.Common</PackageId>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>full</DebugType>
@@ -27,6 +27,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-beta-385" />
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-392" />
   </ItemGroup>
 </Project>

src/PepperDash.Essentials.Devices.Common/Room/IEssentialsHuddleSpaceRoom.cs

@@ -1,7 +1,7 @@
-using System;
-using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Room.Config;
 
-namespace PDT.Plugins.Essentials.Rooms
+namespace PepperDash.Essentials.Devices.Common.Room
 {
     public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IHasDefaultDisplay, IHasCurrentVolumeControls, IRoomOccupancy,
         IEmergency, IMicrophonePrivacy
@@ -10,10 +10,6 @@ namespace PDT.Plugins.Essentials.Rooms
 
         void RunRouteAction(string routeKey);
 
-        // EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; }
-
-        IBasicVolumeControls CurrentVolumeControls { get; }
-
-        event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
+        EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; }
     }
 }

src/PepperDash.Essentials.Devices.Common/Room/IEssentialsHuddleVtc1Room.cs

@@ -2,13 +2,14 @@
 using PepperDash.Essentials.Devices.Common.AudioCodec;
 using PepperDash.Essentials.Devices.Common.Codec;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
+using PepperDash.Essentials.Room.Config;
 
-namespace PDT.Plugins.Essentials.Rooms
+namespace PepperDash.Essentials.Devices.Common.Room
 {
     public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback,
         IRoomOccupancy, IEmergency, IMicrophonePrivacy
     {
-        // EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
+        EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
 
         bool ExcludeFromGlobalFunctions { get; }
 

src/PepperDash.Essentials.Devices.Common/Room/IEssentialsTechRoom.cs

@@ -0,0 +1,22 @@
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
+using PepperDash.Essentials.Room.Config;
+using System.Collections.Generic;
+using TwoWayDisplayBase = PepperDash.Essentials.Devices.Common.Displays.TwoWayDisplayBase;
+
+
+namespace PepperDash.Essentials.Devices.Common.Room
+{
+    public interface IEssentialsTechRoom:IEssentialsRoom, ITvPresetsProvider,IBridgeAdvanced,IRunDirectRouteAction
+    {
+        EssentialsTechRoomConfig PropertiesConfig { get; }
+        Dictionary<string, IRSetTopBoxBase> Tuners { get; }
+
+        Dictionary<string, TwoWayDisplayBase> Displays { get; }
+
+        void RoomPowerOn();
+
+        void RoomPowerOff();
+    }
+}

src/PepperDash.Essentials.Devices.Common/SoftCodec/GenericSoftCodec.cs

@@ -0,0 +1,80 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Devices.Common.SoftCodec
+{
+    public class GenericSoftCodec : EssentialsDevice, IRoutingInputsOutputs
+    {
+        public GenericSoftCodec(string key, string name, GenericSoftCodecProperties props) : base(key, name)
+        {
+            for(var i = 1; i <= props.OutputCount; i++)
+            {
+                var outputPort = new RoutingOutputPort($"{Key}-output{i}", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null, this);
+
+                OutputPorts.Add(outputPort);
+            }
+
+            for(var i = 1; i<= props.ContentInputCount; i++)
+            {
+                var inputPort = new RoutingInputPort($"{Key}-contentInput{i}", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null, this);
+
+                InputPorts.Add(inputPort);
+            }
+
+            if (!props.HasCameraInputs)
+            {
+                return;
+            }
+
+            for(var i = 1; i <=props.CameraInputCount; i++)
+            {
+                var cameraPort = new RoutingInputPort($"{Key}-cameraInput{i}", eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null, this);
+
+                InputPorts.Add(cameraPort);
+            }
+        }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts => throw new NotImplementedException();
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts => throw new NotImplementedException();
+    }
+
+    public class GenericSoftCodecProperties
+    {
+        [JsonProperty("hasCameraInputs")]
+        public bool HasCameraInputs { get; set; }
+
+        [JsonProperty("cameraInputCount")]
+        public int CameraInputCount { get; set; }
+
+        [JsonProperty("contentInputCount")]
+        public int ContentInputCount { get; set; }
+
+        [JsonProperty("contentOutputCount")]
+        public int OutputCount { get; set; }
+    }
+
+    public class GenericSoftCodecFactory: EssentialsDeviceFactory<GenericSoftCodec>
+    {
+        public GenericSoftCodecFactory()
+        {
+            TypeNames = new List<string> { "genericsoftcodec" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Attempting to create new Generic SoftCodec Device");
+
+            var props = dc.Properties.ToObject<GenericSoftCodecProperties>();
+
+            return new GenericSoftCodec(dc.Key, dc.Name, props);
+        }
+    }
+}

src/PepperDash.Essentials/ControlSystem.cs

@@ -11,6 +11,8 @@ using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.DeviceTypeInterfaces;
 using PepperDash.Essentials.Core.Web;
+using PepperDash.Essentials.Devices.Common.Room;
+using PepperDash.Essentials.Room.Config;
 using System;
 using System.Linq;
 
@@ -33,7 +35,7 @@ namespace PepperDash.Essentials
             SecretsManager.Initialize();
             SystemMonitor.ProgramInitialization.ProgramInitializationUnderUserControl = true;
 
-            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
+            // AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
         }
 
         private System.Reflection.Assembly CurrentDomainOnAssemblyResolve(object sender, ResolveEventArgs args)
@@ -364,11 +366,11 @@ namespace PepperDash.Essentials
 
             LoadTieLines();
 
-            var mobileControl = GetMobileControlDevice();
+            /*var mobileControl = GetMobileControlDevice();
 
 		    if (mobileControl == null) return;
 
-            mobileControl.LinkSystemMonitorToAppServer();
+            mobileControl.LinkSystemMonitorToAppServer();*/
 		    
 		}
 
@@ -468,103 +470,48 @@ namespace PepperDash.Essentials
                 return;
             }
 
-            // uint fusionIpId = 0xf1;
-
             foreach (var roomConfig in ConfigReader.ConfigObject.Rooms)
             {
-                /*
-                    var room = EssentialsRoomConfigHelper.GetRoomObject(roomConfig) as IEssentialsRoom;
-                    if (room != null)
-                    {
-                        // default to no join map key
-                        string fusionJoinMapKey = string.Empty;
+                var room = Core.DeviceFactory.GetDevice(roomConfig);
 
-                        if (room.Config.Properties["fusion"] != null)
-                        {
-                            Debug.Console(2, "Custom Fusion config found. Using custom values");
+                DeviceManager.AddDevice(room);
+                if (room is ICustomMobileControl)
+                {
+                    continue;                    
+                }
 
-                            var fusionConfig = room.Config.Properties["fusion"].ToObject<EssentialsRoomFusionConfig>();
-
-                            if (fusionConfig != null)
-                            {
-                                fusionIpId = fusionConfig.IpIdInt;
-                                fusionJoinMapKey = fusionConfig.JoinMapKey;
-                            }
-                        }
-
-                        AddRoomAndBuildMC(room);
-
-                        if (room is IEssentialsHuddleSpaceRoom)
-                        {
-
-                            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleSpaceRoom, attempting to add to DeviceManager with Fusion with IP-ID {0:X2}", fusionIpId);
-                            DeviceManager.AddDevice(new Core.Fusion.EssentialsHuddleSpaceFusionSystemControllerBase(room, fusionIpId, fusionJoinMapKey));
-
-                        }
-                        else if (room is IEssentialsHuddleVtc1Room)
-                        {
-
-                            if (!(room is EssentialsCombinedHuddleVtc1Room))
-                            {
-                                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion with IP-ID {0:X2}", fusionIpId);
-                                DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((IEssentialsHuddleVtc1Room)room, fusionIpId, fusionJoinMapKey));
-                            }
-
-                        }
-                        else if (room is EssentialsTechRoom)
-                        {
-
-                            Debug.Console(0, Debug.ErrorLogLevel.Notice,
-                                "Room is EssentialsTechRoom, Attempting to add to DeviceManager with Fusion with IP-ID {0:X2}", fusionIpId);
-                            DeviceManager.AddDevice(new EssentialsTechRoomFusionSystemController((EssentialsTechRoom)room, fusionIpId, fusionJoinMapKey));
-
-                        }
-                        fusionIpId += 1;
-                    }
-                    else
-                    {
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Notice: Cannot create room from config, key '{0}' - Is this intentional?  This may be a valid configuration.", roomConfig.Key);
-
-                    }
-                */
+               // BuildMC(room as IEssentialsRoom);
             }
 
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "All Rooms Loaded.");
 
         }
 
-        private static void AddRoomAndBuildMC(IEssentialsRoom room)
-        {
-            DeviceManager.AddDevice(room);
-
-            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Mobile Control Bridge");
+        /*private static void BuildMC(IEssentialsRoom room)
+        {            
+            Debug.Console(0, Debug.ErrorLogLevel.Notice, $"Attempting to build Mobile Control Bridge for {room?.Key}");
 
             CreateMobileControlBridge(room);
         }
 
-        private static void CreateMobileControlBridge(object room)
+        private static void CreateMobileControlBridge(IEssentialsRoom room)
         {
+            if(room == null)
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Warning, $"Room does not implement IEssentialsRoom");
+                return;
+            }
+
             var mobileControl = GetMobileControlDevice();
 
-            if (mobileControl == null) return;
-
-            var mobileControl3 = mobileControl as IMobileControl3;
-
-            if (mobileControl3 != null)
-            {
-                mobileControl3.CreateMobileControlRoomBridge(room as IEssentialsRoom, mobileControl);
-            }
-            else
-            {
-                mobileControl.CreateMobileControlRoomBridge(room as EssentialsRoomBase, mobileControl);
-            }
+            mobileControl?.CreateMobileControlRoomBridge(room, mobileControl);
 
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Mobile Control Bridge Added...");
         }
 
-        private static IMobileControl GetMobileControlDevice()
+        private static IMobileControl3 GetMobileControlDevice()
         {
-            var mobileControlList = DeviceManager.AllDevices.OfType<IMobileControl>().ToList();
+            var mobileControlList = DeviceManager.AllDevices.OfType<IMobileControl3>().ToList();
 
             if (mobileControlList.Count > 1)
             {
@@ -581,7 +528,7 @@ namespace PepperDash.Essentials
 
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Mobile Control not enabled for this system");
             return null;
-        }
+        }*/
 
         /// <summary>
         /// Fires up a logo server if not already running

src/PepperDash.Essentials/PepperDash.Essentials.csproj

@@ -5,7 +5,7 @@
   </PropertyGroup>
   <PropertyGroup>
     <RootNamespace>PepperDash.Essentials</RootNamespace>
-    <AssemblyName>PepperDash.Essentials</AssemblyName>
+    <AssemblyName>PepperDashEssentials</AssemblyName>
     <TargetFrameworks>net472;net6</TargetFrameworks>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
     <OutputPath>bin\$(Configuration)\</OutputPath>
@@ -47,7 +47,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Crestron.SimplSharp.SDK.Program" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-beta-385" />
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-392" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\PepperDash.Essentials.Core\PepperDash.Essentials.Core.csproj" />