minor fixes to allow build to succeed.

PepperDashEssentials/ControlSystem.cs

@@ -16,6 +16,7 @@ using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.DM;
 using PepperDash.Essentials.Fusion;
 using PepperDash.Essentials.Room.Config;
+using PepperDash.Essentials.Core.Room;
 
 using Newtonsoft.Json;
 using PepperDash.Essentials.Core.DeviceTypeInterfaces;
@@ -60,6 +61,8 @@ namespace PepperDash.Essentials
 
             CrestronConsole.AddNewConsoleCommand(PepperDash.Essentials.Core.DeviceFactory.GetDeviceFactoryTypes, "gettypes", "Gets the device types that can be built. Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
 
+            CrestronConsole.AddNewConsoleCommand(PepperDash.Essentials.Core.Room.Components.ComponentFactory.GetComponentFactoryTypes, "getcomponenttypes", "Gets the components types that can be built.  Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
+
             CrestronConsole.AddNewConsoleCommand(BridgeHelper.PrintJoinMap, "getjoinmap", "map(s) for bridge or device on bridge [brKey [devKey]]", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
@@ -428,12 +431,21 @@ namespace PepperDash.Essentials
 
             foreach (var roomConfig in ConfigReader.ConfigObject.Rooms)
             {
-                var room = EssentialsRoomConfigHelper.GetRoomObject(roomConfig) as EssentialsRoomBase;
+                Device room = null;
-                if (room != null)
+
+                if (roomConfig.Type != "componentRoom")
+                {
+                    room = EssentialsRoomConfigHelper.GetRoomObject(roomConfig) as EssentialsRoomBase;
+                }
+                else
+                {
+                    room = new ComponentRoom(roomConfig);
+                }
+
+                if (room != null && room is EssentialsRoomBase)
                 {
                     if (room is EssentialsHuddleSpaceRoom)
                     {
-                        DeviceManager.AddDevice(room);
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleSpaceRoom, attempting to add to DeviceManager with Fusion");
                         DeviceManager.AddDevice(new Core.Fusion.EssentialsHuddleSpaceFusionSystemControllerBase((EssentialsHuddleSpaceRoom)room, 0xf1));
@@ -441,25 +453,26 @@ namespace PepperDash.Essentials
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Mobile Control Bridge...");
 
-                        CreateMobileControlBridge(room);
+                        CreateMobileControlBridge(room as EssentialsRoomBase);
                     }
                     else if (room is EssentialsHuddleVtc1Room)
                     {
-                        DeviceManager.AddDevice(room);
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion");
                         DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((EssentialsHuddleVtc1Room)room, 0xf1));
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Mobile Control Bridge...");
 
-                        CreateMobileControlBridge(room);
+                        CreateMobileControlBridge(room as EssentialsRoomBase);
                     }
                     else
                     {
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is NOT EssentialsRoom, attempting to add to DeviceManager w/o Fusion");
-                        DeviceManager.AddDevice(room);
                     }
-
+                }
+                else if (room != null)
+                {
+                    DeviceManager.AddDevice(room);
                 }
                 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);
@@ -558,7 +571,7 @@ namespace PepperDash.Essentials
             }
             catch (Exception e)
             {
-                Debug.Console(1, Debug.ErrorLogLevel.Notice, "Unable to find logo information in any room config");
+                Debug.Console(1, Debug.ErrorLogLevel.Notice, "Unable to find logo information in any room config: {0}", e);
                 return false;
             }
         }

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

@@ -1,113 +1,113 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
-using System.Text;
+using System.Text;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using Crestron.SimplSharp.Reflection;
-
+
-using PepperDash.Core;
+using PepperDash.Core;
-using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Config;
-
+
-namespace PepperDash.Essentials.Core
+namespace PepperDash.Essentials.Core
-{
+{
-    /// <summary>
+    /// <summary>
-    /// Defines the basic needs for an EssentialsDevice to enable it to be build by an IDeviceFactory class
+    /// Defines the basic needs for an EssentialsDevice to enable it to be build by an IDeviceFactory class
-    /// </summary>
+    /// </summary>
-    [Description("The base Essentials Device Class")]
+    [Description("The base Essentials Device Class")]
-    public abstract class EssentialsDevice : Device
+    public abstract class EssentialsDevice : Device
-    {
+    {
-        protected EssentialsDevice(string key)
+        protected EssentialsDevice(string key)
-            : base(key)
+            : base(key)
-        {
+        {
-
+
-        }
+        }
-
+
-        protected EssentialsDevice(string key, string name)
+        protected EssentialsDevice(string key, string name)
-            : base(key, name)
+            : base(key, name)
-        {
+        {
-
+
-        }
+        }
-    }
+    }
-
+
-    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
+    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
-    public class DescriptionAttribute : Attribute
+    public class DescriptionAttribute : Attribute
-    {
+    {
-        private string _Description;
+        private string _Description;
-
+
-        public DescriptionAttribute(string description)
+        public DescriptionAttribute(string description)
-        {
+        {
-            Debug.Console(2, "Setting Description: {0}", description);
+            Debug.Console(2, "Setting Description: {0}", description);
-            _Description = description;
+            _Description = description;
-        }
+        }
-
+
-        public string Description
+        public string Description
-        {
+        {
-            get { return _Description; }
+            get { return _Description; }
-        }
+        }
-    }
+    }
-
+
-    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
+    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
-    public class ConfigSnippetAttribute : Attribute
+    public class ConfigSnippetAttribute : Attribute
-    {
+    {
-        private string _ConfigSnippet;
+        private string _ConfigSnippet;
-
+
-        public ConfigSnippetAttribute(string configSnippet)
+        public ConfigSnippetAttribute(string configSnippet)
-        {
+        {
-            Debug.Console(2, "Setting Config Snippet {0}", configSnippet);
+            Debug.Console(2, "Setting Config Snippet {0}", configSnippet);
-            _ConfigSnippet = configSnippet;
+            _ConfigSnippet = configSnippet;
-        }
+        }
-
+
-        public string ConfigSnippet
+        public string ConfigSnippet
-        {
+        {
-            get { return _ConfigSnippet; }
+            get { return _ConfigSnippet; }
-        }
+        }
-    }
+    }
-
+
-    /// <summary>
+    /// <summary>
-    /// Devices the basic needs for a Device Factory
+    /// Devices the basic needs for a Device Factory
-    /// </summary>
+    /// </summary>
-    public abstract class EssentialsDeviceFactory<T> : IDeviceFactory where T:EssentialsDevice
+    public abstract class EssentialsDeviceFactory<T> : IDeviceFactory where T:EssentialsDevice
-    {
+    {
-        #region IDeviceFactory Members
+        #region IDeviceFactory Members
-
+
-        /// <summary>
+        /// <summary>
-        /// A list of strings that can be used in the type property of a DeviceConfig object to build an instance of this device
+        /// A list of strings that can be used in the type property of a DeviceConfig object to build an instance of this device
-        /// </summary>
+        /// </summary>
-        public List<string> TypeNames { get; protected set; }
+        public List<string> TypeNames { get; protected set; }
-
+
-        /// <summary>
+        /// <summary>
-        /// Loads an item to the DeviceFactory.FactoryMethods dictionary for each entry in the TypeNames list
+        /// Loads an item to the DeviceFactory.FactoryMethods dictionary for each entry in the TypeNames list
-        /// </summary>
+        /// </summary>
-        public void LoadTypeFactories()
+        public void LoadTypeFactories()
-        {
+        {
-            foreach (var typeName in TypeNames)
+            foreach (var typeName in TypeNames)
-            {
+            {
-                Debug.Console(2, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
+                Debug.Console(2, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
-                var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
+                var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
                 string description = descriptionAttribute[0].Description;
-                var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
+                var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
-                DeviceFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildDevice);
+                DeviceFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildDevice);
-            }
+            }
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// The method that will build the device
+        /// The method that will build the device
-        /// </summary>
+        /// </summary>
-        /// <param name="dc">The device config</param>
+        /// <param name="dc">The device config</param>
-        /// <returns>An instance of the device</returns>
+        /// <returns>An instance of the device</returns>
-        public abstract EssentialsDevice BuildDevice(DeviceConfig dc);
+        public abstract EssentialsDevice BuildDevice(DeviceConfig dc);
-
+
-        #endregion
+        #endregion
-    }
+    }
-
+
-    /// <summary>
+    /// <summary>
-    /// Devices the basic needs for a Device Factory
+    /// Devices the basic needs for a Device Factory
-    /// </summary>
+    /// </summary>
-    public abstract class EssentialsPluginDeviceFactory<T> : EssentialsDeviceFactory<T>, IPluginDeviceFactory where T : EssentialsDevice
+    public abstract class EssentialsPluginDeviceFactory<T> : EssentialsDeviceFactory<T>, IPluginDeviceFactory where T : EssentialsDevice
-    {
+    {
-        /// <summary>
+        /// <summary>
-        /// Specifies the minimum version of Essentials required for a plugin to run.  Must use the format Major.Minor.Build (ex. "1.4.33")
+        /// Specifies the minimum version of Essentials required for a plugin to run.  Must use the format Major.Minor.Build (ex. "1.4.33")
-        /// </summary>
+        /// </summary>
-        public string MinimumEssentialsFrameworkVersion { get; protected set; }
+        public string MinimumEssentialsFrameworkVersion { get; protected set; }
-    }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -277,9 +277,13 @@
     <Compile Include="Remotes\CrestronRemotePropertiesConfig.cs" />
     <Compile Include="Remotes\Hrxx0WirelessRemoteController.cs" />
     <Compile Include="Room\Behaviours\RoomOnToDefaultSourceWhenOccupied.cs" />
+    <Compile Include="Room\Components\ComponentFactory.cs" />
+    <Compile Include="Room\Components\ComponentRoom.cs" />
+    <Compile Include="Room\Components\RoomComponentBase.cs" />
     <Compile Include="Room\EssentialsRoomBase.cs" />
     <Compile Include="Room\Interfaces.cs" />
     <Compile Include="Room\iOccupancyStatusProvider.cs" />
+    <Compile Include="Room\RoomFactory.cs" />
     <Compile Include="Routing\DummyRoutingInputsDevice.cs" />
     <Compile Include="Routing\ICardPortsDevice.cs" />
     <Compile Include="InUseTracking\IInUseTracking.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Components/ComponentFactory.cs

@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.Reflection;
+
+using PepperDash.Core;
+
+
+using PepperDash.Essentials.Interfaces.Components;
+
+namespace PepperDash.Essentials.Core.Room.Components
+{
+    public class ComponentFactoryWrapper
+    {
+        public CType CType { get; set; }
+        public string Description { get; set; }
+        public Func<RoomComponentConfig, IKeyed> FactoryMethod { get; set; }
+
+        public ComponentFactoryWrapper()
+        {
+            CType = null;
+            Description = "Not Available";
+        }
+    }
+
+    /// <summary>
+    /// Defines a class that is capable of loading component types
+    /// </summary>
+    public interface IComponentFactory : IDeviceFactory
+    {
+
+    }
+
+    public static class ComponentFactory
+    {
+        static ComponentFactory()
+        {
+            var assy = Assembly.GetExecutingAssembly();
+            PluginLoader.SetEssentialsAssembly(assy.GetName().Name, assy);
+
+            var types = assy.GetTypes().Where(ct => typeof(IComponentFactory).IsAssignableFrom(ct) && !ct.IsInterface && !ct.IsAbstract);
+
+            if (types != null)
+            {
+                foreach (var type in types)
+                {
+                    try
+                    {
+                        var factory = (IComponentFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                        factory.LoadTypeFactories();
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.Console(0, Debug.ErrorLogLevel.Error, "Unable to load type: '{1}' ComponentFactory: {0}", e, type.Name);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// A dictionary of factory methods, keyed by config types, added by plugins.
+        /// These methods are looked up and called by GetDevice in this class.
+        /// </summary>
+        static Dictionary<string, ComponentFactoryWrapper> FactoryMethods =
+            new Dictionary<string, ComponentFactoryWrapper>(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Adds a plugin factory method
+        /// </summary>
+        /// <param name="dc"></param>
+        /// <returns></returns>
+        public static void AddFactoryForType(string typeName, Func<RoomComponentConfig, IKeyed> method)
+        {
+            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Adding factory method for type '{0}'", typeName);
+            ComponentFactory.FactoryMethods.Add(typeName, new ComponentFactoryWrapper() { FactoryMethod = method });
+        }
+
+        public static void AddFactoryForType(string typeName, string description, CType cType, Func<RoomComponentConfig, IKeyed> method)
+        {
+            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Adding factory method for type '{0}'", typeName);
+
+            if (FactoryMethods.ContainsKey(typeName))
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Error, "Unable to add type: '{0}'.  Already exists in ComponentFactory", typeName);
+                return;
+            }
+
+            var wrapper = new ComponentFactoryWrapper() { CType = cType, Description = description, FactoryMethod = method };
+            ComponentFactory.FactoryMethods.Add(typeName, wrapper);
+        }
+
+        /// <summary>
+        /// The factory method for Core components. Also iterates the Factory methods that have
+        /// been loaded from plugins
+        /// </summary>
+        /// <param name="dc"></param>
+        /// <returns></returns>
+        public static IKeyed GetComponent(RoomComponentConfig dc)
+        {
+            var key = dc.Key;
+            var name = dc.Name;
+            var type = dc.Type;
+            var properties = dc.Properties;
+
+            var typeName = dc.Type.ToLower();
+
+            // Check for types that have been added by plugin dlls. 
+            if (FactoryMethods.ContainsKey(typeName))
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Loading '{0}' from Essentials Core", dc.Type);
+                return FactoryMethods[typeName].FactoryMethod(dc);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Prints the type names and associated metadata from the FactoryMethods collection.
+        /// </summary>
+        /// <param name="command"></param>
+        public static void GetComponentFactoryTypes(string filter)
+        {
+            Dictionary<string, ComponentFactoryWrapper> types = new Dictionary<string, ComponentFactoryWrapper>();
+
+            if (!string.IsNullOrEmpty(filter))
+            {
+                types = FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value);
+            }
+            else
+            {
+                types = FactoryMethods;
+            }
+
+            Debug.Console(0, "Component Types:");
+
+            foreach (var type in types.OrderBy(t => t.Key))
+            {
+                var description = type.Value.Description;
+                var cType = "Not Specified by Plugin";
+
+                if (type.Value.CType != null)
+                {
+                    cType = type.Value.CType.FullName;
+                }
+
+                Debug.Console(0,
+                    @"Type: '{0}' 
+                    CType: '{1}' 
+                    Description: {2}", type.Key, cType, description);
+            }
+        }
+
+    }
+
+
+    /// <summary>
+    /// Devices the basic needs for a Device Factory
+    /// </summary>
+    public abstract class EssentialsComponentFactory<T> : IComponentFactory where T : IComponent
+    {
+        #region IComponentFactory Members
+
+        /// <summary>
+        /// A list of strings that can be used in the type property of a DeviceConfig object to build an instance of this device
+        /// </summary>
+        public List<string> TypeNames { get; protected set; }
+
+        /// <summary>
+        /// Loads an item to the ComponentFactory.FactoryMethods dictionary for each entry in the TypeNames list
+        /// </summary>
+        public void LoadTypeFactories()
+        {
+            foreach (var typeName in TypeNames)
+            {
+                Debug.Console(2, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
+                var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
+                string description = descriptionAttribute[0].Description;
+                var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
+                ComponentFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildComponent);
+            }
+        }
+
+        /// <summary>
+        /// The method that will build the device
+        /// </summary>
+        /// <param name="dc">The device config</param>
+        /// <returns>An instance of the device</returns>
+        public abstract IComponent BuildComponent(RoomComponentConfig dc);
+
+        #endregion
+    }
+}
+

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Components/ComponentRoom.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Interfaces.Components;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Devices;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.Room
+{
+    /// <summary>
+    /// The base config class for various component types
+    /// </summary>
+    public abstract class RoomComponentConfig : DeviceConfig
+    {
+
+    }
+
+    /// <summary>
+    /// The config class for an activiry
+    /// </summary>
+    public class RoomActivityConfig : RoomComponentConfig
+    {
+        [JsonProperty("label")]
+        public string Label { get; set; }
+        [JsonProperty("icon")]
+        public string Icon { get; set; }
+        [JsonProperty("componentKey")]
+        public string ComponentKey { get; set; }
+        [JsonProperty("order")]
+        public int Order { get; set; }
+    }
+
+    /// <summary>
+    /// The config class for a room behaviour
+    /// </summary>
+    public class RoomBehaviourConfig : RoomComponentConfig
+    {
+
+    }
+
+    /// <summary>
+    /// The config class for a device behavior
+    /// </summary>
+    public class RoomDeviceBehaviourConfig : RoomComponentConfig
+    {
+
+    }
+
+    /// <summary>
+    /// The config class for a ComponentRoom
+    /// </summary>
+    public class ComponentRoomPropertiesConfig
+    {
+        [JsonProperty("activities")]
+        public List<RoomActivityConfig> Activities { get; set; }
+        [JsonProperty("components")]
+        public List<RoomComponentConfig> Components { get; set; }
+
+    }
+
+
+    /// <summary>
+    /// A room comprised of component parts built at runtime.  
+    /// </summary>
+    public class ComponentRoom : ReconfigurableDevice, IComponentRoom
+    {
+        public ComponentRoomPropertiesConfig PropertiesConfig { get; private set; }
+
+        public List<IRoomComponent> Components { get; private set; }
+        public List<IRoomActivityComponent> Activities { get; private set; }
+
+        public ComponentRoom(DeviceConfig config)
+            : base(config)
+        {
+            try
+            {
+                PropertiesConfig = JsonConvert.DeserializeObject<ComponentRoomPropertiesConfig>
+                    (config.Properties.ToString());
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Error building ComponentRoom: \n{0}", e);
+            }
+
+        }
+
+        public List<IRoomComponent> GetRoomComponentsOfType(Type componentType)
+        {
+            // TODO: Figure this out later
+            return Components;
+            //var results = Components.OfType<componentType>();
+            //return results;
+            //return Components.Where(c => c != null && type.IsAssignableFrom(c.GetType()));
+        }
+
+        /// <summary>
+        /// Returns a list of the activies sorted by order
+        /// </summary>
+        /// <returns></returns>
+        public List<IRoomActivityComponent> GetOrderedActvities()
+        {
+            return Activities.OrderBy(a => a.Order).ToList<IRoomActivityComponent>();
+        }
+
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Components/RoomComponentBase.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Interfaces.Components;
+
+namespace PepperDash.Essentials.Core.Room.Components
+{
+    /// <summary>
+    /// The base class from which Room Components should be derived
+    /// </summary>
+    public abstract class RoomComponentBase : IRoomComponent
+    {
+        private string _componentKey;
+
+        /// <summary>
+        /// The key of the component, which is composed of the parent room key, plus the specific component key
+        /// </summary>
+        public string Key {
+            get
+            {
+                return Parent.Key + "-" + _componentKey;
+            }
+        }
+
+        public IComponentRoom Parent { get; private set; }
+
+        public RoomComponentBase(string key, IComponentRoom parent)
+        {
+            _componentKey = key;
+            Parent = parent;
+        }
+
+    }
+}

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

@@ -12,45 +12,45 @@ namespace PepperDash.Essentials.Core
 {
 	//***************************************************************************************************
 
-	public abstract class Room : Device, IHasFeedback
+//    public abstract class Room : Device, IHasFeedback
-	{
+//    {
-		public abstract BoolFeedback RoomIsOnFeedback { get; protected set; }
+//        public abstract BoolFeedback RoomIsOnFeedback { get; protected set; }
-		public abstract BoolFeedback IsCoolingDownFeedback { get; protected set; }
+//        public abstract BoolFeedback IsCoolingDownFeedback { get; protected set; }
-		public abstract BoolFeedback IsWarmingUpFeedback { get; protected set; }
+//        public abstract BoolFeedback IsWarmingUpFeedback { get; protected set; }
 
-		// In concrete classes, these should be computed from the relevant devices
+//        // In concrete classes, these should be computed from the relevant devices
-		public virtual uint CooldownTime { get { return 10000; } }
+//        public virtual uint CooldownTime { get { return 10000; } }
-		public virtual uint WarmupTime { get { return 5000; } }
+//        public virtual uint WarmupTime { get { return 5000; } }
 
-		public string Description { get; set; }
+//        public string Description { get; set; }
-		public string HelpMessage { get; set; }
+//        public string HelpMessage { get; set; }
 
-		public Room(string key, string name)
+//        public Room(string key, string name)
-			: base(key, name)
+//            : base(key, name)
-		{
+//        {
-			Description = "";
+//            Description = "";
-			HelpMessage = "";
+//            HelpMessage = "";
-		}
+//        }
 
-		public virtual void RoomOn() { }
+//        public virtual void RoomOn() { }
 
-		public virtual void RoomOff() { }
+//        public virtual void RoomOff() { }
 
-		#region IDeviceWithOutputs Members
+//        #region IDeviceWithOutputs Members
 
-		public virtual FeedbackCollection<Feedback> Feedbacks
+//        public virtual FeedbackCollection<Feedback> Feedbacks
-		{
+//        {
-			get
+//            get
-			{
+//            {
-                return new FeedbackCollection<Feedback>
+//                return new FeedbackCollection<Feedback>
-                {
+//                {
-                    RoomIsOnFeedback,
+//                    RoomIsOnFeedback,
-                    IsCoolingDownFeedback,
+//                    IsCoolingDownFeedback,
-                    IsWarmingUpFeedback
+//                    IsWarmingUpFeedback
-                };
+//                };
-			}
+//            }
-		}
+//        }
 
-		#endregion
+//        #endregion
-	}
+//    }
 }

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

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Interfaces.Components;
+
+namespace PepperDash.Essentials.Core.Room
+{
+    /// <summary>
+    /// The class that constructs rooms
+    /// </summary>
+    public static class RoomFactory
+    {
+        
+
+    }
+}

essentials-framework/Essentials Interfaces/PepperDash_Essentials_Interfaces/Components/RoomComponents.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Interfaces.Components
+{
+    /// <summary>
+    /// Describes a room comprised of components
+    /// </summary>
+    public interface IComponentRoom : IKeyed
+    {
+        List<IRoomComponent> Components { get; }
+        List<IRoomActivityComponent> Activities { get; }
+
+        List<IRoomComponent> GetRoomComponentsOfType(Type type);
+        List<IRoomActivityComponent> GetOrderedActvities();
+    }
+
+    /// <summary>
+    /// Describes a component
+    /// </summary>
+    public interface IComponent : IKeyed
+    {
+
+    }
+
+    /// <summary>
+    /// Describes a room component
+    /// </summary>
+    public interface IRoomComponent : IComponent
+    {
+        IComponentRoom Parent { get; }
+    }
+
+    /// <summary>
+    /// Describes a room activity component
+    /// </summary>
+    public interface IRoomActivityComponent : IRoomComponent
+    {
+        string Label { get; }
+        string Icon { get;  }
+        IRoomComponent Component { get; }
+        int Order { get; }
+
+        void StartActivity();
+        void EndActivity();
+    }
+
+    /// <summary>
+    /// Describes a room component that can be "used" by a user
+    /// </summary>
+    public interface IUsableRoomComponent
+    {
+        bool InUse { get; }
+
+        void StartUse();
+        void EndUse();
+    }
+
+    /// <summary>
+    /// Describes a room behaviour component
+    /// </summary>
+    public interface IRoomBehaviourComponent : IUsableRoomComponent
+    {
+
+    }
+
+    /// <summary>
+    /// Describes a room device component
+    /// </summary>
+    public interface IRoomDeviceComponent : IUsableRoomComponent
+    {
+
+    }
+}

essentials-framework/Essentials Interfaces/PepperDash_Essentials_Interfaces/PepperDash_Essentials_Interfaces.csproj

@@ -47,6 +47,10 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="mscorlib" />
+    <Reference Include="PepperDash_Core, Version=1.0.43.36276, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\packages\PepperDashCore\lib\net35\PepperDash_Core.dll</HintPath>
+    </Reference>
     <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
@@ -60,6 +64,7 @@
     <Reference Include="System.Data" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Components\RoomComponents.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <None Include="Properties\ControlSystem.cfg" />
   </ItemGroup>