Build after merge

Conflicts:
	Essentials Devices Common/Essentials Devices Common/Display/SamsungMDCDisplay.cs
	Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj
	Release Package/PepperDashEssentials.cpz
	Release Package/PepperDashEssentials.dll

Essentials Core/PepperDashEssentialsBase/Crestron IO/IOPortConfig.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class IOPortConfig
+    {
+        public string PortDeviceKey { get; set; }
+        public uint PortNumber { get; set; }
+    }
+
+}

Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/GenericDigitalInputDevice.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class GenericDigitalInputDevice : Device, IDigitalInput
+    {
+        public DigitalInput InputPort { get; private set; }
+
+        public BoolFeedback InputStateFeedback { get; private set; }
+
+        Func<bool> InputStateFeedbackFunc
+        {
+            get
+            {
+                return () => InputPort.State;
+            }
+        }
+
+        public GenericDigitalInputDevice(string key, DigitalInput inputPort):
+            base(key)
+        {
+            InputStateFeedback = new BoolFeedback(InputStateFeedbackFunc);
+
+            InputPort = inputPort;
+
+            InputPort.StateChange += new DigitalInputEventHandler(InputPort_StateChange);
+
+        }
+
+        void InputPort_StateChange(DigitalInput digitalInput, DigitalInputEventArgs args)
+        {
+            InputStateFeedback.FireUpdate();
+        }
+
+    }
+}

Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/GenericVersiportInputDevice.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic digital input deviced tied to a versiport
+    /// </summary>
+    public class GenericVersiportInputDevice : Device, IDigitalInput
+    {
+        public Versiport InputPort { get; private set; }
+
+        public BoolFeedback InputStateFeedback { get; private set; }
+
+        Func<bool> InputStateFeedbackFunc
+        {
+            get
+            {
+                return () => InputPort.DigitalIn;
+            }
+        }
+
+        public GenericVersiportInputDevice(string key, Versiport inputPort):
+            base(key)
+        {
+            InputStateFeedback = new BoolFeedback(InputStateFeedbackFunc);
+
+            InputPort = inputPort;
+
+            InputPort.SetVersiportConfiguration(eVersiportConfiguration.DigitalInput);
+
+            InputPort.VersiportChange += new VersiportEventHandler(InputPort_VersiportChange);
+
+        }
+
+        void InputPort_VersiportChange(Versiport port, VersiportEventArgs args)
+        {
+            InputStateFeedback.FireUpdate();
+        }
+    }
+
+    public class GenericVersiportInputDeviceConfigProperties
+    {
+
+    }
+
+}

Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/IDigitalInput.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a device that provides digital input
+    /// </summary>
+    public interface IDigitalInput
+    {
+        BoolFeedback InputStateFeedback { get; }
+    }
+}

Essentials Core/PepperDashEssentialsBase/Crestron IO/Relay/GenericRelayDevice.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic device controlled by relays
+    /// </summary>
+    public class GenericRelayDevice : Device
+    {
+        public Relay RelayOutput { get; private set; }
+
+        public BoolFeedback RelayStateFeedback { get; private set; }
+
+        Func<bool> RelayStateFeedbackFunc
+        {
+            get
+            {
+                return () => RelayOutput.State;
+            }
+        }
+
+        public GenericRelayDevice(string key, Relay relay):
+            base(key)
+        {
+            RelayStateFeedback = new BoolFeedback(RelayStateFeedbackFunc);
+
+            if (relay.AvailableForUse)
+                RelayOutput = relay;
+
+            RelayOutput.StateChange += new RelayEventHandler(RelayOutput_StateChange);
+        }
+
+        void RelayOutput_StateChange(Relay relay, RelayEventArgs args)
+        {
+            RelayStateFeedback.FireUpdate();
+        }
+
+        public void OpenRelay()
+        {
+            RelayOutput.State = false;
+        }
+
+        public void CloseRelay()
+        {
+            RelayOutput.State = true;
+        }
+
+        public void ToggleRelayState()
+        {
+            if (RelayOutput.State == true)
+                OpenRelay();
+            else
+                CloseRelay();
+        }
+    }
+}

Essentials Core/PepperDashEssentialsBase/Global/JobTimer.cs

@@ -72,6 +72,7 @@ namespace PepperDash.Essentials.Core
 
 	public enum eJobTimerCycleTypes
 	{
+        RunEveryDay,
 		RunEveryHour,
 		RunEveryHalfHour,
 		RunEveryMinute

Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -24,7 +24,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\</OutputPath>
+    <OutputPath>..\..\Release Package\</OutputPath>
     <DefineConstants>DEBUG;TRACE;</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -71,7 +71,7 @@
       <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.0.16459, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.1.26313, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\pepperdash-simplsharp-core\Pepperdash Core\CLZ Builds\PepperDash_Core.dll</HintPath>
     </Reference>
@@ -103,6 +103,11 @@
     <Reference Include="System.Data" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Crestron IO\Inputs\GenericDigitalInputDevice.cs" />
+    <Compile Include="Crestron IO\Inputs\GenericVersiportInputDevice.cs" />
+    <Compile Include="Crestron IO\Inputs\IDigitalInput.cs" />
+    <Compile Include="Crestron IO\IOPortConfig.cs" />
+    <Compile Include="Crestron IO\Relay\GenericRelayDevice.cs" />
     <Compile Include="Devices\CodecInterfaces.cs" />
     <Compile Include="Global\JobTimer.cs" />
     <Compile Include="Ramps and Increments\ActionIncrementer.cs" />

Essentials Core/PepperDashEssentialsBase/Properties/AssemblyInfo.cs

@@ -4,5 +4,4 @@
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("PepperDashEssentialsBase")]
 [assembly: AssemblyCopyright("Copyright ©  2015")]
-[assembly: AssemblyVersion("1.0.0.*")]
-
+[assembly: AssemblyVersion("1.0.3.*")]

Essentials Core/PepperDashEssentialsBase/Routing/RoutingPortNames.cs

@@ -108,10 +108,18 @@ namespace PepperDash.Essentials.Core.Routing
         /// </summary>
 		public const string HdmiIn1 = "hdmiIn1";
         /// <summary>
+        /// hdmiIn1PC
+        /// </summary>
+        public const string HdmiIn1PC = "hdmiIn1PC";
+        /// <summary>
         /// hdmiIn2
         /// </summary>
 		public const string HdmiIn2 = "hdmiIn2";
         /// <summary>
+        /// hdmiIn2PC
+        /// </summary>
+        public const string HdmiIn2PC = "hdmiIn2PC";
+        /// <summary>
         /// hdmiIn3
         /// </summary>
 		public const string HdmiIn3 = "hdmiIn3";
@@ -176,8 +184,20 @@ namespace PepperDash.Essentials.Core.Routing
         /// </summary>
 		public const string VgaIn = "vgaIn";
         /// <summary>
+        /// vgaIn1
+        /// </summary>
+        public const string VgaIn1 = "vgaIn1";
+        /// <summary>
         /// vgaOut
         /// </summary>
 		public const string VgaOut = "vgaOut";
+        /// <summary>
+        /// IPC/OPS
+        /// </summary>
+        public const string IpcOps = "ipcOps";
+        /// <summary>
+        /// MediaPlayer
+        /// </summary>
+        public const string MediaPlayer = "mediaPlayer";
 	}
 }

Essentials Core/PepperDashEssentialsBase/SmartObjects/SubpageReferencList/SubpageReferenceList.cs

@@ -68,7 +68,7 @@ namespace PepperDash.Essentials.Core
 				// Count the enable lines to see what max items is
 				MaxDefinedItems = (ushort)SRL.BooleanInput
 					.Where(s => s.Name.Contains("Enable")).Count();
-				Debug.Console(0, "SRL {0} contains max {1} items", SRL.ID, MaxDefinedItems);
+				Debug.Console(2, "SRL {0} contains max {1} items", SRL.ID, MaxDefinedItems);
 
 				SRL.SigChange -= new SmartObjectSigChangeEventHandler(SRL_SigChange);
 				SRL.SigChange += new SmartObjectSigChangeEventHandler(SRL_SigChange);

Essentials DM/Essentials_DM/Essentials_DM.csproj

@@ -55,14 +55,10 @@
       <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DM.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.0.15153, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.1.20241, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\pepperdash-simplsharp-core\Pepperdash Core\CLZ Builds\PepperDash_Core.dll</HintPath>
     </Reference>
-    <Reference Include="PepperDash_Essentials_Core, Version=1.0.0.24289, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\Essentials Core\PepperDashEssentialsBase\bin\PepperDash_Essentials_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>
@@ -115,6 +111,12 @@
     <Compile Include="VideoStatusHelpers.cs" />
     <None Include="Properties\ControlSystem.cfg" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj">
+      <Project>{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}</Project>
+      <Name>PepperDash_Essentials_Core</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>

Essentials DM/Essentials_DM/Properties/AssemblyInfo.cs

@@ -4,5 +4,4 @@
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Essentials_DM")]
 [assembly: AssemblyCopyright("Copyright ©  2016")]
-[assembly: AssemblyVersion("1.0.0.*")]
-
+[assembly: AssemblyVersion("1.0.3.*")]

Essentials Devices Common/Essentials Devices Common/Codec/CodecActiveCallItem.cs

@@ -38,4 +38,17 @@ namespace PepperDash.Essentials.Devices.Common.Codec
             }
         }
     }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CodecCallStatusItemChangeEventArgs : EventArgs
+    {
+        public CodecActiveCallItem CallItem { get; private set; }
+
+        public CodecCallStatusItemChangeEventArgs(CodecActiveCallItem item)
+        {
+            CallItem = item;
+        }
+    }
 }

Essentials Devices Common/Essentials Devices Common/Codec/iCodecInfo.cs

@@ -21,7 +21,9 @@ namespace PepperDash.Essentials.Devices.Common.Codec
     {
         public abstract bool MultiSiteOptionIsEnabled { get; }
         public abstract string IpAddress { get; }
-        public abstract string PhoneNumber { get; }
+        public abstract string SipPhoneNumber { get; }
+        public abstract string E164Alias { get; }
+        public abstract string H323Id { get; }
         public abstract string SipUri { get; }
         public abstract bool AutoAnswerEnabled { get; }
     }

Essentials Devices Common/Essentials Devices Common/Codec/iHasDialer.cs

@@ -24,27 +24,7 @@ namespace PepperDash.Essentials.Devices.Common.Codec
         void RejectCall(CodecActiveCallItem item);
         void SendDtmf(string digit);
 
-        //BoolFeedback IncomingCallFeedback { get; }
+        bool IsInCall { get; }
     }
 
-
-    /// <summary>
-    /// 
-    /// </summary>
-    public class CodecCallStatusItemChangeEventArgs : EventArgs
-    {
-        public CodecActiveCallItem CallItem { get; private set; }
-
-        //public eCodecCallStatus PreviousStatus { get; private set; }
-
-        //public eCodecCallStatus NewStatus { get; private set; }
-
-        public CodecCallStatusItemChangeEventArgs(/*eCodecCallStatus previousStatus,
-             eCodecCallStatus newStatus,*/ CodecActiveCallItem item)
-        {
-            //PreviousStatus = previousStatus;
-            //NewStatus = newStatus;
-            CallItem = item;
-        }
-    }
 }

Essentials Devices Common/Essentials Devices Common/Codec/iHasScheduleAwareness.cs

@@ -30,6 +30,9 @@ namespace PepperDash.Essentials.Devices.Common.Codec
 
         public event EventHandler<EventArgs> MeetingsListHasChanged;
 
+		/// <summary>
+		/// Setter triggers MeetingsListHasChanged event
+		/// </summary>
         public List<Meeting> Meetings
         {
             get
@@ -131,7 +134,7 @@ namespace PepperDash.Essentials.Devices.Common.Codec
             get
             {
                 return StartTime.AddMinutes(-5) <= DateTime.Now
-                    && DateTime.Now <= EndTime.AddMinutes(-5);
+                    && DateTime.Now <= EndTime; //.AddMinutes(-5);
             }
         }
         //public string ConferenceNumberToDial { get; set; }

Essentials Devices Common/Essentials Devices Common/Display/AvocorVTFDisplay.cs

@@ -0,0 +1,720 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.CrestronThread;
+using Crestron.SimplSharpPro;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+
+namespace PepperDash.Essentials.Devices.Displays
+{
+	/// <summary>
+	/// 
+	/// </summary>
+    public class AvocorDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, ICommunicationMonitor, IInputDisplayPort1,
+        IInputHdmi1, IInputHdmi2, IInputHdmi3, IInputHdmi4, IInputVga1
+	{
+        public IBasicCommunication Communication { get; private set; }
+        public CommunicationGather PortGather { get; private set; }
+		
+        public StatusMonitorBase CommunicationMonitor { get; private set; }
+
+        public byte ID { get; private set; }
+
+        /// <summary>
+        /// 0x08
+        /// </summary>
+        const byte InputVga1Value = 0x00;
+        /// <summary>
+        /// 0x09
+        /// </summary>
+        const byte InputHdmi1Value = 0x09;
+        /// <summary>
+        /// 0x0a
+        /// </summary>
+        const byte InputHdmi2Value = 0x0a;
+        /// <summary>
+        /// 0x0b
+        /// </summary>
+        const byte InputHdmi3Value = 0x0b;
+        /// <summary>
+        /// 0x0c
+        /// </summary>
+        const byte InputHdmi4Value = 0x0c;
+        /// <summary>
+        /// 0c0d
+        /// </summary>
+        const byte InputDisplayPort1Value = 0x0d;
+        /// <summary>
+        /// 0x0e
+        /// </summary>
+        const byte InputIpcOpsValue = 0x0e;
+        /// <summary>
+        /// 0x11
+        /// </summary>
+        const byte InputHdmi5Value = 0x11;
+        /// <summary>
+        /// 0x12
+        /// </summary>
+        const byte InputMediaPlayerValue = 0x12;
+
+
+		bool _PowerIsOn;
+		bool _IsWarmingUp;
+		bool _IsCoolingDown;
+		ushort _VolumeLevelForSig;
+        int _LastVolumeSent;
+        ushort _PreMuteVolumeLevel;
+		bool _IsMuted;
+        RoutingInputPort _CurrentInputPort;
+        ActionIncrementer VolumeIncrementer;
+        bool VolumeIsRamping;
+        public bool IsInStandby { get; private set; }
+
+		protected override Func<bool> PowerIsOnFeedbackFunc { get { return () => _PowerIsOn; } }
+		protected override Func<bool> IsCoolingDownFeedbackFunc { get { return () => _IsCoolingDown; } }
+		protected override Func<bool> IsWarmingUpFeedbackFunc { get { return () => _IsWarmingUp; } }
+        protected override Func<string> CurrentInputFeedbackFunc { get { return () => _CurrentInputPort.Key; } }    
+
+		/// <summary>
+		/// Constructor for IBasicCommunication
+		/// </summary>
+		public AvocorDisplay(string key, string name, IBasicCommunication comm, string id)
+			: base(key, name)
+		{
+			Communication = comm;
+            //Communication.BytesReceived += new EventHandler<GenericCommMethodReceiveBytesArgs>(Communication_BytesReceived);
+
+            PortGather = new CommunicationGather(Communication, '\x08');
+            PortGather.IncludeDelimiter = true;
+            PortGather.LineReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(PortGather_LineReceived);
+
+            ID = id == null ? (byte)0x01 : Convert.ToByte(id, 16); // If id is null, set default value of 0x01, otherwise assign value passed in constructor
+            Init();
+		}
+
+		/// <summary>
+		/// Constructor for TCP
+		/// </summary>
+		public AvocorDisplay(string key, string name, string hostname, int port, string id)
+			: base(key, name)
+		{
+			Communication = new GenericTcpIpClient(key + "-tcp", hostname, port, 5000);
+
+            PortGather = new CommunicationGather(Communication, '\x0d');
+            PortGather.IncludeDelimiter = true;
+            PortGather.LineReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(PortGather_LineReceived);
+
+            ID = id == null ? (byte)0x01 : Convert.ToByte(id, 16); // If id is null, set default value of 0x01, otherwise assign value passed in constructor
+            Init();
+		}
+
+		/// <summary>
+		/// Constructor for COM
+		/// </summary>
+		public AvocorDisplay(string key, string name, ComPort port, ComPort.ComPortSpec spec, string id)
+			: base(key, name)
+		{
+			Communication = new ComPortController(key + "-com", port, spec);
+
+            PortGather = new CommunicationGather(Communication, '\x0d');
+            PortGather.IncludeDelimiter = true;
+            PortGather.LineReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(PortGather_LineReceived);
+
+            ID = id == null ? (byte)0x01 : Convert.ToByte(id, 16); // If id is null, set default value of 0x01, otherwise assign value passed in constructor
+            Init();
+		}
+
+        void AddRoutingInputPort(RoutingInputPort port, byte fbMatch)
+        {
+            port.FeedbackMatchObject = fbMatch;
+            InputPorts.Add(port);
+        }
+
+		void Init()
+		{
+            WarmupTime = 10000;
+			CooldownTime = 8000;
+
+            CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000, StatusGet);
+            DeviceManager.AddDevice(CommunicationMonitor);
+
+            VolumeIncrementer = new ActionIncrementer(655, 0, 65535, 800, 80, 
+                v => SetVolume((ushort)v), 
+                () => _LastVolumeSent);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this), InputHdmi1Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this), InputHdmi2Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this), InputHdmi3Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi4), this), InputHdmi4Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn5, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi5), this), InputHdmi5Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort1), this), InputDisplayPort1Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Dvi, new Action(InputVga1), this), InputVga1Value);
+
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.IpcOps, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Composite, new Action(InputIpcOps), this), InputIpcOpsValue);
+
+			AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.MediaPlayer, eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Vga, new Action(InputMediaPlayer), this), InputMediaPlayerValue);
+
+			VolumeLevelFeedback = new IntFeedback(() => { return _VolumeLevelForSig; });
+			MuteFeedback = new BoolFeedback(() => _IsMuted);
+		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+		public override bool CustomActivate()
+		{
+			Communication.Connect();
+
+            var socket = Communication as ISocketStatus;
+            if (socket != null)
+            {
+                socket.ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(socket_ConnectionChange);
+            }
+
+			CommunicationMonitor.StatusChange += (o, a) => { Debug.Console(2, this, "Communication monitor state: {0}", CommunicationMonitor.Status); };
+			CommunicationMonitor.Start();
+
+            StatusGet();
+
+			return true;
+		}
+
+        void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
+        {
+            if (e.Client.IsConnected)
+                StatusGet();
+        }
+
+		public override List<Feedback> Feedbacks
+		{
+			get
+			{
+				var list = base.Feedbacks;
+				list.AddRange(new List<Feedback>
+				{
+                    VolumeLevelFeedback,
+                    MuteFeedback,
+                    CurrentInputFeedback
+				});
+				return list;
+			}
+		}
+
+        ///// <summary>
+        ///// /
+        ///// </summary>
+        ///// <param name="sender"></param>
+        //void Communication_BytesReceived(object sender, GenericCommMethodReceiveBytesArgs e)
+        //{
+        //    // This is probably not thread-safe buffering
+        //    // Append the incoming bytes with whatever is in the buffer
+        //    var newBytes = new byte[IncomingBuffer.Length + e.Bytes.Length];
+        //    IncomingBuffer.CopyTo(newBytes, 0);
+        //    e.Bytes.CopyTo(newBytes, IncomingBuffer.Length);
+
+        //    if (Debug.Level == 2) // This check is here to prevent following string format from building unnecessarily on level 0 or 1
+        //        Debug.Console(2, this, "Received:{0}", ComTextHelper.GetEscapedText(newBytes));
+
+        //    // Need to find AA FF and have 
+        //    for (int i = 0; i < newBytes.Length; i++)
+        //    {
+        //        if (newBytes[i] == 0xAA && newBytes[i + 1] == 0xFF)
+        //        {
+        //            newBytes = newBytes.Skip(i).ToArray(); // Trim off junk if there's "dirt" in the buffer
+
+        //            // parse it
+        //            // If it's at least got the header, then process it, 
+        //            while (newBytes.Length > 4 && newBytes[0] == 0xAA && newBytes[1] == 0xFF)
+        //            {
+        //                var msgLen = newBytes[3];
+        //                // if the buffer is shorter than the header (3) + message (msgLen) + checksum (1),
+        //                // give and save it for next time 
+        //                if (newBytes.Length < msgLen + 4)
+        //                    break;
+
+        //                // Good length, grab the message
+        //                var message = newBytes.Skip(4).Take(msgLen).ToArray();
+
+        //                // At this point, the ack/nak is the first byte
+        //                if (message[0] == 0x41)
+        //                {
+        //                    switch (message[1]) // type byte
+        //                    {
+        //                        case 0x00: // General status
+        //                            UpdatePowerFB(message[2], message[5]); // "power" can be misrepresented when the display sleeps
+        //                            UpdateInputFb(message[5]);
+        //                            UpdateVolumeFB(message[3]);
+        //                            UpdateMuteFb(message[4]);
+        //                            UpdateInputFb(message[5]);
+        //                            break;
+
+        //                        case 0x11:
+        //                            UpdatePowerFB(message[2]);
+        //                            break;
+
+        //                        case 0x12:
+        //                            UpdateVolumeFB(message[2]);
+        //                            break;
+
+        //                        case 0x13:
+        //                            UpdateMuteFb(message[2]);
+        //                            break;
+
+        //                        case 0x14:
+        //                            UpdateInputFb(message[2]);
+        //                            break;
+
+        //                        default:
+        //                            break;
+        //                    }
+        //                }
+        //                // Skip over what we've used and save the rest for next time
+        //                newBytes = newBytes.Skip(5 + msgLen).ToArray();
+        //            }
+       
+        //            break; // parsing will mean we can stop looking for header in loop
+        //        }
+        //    }
+
+        //    // Save whatever partial message is here
+        //    IncomingBuffer = newBytes;
+        //}
+
+        void PortGather_LineReceived(object sender, GenericCommMethodReceiveTextArgs e)
+        {
+            Debug.Console(1, this, "Receivied: '{0}'", ComTextHelper.GetEscapedText(e.Text));
+
+            if (e.Text.IndexOf("\x50\x4F\x57") > -1)
+            {
+                // Power Status Response
+
+                var value = e.Text.ToCharArray();
+
+                switch (value[6])
+                {
+                    case '\x00':
+                        {
+                            _PowerIsOn = false;
+                            break;
+                        }
+                    case '\x01':
+                        {
+                            _PowerIsOn = true;
+                            break;
+                        }
+                }
+
+                PowerIsOnFeedback.FireUpdate();
+                Debug.Console(1, this, "PowerIsOn State: {0}", PowerIsOnFeedback.BoolValue);
+
+            }
+            else if (e.Text.IndexOf("\x4D\x49\x4E") > -1)
+            {
+                var value = e.Text.ToCharArray();
+
+                var b = value[6];
+
+                var newInput = InputPorts.FirstOrDefault(i => i.FeedbackMatchObject.Equals(b));
+                if (newInput != null && newInput != _CurrentInputPort)
+                {
+                    _CurrentInputPort = newInput;
+                    CurrentInputFeedback.FireUpdate();
+                    Debug.Console(1, this, "Current Input: {0}", CurrentInputFeedback.StringValue);
+                }
+                
+            }
+            else if (e.Text.IndexOf("\x56\x4F\x4C") > -1)
+            {
+                // Volume Status Response
+
+                var value = e.Text.ToCharArray();
+
+                var b = value[6];
+
+                var newVol = (ushort)NumericalHelpers.Scale((double)b, 0, 100, 0, 65535);
+                if (!VolumeIsRamping)
+                    _LastVolumeSent = newVol;
+                if (newVol != _VolumeLevelForSig)
+                {
+                    _VolumeLevelForSig = newVol;
+                    VolumeLevelFeedback.FireUpdate();
+
+                    if (_VolumeLevelForSig > 0)
+                        _IsMuted = false;
+                    else
+                        _IsMuted = true;
+
+                    MuteFeedback.FireUpdate();
+
+                    Debug.Console(1, this, "Volume Level: {0}", VolumeLevelFeedback.IntValue);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void UpdatePowerFB(byte powerByte)
+        {
+            var newVal = powerByte == 1;
+            if (newVal != _PowerIsOn)
+            {
+                _PowerIsOn = newVal;
+                PowerIsOnFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Updates power status from general updates where source is included.
+        /// Compensates for errant standby / power off hiccups by ignoring 
+        /// power off states with input < 0x10 
+        /// </summary>
+        void UpdatePowerFB(byte powerByte, byte inputByte)
+        {
+            // This should reject errant power feedbacks when switching away from input on standby.
+            if (powerByte == 0x01 && inputByte < 0x10)
+                IsInStandby = true;
+            if (powerByte == 0x00 && IsInStandby) // Ignore power off if coming from standby - glitch
+            {
+                IsInStandby = false;
+                return;
+            }
+        
+            UpdatePowerFB(powerByte);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void UpdateVolumeFB(byte b)
+        {
+            var newVol = (ushort)NumericalHelpers.Scale((double)b, 0, 100, 0, 65535);
+            if (!VolumeIsRamping)
+                _LastVolumeSent = newVol;
+            if (newVol != _VolumeLevelForSig)
+            {
+                _VolumeLevelForSig = newVol;
+                VolumeLevelFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void UpdateMuteFb(byte b)
+        {
+            var newMute = b == 1;
+            if (newMute != _IsMuted)
+            {
+                _IsMuted = newMute;
+                MuteFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void UpdateInputFb(byte b)
+        {
+            var newInput = InputPorts.FirstOrDefault(i => i.FeedbackMatchObject.Equals(b));
+            if (newInput != null && newInput != _CurrentInputPort)
+            {
+                _CurrentInputPort = newInput;
+                CurrentInputFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Formats an outgoing message. Replaces third byte with ID and replaces last byte with checksum
+        /// </summary>
+        /// <param name="b"></param>
+        void SendBytes(byte[] b)
+        {
+            b[1] = ID;
+
+            var command = b.ToString();
+
+            Debug.Console(1, this, "Sending: '{0}'",ComTextHelper.GetEscapedText(b));
+
+            Communication.SendBytes(b);
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void StatusGet()
+        {
+            PowerGet();
+
+            CrestronEnvironment.Sleep(100);
+
+            InputGet();
+
+            CrestronEnvironment.Sleep(100);
+
+            VolumeGet();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public override void PowerOn()
+		{
+            //Send(PowerOnCmd);
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x50, 0x4F, 0x57, 0x01, 0x08, 0x0d });
+			if (!PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
+			{
+				_IsWarmingUp = true;
+				IsWarmingUpFeedback.FireUpdate();
+				// Fake power-up cycle
+				WarmupTimer = new CTimer(o =>
+					{
+						_IsWarmingUp = false;
+						_PowerIsOn = true;
+						IsWarmingUpFeedback.FireUpdate();
+						PowerIsOnFeedback.FireUpdate();
+					}, WarmupTime);
+			}
+		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+		public override void PowerOff()
+		{
+			// If a display has unreliable-power off feedback, just override this and
+			// remove this check.
+            if (!_IsWarmingUp && !_IsCoolingDown) // PowerIsOnFeedback.BoolValue &&
+			{
+                //Send(PowerOffCmd);
+                SendBytes(new byte[] { 0x07, ID, 0x02, 0x50, 0x4F, 0x57, 0x00, 0x08, 0x0d });
+				_IsCoolingDown = true;
+				_PowerIsOn = false;
+				PowerIsOnFeedback.FireUpdate();
+				IsCoolingDownFeedback.FireUpdate();
+				// Fake cool-down cycle
+				CooldownTimer = new CTimer(o =>
+					{
+						_IsCoolingDown = false;
+						IsCoolingDownFeedback.FireUpdate();
+					}, CooldownTime);
+			}
+		}		
+		
+		public override void PowerToggle()
+		{
+			if (PowerIsOnFeedback.BoolValue && !IsWarmingUpFeedback.BoolValue)
+				PowerOff();
+			else if (!PowerIsOnFeedback.BoolValue && !IsCoolingDownFeedback.BoolValue)
+				PowerOn();
+		}
+
+        public void PowerGet()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x01, 0x50, 0x4F, 0x57, 0x08, 0x0d });
+        }
+
+		public void InputHdmi1()
+		{
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputHdmi1Value, 0x08, 0x0d });
+		}
+
+		public void InputHdmi2()
+		{
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputHdmi2Value, 0x08, 0x0d });
+        }
+
+		public void InputHdmi3()
+		{
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputHdmi3Value, 0x08, 0x0d });
+        }
+
+        public void InputHdmi4()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputHdmi4Value, 0x08, 0x0d });
+        }
+
+        public void InputHdmi5()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputHdmi5Value, 0x08, 0x0d });
+        }
+
+		public void InputDisplayPort1()
+		{
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputDisplayPort1Value, 0x08, 0x0d });
+        }
+
+        public void InputVga1()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputVga1Value, 0x08, 0x0d });
+        }
+
+        public void InputIpcOps()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputIpcOpsValue, 0x08, 0x0d });
+        }
+
+        public void InputMediaPlayer()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x4D, 0x49, 0x4E, InputMediaPlayerValue, 0x08, 0x0d });
+        }
+
+        public void InputGet()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x01, 0x4D, 0x49, 0x4E, 0x08, 0x0d });
+        }
+
+        public void VolumeGet()
+        {
+            SendBytes(new byte[] { 0x07, ID, 0x01, 0x56, 0x4F, 0x4C, 0x08, 0x0d });
+        }
+
+
+        /// <summary>
+        /// Executes a switch, turning on display if necessary.
+        /// </summary>
+        /// <param name="selector"></param>
+		public override void ExecuteSwitch(object selector)
+		{
+            //if (!(selector is Action))
+            //    Debug.Console(1, this, "WARNING: ExecuteSwitch cannot handle type {0}", selector.GetType());
+         
+            if (_PowerIsOn)
+                (selector as Action)();
+            else // if power is off, wait until we get on FB to send it. 
+            {
+                // One-time event handler to wait for power on before executing switch
+                EventHandler<EventArgs> handler = null; // necessary to allow reference inside lambda to handler
+                handler = (o, a) =>
+                {
+                    if (!_IsWarmingUp) // Done warming
+                    {
+                        IsWarmingUpFeedback.OutputChange -= handler;
+                        (selector as Action)();
+                    }
+                };
+                IsWarmingUpFeedback.OutputChange += handler; // attach and wait for on FB
+                PowerOn();
+            }
+		}
+
+        /// <summary>
+        /// Scales the level to the range of the display and sends the command
+        /// </summary>
+        /// <param name="level"></param>
+		public void SetVolume(ushort level)
+		{
+            _LastVolumeSent = level;
+            var scaled = (int)NumericalHelpers.Scale(level, 0, 65535, 0, 100);
+            // The inputs to Scale ensure that byte won't overflow
+            SendBytes(new byte[] { 0x07, ID, 0x02, 0x56, 0x4F, 0x4C, Convert.ToByte(scaled), 0x08, 0x0d });
+		}
+
+		#region IBasicVolumeWithFeedback Members
+	    
+		public IntFeedback VolumeLevelFeedback { get; private set; }
+
+		public BoolFeedback MuteFeedback { get; private set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+		public void MuteOff()
+		{
+            SetVolume(_PreMuteVolumeLevel);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+		public void MuteOn()
+		{
+            _PreMuteVolumeLevel = _VolumeLevelForSig;
+
+            SetVolume(0);
+		}
+
+        ///// <summary>
+        ///// 
+        ///// </summary>
+        //public void MuteGet()
+        //{
+        //    SendBytes(new byte[] { 0x07, ID, 0x01, });
+        //}
+
+		#endregion
+
+		#region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+		public void MuteToggle()
+		{
+            if (_IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pressRelease"></param>
+		public void VolumeDown(bool pressRelease)
+		{
+            if (pressRelease)
+            {
+                VolumeIncrementer.StartDown();
+                VolumeIsRamping = true;
+            }
+            else
+            {
+                VolumeIsRamping = false;
+                VolumeIncrementer.Stop();
+            }
+		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pressRelease"></param>
+		public void VolumeUp(bool pressRelease)
+		{
+            if (pressRelease)
+            {
+                VolumeIncrementer.StartUp();
+                VolumeIsRamping = true;
+            }
+            else
+            {
+                VolumeIsRamping = false;
+                VolumeIncrementer.Stop();
+            }
+        }
+
+		#endregion
+	}
+}

Essentials Devices Common/Essentials Devices Common/Display/DeviceFactory.cs

@@ -36,6 +36,12 @@ namespace PepperDash.Essentials.Devices.Displays
                     var comm = CommFactory.CreateCommForDevice(dc);
                     if (comm != null)
                         return new SamsungMDC(dc.Key, dc.Name, comm, dc.Properties["id"].Value<string>());
+                }
+                if (typeName == "avocorvtf")
+                {
+                    var comm = CommFactory.CreateCommForDevice(dc);
+                    if (comm != null)
+                        return new AvocorDisplay(dc.Key, dc.Name, comm, null);
                 }
                    
 			}

Essentials Devices Common/Essentials Devices Common/Display/InputInterfaces.cs

@@ -11,6 +11,7 @@ namespace PepperDash.Essentials.Devices.Displays
     public interface IInputHdmi3 { void InputHdmi3(); }
     public interface IInputHdmi4 { void InputHdmi4(); }
     public interface IInputDisplayPort1 { void InputDisplayPort1(); }
-    public interface IInputDisplayPort2 { void InputDisplayPort2(); }
+    public interface IInputDisplayPort2 { void InputDisplayPort2(); }
+    public interface IInputVga1 { void InputVga1(); }
 
 }

Essentials Devices Common/Essentials Devices Common/Display/SamsungMDCDisplay.cs

@@ -23,6 +23,7 @@ namespace PepperDash.Essentials.Devices.Displays
 
         public byte ID { get; private set; }
 
+        bool LastCommandSentWasVolume;
 
 		bool _PowerIsOn;
 		bool _IsWarmingUp;
@@ -99,9 +100,15 @@ namespace PepperDash.Essentials.Devices.Displays
             AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this), 0x21);
 
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1PC, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1PC), this), 0x22);
+
             AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this), 0x23);
 
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2PC, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2PC), this), 0x24);
+
             AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this), 0x32);
 
@@ -165,6 +172,9 @@ namespace PepperDash.Essentials.Devices.Displays
             IncomingBuffer.CopyTo(newBytes, 0);
             e.Bytes.CopyTo(newBytes, IncomingBuffer.Length);
 
+            if (Debug.Level == 2) // This check is here to prevent following string format from building unnecessarily on level 0 or 1
+                Debug.Console(2, this, "Received:{0}", ComTextHelper.GetEscapedText(newBytes));
+
             // Need to find AA FF and have 
             for (int i = 0; i < newBytes.Length; i++)
             {
@@ -309,6 +319,10 @@ namespace PepperDash.Essentials.Devices.Displays
         /// <param name="b"></param>
         void SendBytes(byte[] b)
         {
+            if (LastCommandSentWasVolume)   // If the last command sent was volume
+                if (b[1] != 0x12)           // Check if this command is volume, and if not, delay this command 
+                    CrestronEnvironment.Sleep(100);
+
             b[2] = ID;
             // append checksum by adding all bytes, except last which should be 00
             int checksum = 0;
@@ -320,6 +334,12 @@ namespace PepperDash.Essentials.Devices.Displays
             b[b.Length - 1] = (byte)checksum;
             if(Debug.Level == 2) // This check is here to prevent following string format from building unnecessarily on level 0 or 1
                 Debug.Console(2, this, "Sending:{0}", ComTextHelper.GetEscapedText(b));
+
+            if (b[1] == 0x12)
+                LastCommandSentWasVolume = true;
+            else
+                LastCommandSentWasVolume = false;
+
             Communication.SendBytes(b);
         }
 
@@ -393,11 +413,21 @@ namespace PepperDash.Essentials.Devices.Displays
 
 		public void InputHdmi1()
 		{
-            SendBytes(new byte[] { 0xAA, 0x14, 0x00, 0x01, 0x22, 0x00 });
+            SendBytes(new byte[] { 0xAA, 0x14, 0x00, 0x01, 0x21, 0x00 });
 		}
 
+        public void InputHdmi1PC()
+        {
+            SendBytes(new byte[] { 0xAA, 0x14, 0x00, 0x01, 0x22, 0x00 });
+        }
+
 		public void InputHdmi2()
 		{
+            SendBytes(new byte[] { 0xAA, 0x14, 0x00, 0x01, 0x23, 0x00 });
+        }
+
+        public void InputHdmi2PC()
+        {
             SendBytes(new byte[] { 0xAA, 0x14, 0x00, 0x01, 0x24, 0x00 });
         }
 

Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj

@@ -59,14 +59,10 @@
       <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.GeneralIO.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.6284.20368, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.1.20241, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\pepperdash-simplsharp-core\Pepperdash Core\CLZ Builds\PepperDash_Core.dll</HintPath>
     </Reference>
-    <Reference Include="PepperDash_Essentials_Core, Version=1.0.0.24289, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\Essentials Core\PepperDashEssentialsBase\bin\PepperDash_Essentials_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>
@@ -109,6 +105,7 @@
     <Compile Include="Codec\iHasScheduleAwareness.cs" />
     <Compile Include="Crestron\Gateways\CenRfgwController.cs" />
     <Compile Include="Display\ComTcpDisplayBase.cs" />
+    <Compile Include="Display\AvocorVTFDisplay.cs" />
     <Compile Include="Display\InputInterfaces.cs" />
     <Compile Include="Display\SamsungMDCDisplay.cs" />
     <Compile Include="Display\DeviceFactory.cs" />
@@ -123,6 +120,8 @@
     <Compile Include="DSP\PolycomSoundStructure\SoundStructureBasics.cs" />
     <Compile Include="Factory\DeviceFactory.cs" />
     <Compile Include="Generic\GenericSource.cs" />
+    <Compile Include="MIcrophone\MicrophonePrivacyController.cs" />
+    <Compile Include="MIcrophone\MicrophonePrivacyControllerConfig.cs" />
     <Compile Include="Occupancy\EssentialsGlsOccupancySensorBaseController.cs" />
     <Compile Include="Occupancy\EssentialsOccupancyAggregator.cs" />
     <Compile Include="Occupancy\iOccupancyStatusProvider.cs" />
@@ -154,6 +153,12 @@
     <Compile Include="VideoCodec\VideoCodecBase.cs" />
     <None Include="Properties\ControlSystem.cfg" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj">
+      <Project>{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}</Project>
+      <Name>PepperDash_Essentials_Core</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>

Essentials Devices Common/Essentials Devices Common/Factory/DeviceFactory.cs

@@ -9,6 +9,7 @@ using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.CrestronIO;
 
 using PepperDash.Essentials.Devices.Common.DSP;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
@@ -116,6 +117,118 @@ namespace PepperDash.Essentials.Devices.Common
                 return new PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.CiscoSparkCodec(key, name, comm, props);
             }
 
+            else if (typeName == "versiportinput")
+            {
+                var props = JsonConvert.DeserializeObject<IOPortConfig>(properties.ToString());
+
+                IIOPorts portDevice;
+
+                if (props.PortDeviceKey == "processor")
+                    portDevice = Global.ControlSystem as IIOPorts;
+                else
+                    portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IIOPorts;
+
+                if(portDevice == null)
+                    Debug.Console(0, "Unable to add versiport device with key '{0}'. Port Device does not support versiports", key);
+                else
+                {
+                    var cs = (portDevice as CrestronControlSystem);
+
+                    if (cs != null)
+                        if (cs.SupportsVersiport && props.PortNumber <= cs.NumberOfVersiPorts)
+                        {
+                            Versiport versiport = cs.VersiPorts[props.PortNumber];
+
+                            if(!versiport.Registered)
+                            {
+                                if (versiport.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
+                                    return new GenericVersiportInputDevice(key, versiport);
+                                else
+                                    Debug.Console(0, "Attempt to register versiport {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
+                            }
+                        }
+
+                    // Future: Check if portDevice is 3-series card or other non control system that supports versiports
+                            
+                }
+            }
+
+            else if (typeName == "digitalinput")
+            {
+                var props = JsonConvert.DeserializeObject<IOPortConfig>(properties.ToString());
+
+                IDigitalInputPorts portDevice;
+
+                if (props.PortDeviceKey == "processor")
+                    portDevice = Global.ControlSystem as IDigitalInputPorts;
+                else
+                    portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IDigitalInputPorts;
+
+                if (portDevice == null)
+                    Debug.Console(0, "Unable to add digital input device with key '{0}'. Port Device does not support digital inputs", key);
+                else
+                {
+                    var cs = (portDevice as CrestronControlSystem);
+
+                    if (cs != null)
+                        if (cs.SupportsDigitalInput && props.PortNumber <= cs.NumberOfDigitalInputPorts)
+                        {
+                            DigitalInput digitalInput = cs.DigitalInputPorts[props.PortNumber];
+
+                            if (!digitalInput.Registered)
+                            {
+                                if(digitalInput.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
+                                    return new GenericDigitalInputDevice(key, digitalInput);
+                                else
+                                    Debug.Console(0, "Attempt to register digital input {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
+                            }
+                        }
+                    // Future: Check if portDevice is 3-series card or other non control system that supports versiports
+                }
+            }
+
+            else if (typeName == "relayoutput")
+            {
+                var props = JsonConvert.DeserializeObject<IOPortConfig>(properties.ToString());
+
+                IRelayPorts portDevice;
+
+                if (props.PortDeviceKey == "processor")
+                    portDevice = Global.ControlSystem as IRelayPorts;
+                else
+                    portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IRelayPorts;
+
+                if (portDevice == null)
+                    Debug.Console(0, "Unable to add relay device with key '{0}'. Port Device does not support relays", key);
+                else
+                {
+                    var cs = (portDevice as CrestronControlSystem);
+
+                    if(cs != null)
+                        if (cs.SupportsRelay && props.PortNumber <= cs.NumberOfRelayPorts)
+                        {
+                            Relay relay = cs.RelayPorts[props.PortNumber];
+
+                            if (!relay.Registered)
+                            {
+                                if(relay.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
+                                    return new GenericRelayDevice(key, relay);
+                                else
+                                    Debug.Console(0, "Attempt to register relay {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
+                            }
+                        }
+
+                    // Future: Check if portDevice is 3-series card or other non control system that supports versiports
+                }
+            }
+
+            else if (typeName == "microphoneprivacycontroller")
+            {
+                var props = JsonConvert.DeserializeObject<Microphones.MicrophonePrivacyControllerConfig>(properties.ToString());
+
+                return new Microphones.MicrophonePrivacyController(key, props);
+            }
+
             else if (groupName == "settopbox") //(typeName == "irstbbase")
             {
                 var irCont = IRPortHelper.GetIrOutputPortController(dc);

Essentials Devices Common/Essentials Devices Common/MIcrophone/MicrophonePrivacyController.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.CrestronIO;
+
+
+namespace PepperDash.Essentials.Devices.Common.Microphones
+{
+    /// <summary>
+    /// Used for applications where one or more microphones with momentary contact closure outputs are used to
+    /// toggle the privacy state of the room.  Privacy state feedback is represented 
+    /// </summary>
+    public class MicrophonePrivacyController : Device
+    {
+        MicrophonePrivacyControllerConfig Config;
+
+        bool initialized;
+
+        public bool EnableLeds
+        {
+            get
+            {
+                return _enableLeds;
+            }
+            set
+            {
+                _enableLeds = value;
+
+                if (initialized)
+                {
+                    if (value)
+                    {
+                        CheckPrivacyMode();
+                        SetLedStates();
+                    }
+                    else
+                        TurnOffAllLeds();
+                }
+            }
+        }
+        bool _enableLeds;
+
+        public List<IDigitalInput> Inputs { get; private set; }
+
+        public GenericRelayDevice RedLedRelay { get; private set; }
+        bool _redLedRelayState;
+
+        public GenericRelayDevice GreenLedRelay { get; private set; }
+        bool _greenLedRelayState;
+
+        public IPrivacy PrivacyDevice { get; private set; }
+
+        public MicrophonePrivacyController(string key, MicrophonePrivacyControllerConfig config) :
+            base(key)
+        {
+            Config = config;
+
+            Inputs = new List<IDigitalInput>();
+        }
+
+        public override bool CustomActivate()
+        {
+            foreach (var i in Config.Inputs)
+            {
+                var input = DeviceManager.GetDeviceForKey(i.DeviceKey) as IDigitalInput;
+
+                if(input != null)
+                    AddInput(input);
+            }
+
+            var greenLed = DeviceManager.GetDeviceForKey(Config.GreenLedRelay.DeviceKey) as GenericRelayDevice;
+
+            if (greenLed != null)
+                GreenLedRelay = greenLed;
+            else
+                Debug.Console(0, this, "Unable to add Green LED device");
+
+            var redLed = DeviceManager.GetDeviceForKey(Config.RedLedRelay.DeviceKey) as GenericRelayDevice;
+
+            if (redLed != null)
+                RedLedRelay = redLed;
+            else
+                Debug.Console(0, this, "Unable to add Red LED device");
+
+            CheckPrivacyMode();
+
+            initialized = true;
+
+            return base.CustomActivate();
+        }
+
+        public void SetPrivacyDevice(IPrivacy privacyDevice)
+        {
+            PrivacyDevice = privacyDevice;
+
+            PrivacyDevice.PrivacyModeIsOnFeedback.OutputChange += new EventHandler<EventArgs>(PrivacyModeIsOnFeedback_OutputChange);
+        }
+
+        void PrivacyModeIsOnFeedback_OutputChange(object sender, EventArgs e)
+        {
+            CheckPrivacyMode();
+        }
+
+        void CheckPrivacyMode()
+        {
+            if (PrivacyDevice != null)
+            {
+                var privacyState = PrivacyDevice.PrivacyModeIsOnFeedback.BoolValue;
+
+                if (privacyState)
+                    TurnOnRedLeds();
+                else
+                    TurnOnGreenLeds();
+            }
+        }
+
+        void AddInput(IDigitalInput input)
+        {
+            Inputs.Add(input);
+
+            input.InputStateFeedback.OutputChange += new EventHandler<EventArgs>(InputStateFeedback_OutputChange);
+        }
+
+        void RemoveInput(IDigitalInput input)
+        {
+            var tempInput = Inputs.FirstOrDefault(i => i.Equals(input));
+
+            if (tempInput != null)
+                tempInput.InputStateFeedback.OutputChange -= InputStateFeedback_OutputChange;
+
+            Inputs.Remove(input);
+        }
+
+        void SetRedLedRelay(GenericRelayDevice relay)
+        {
+            RedLedRelay = relay;
+        }
+
+        void SetGreenLedRelay(GenericRelayDevice relay)
+        {
+            GreenLedRelay = relay;
+        }
+
+        /// <summary>
+        /// Check the state of the input change and handle accordingly
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void InputStateFeedback_OutputChange(object sender, EventArgs e)
+        {
+            if ((sender as BoolFeedback).BoolValue == true)
+                TogglePrivacyMute();
+        }
+
+        /// <summary>
+        /// Toggles the state of the privacy mute
+        /// </summary>
+        void TogglePrivacyMute()
+        {
+            PrivacyDevice.PrivacyModeToggle();
+        }
+
+        void TurnOnRedLeds()
+        {
+            _greenLedRelayState = false;
+            _redLedRelayState = true;
+            SetLedStates();
+        }
+
+        void TurnOnGreenLeds()
+        {
+            _redLedRelayState = false;
+            _greenLedRelayState = true;
+            SetLedStates();
+        }
+
+        /// <summary>
+        /// If enabled, sets the actual state of the relays
+        /// </summary>
+        void SetLedStates()
+        {
+            if (_enableLeds)
+            {
+                SetRelayStates();
+            }
+            else
+                TurnOffAllLeds();
+        }
+
+        /// <summary>
+        /// Turns off all LEDs
+        /// </summary>
+        void TurnOffAllLeds()
+        {
+            _redLedRelayState = false;
+            _greenLedRelayState = false;
+
+            SetRelayStates();
+        }
+
+        void SetRelayStates()
+        {
+            if (RedLedRelay != null)
+            {
+                if (_redLedRelayState)
+                    RedLedRelay.CloseRelay();
+                else
+                    RedLedRelay.OpenRelay();
+            }
+
+            if(GreenLedRelay != null)
+            {
+                if (_greenLedRelayState)
+                    GreenLedRelay.CloseRelay();
+                else
+                    GreenLedRelay.OpenRelay();
+            }
+        }
+    }
+}

Essentials Devices Common/Essentials Devices Common/MIcrophone/MicrophonePrivacyControllerConfig.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core.CrestronIO;
+
+namespace PepperDash.Essentials.Devices.Common.Microphones
+{
+    public class MicrophonePrivacyControllerConfig
+    {
+        public List<KeyedDevice> Inputs { get; set; }
+        public KeyedDevice GreenLedRelay { get; set; }
+        public KeyedDevice RedLedRelay { get; set; }
+    }
+
+    public class KeyedDevice
+    {
+        public string DeviceKey { get; set; }
+    }
+}

Essentials Devices Common/Essentials Devices Common/Properties/AssemblyInfo.cs

@@ -4,5 +4,4 @@
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Essentials_Devices_Common")]
 [assembly: AssemblyCopyright("Copyright ©  2016")]
-[assembly: AssemblyVersion("1.0.0.*")]
-
+[assembly: AssemblyVersion("1.0.3.*")]

Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs

@@ -33,6 +33,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         public StatusMonitorBase CommunicationMonitor { get; private set; }
 
+		public BoolFeedback PresentationViewMaximizedFeedback { get; private set; }
+
+		string CurrentPresentationView;
+
         public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
 
         public IntFeedback PeopleCountFeedback { get; private set; }
@@ -68,15 +72,15 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         /// </summary>
         public List<CodecCommandWithLabel> LocalLayouts = new List<CodecCommandWithLabel>()
         {
-            new CodecCommandWithLabel("auto", "Auto"),
+            //new CodecCommandWithLabel("auto", "Auto"),
             //new CiscoCodecLocalLayout("custom", "Custom"),    // Left out for now
             new CodecCommandWithLabel("equal","Equal"),
             new CodecCommandWithLabel("overlay","Overlay"),
             new CodecCommandWithLabel("prominent","Prominent"),
             new CodecCommandWithLabel("single","Single")
         };
-        
-        private CiscoCodecConfiguration.RootObject CodecConfiguration;
+
+        private CiscoCodecConfiguration.RootObject CodecConfiguration = new CiscoCodecConfiguration.RootObject();
 
         private CiscoCodecStatus.RootObject CodecStatus = new CiscoCodecStatus.RootObject();
 
@@ -242,6 +246,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             SelfviewPipPositionFeedback = new StringFeedback(SelfviewPipPositionFeedbackFunc);
             LocalLayoutFeedback = new StringFeedback(LocalLayoutFeedbackFunc);
 
+			PresentationViewMaximizedFeedback = new BoolFeedback(() => CurrentPresentationView == "Maximized");
+
             Communication = comm;
 
             if (props.CommunicationMonitorProperties != null)
@@ -272,9 +278,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             PortGather.IncludeDelimiter = true;
             PortGather.LineReceived += this.Port_LineReceived;
 
-            CodecConfiguration = new CiscoCodecConfiguration.RootObject();
-            //CodecStatus = new CiscoCodecStatus.RootObject();
-
             CodecInfo = new CiscoCodecInfo(CodecStatus, CodecConfiguration);
 
             CallHistory = new CodecCallHistory();
@@ -671,6 +674,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
                         EvalutateDisconnectEvent(eventReceived);
                     }
+					else if (response.IndexOf("\"Bookings\":{") > -1) // The list has changed, reload it
+					{
+						GetBookings(null);
+					}
                 }
                 else if (response.IndexOf("\"CommandResponse\":{") > -1)
                 {
@@ -1229,6 +1236,20 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             }
         }
 
+		/// <summary>
+		/// 
+		/// </summary>
+		public void MinMaxLayoutToggle()
+		{
+			if (PresentationViewMaximizedFeedback.BoolValue)
+				CurrentPresentationView = "Minimized";
+			else
+				CurrentPresentationView = "Maximized";
+
+			SendText(string.Format("xCommand Video PresentationView Set View:  {0}", CurrentPresentationView));
+			PresentationViewMaximizedFeedback.FireUpdate();
+		}
+
         /// <summary>
         /// Calculates the current selfview PIP position
         /// </summary>
@@ -1264,7 +1285,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
             public override bool MultiSiteOptionIsEnabled
             {
-                                get
+                get
                 {
                     if (CodecStatus.Status.SystemUnit.Software.OptionKeys.MultiSite.Value.ToLower() == "true")
                         return true;
@@ -1285,7 +1306,27 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
                     return string.Empty;
                 }
             }
-            public override string PhoneNumber
+            public override string E164Alias
+            {
+                get 
+                {
+                    if (CodecConfiguration.Configuration.H323.H323Alias.E164 != null)
+                        return CodecConfiguration.Configuration.H323.H323Alias.E164.Value;
+                    else
+                        return string.Empty;
+                }
+            }
+            public override string H323Id
+            {
+                get
+                {
+                    if (CodecConfiguration.Configuration.H323.H323Alias.ID != null)
+                        return CodecConfiguration.Configuration.H323.H323Alias.ID.Value;
+                    else
+                        return string.Empty;
+                }
+            }
+            public override string SipPhoneNumber
             {
                 get
                 {

Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/xConfiguration.cs

@@ -5,7 +5,10 @@ using System.Text;
 
 using Crestron.SimplSharp;
 
+using PepperDash.Core;
+
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 
 namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
@@ -212,9 +215,16 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Mode7 Mode { get; set; }
         }
 
+        public class Framerate
+        {
+            public string valueSpaceRef { get; set; }
+            public string Value { get; set; }
+        }
+
         public class Camera
         {
             public string id { get; set; }
+            public Framerate Framerate { get; set; }
             public Backlight Backlight { get; set; }
             public Brightness Brightness { get; set; }
             public Focus Focus { get; set; }
@@ -243,9 +253,68 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         public class Cameras
         {
-			//[JsonConverter(typeof(CameraConverter))]
-			//public List<Camera> Camera { get; set; }
+            //[JsonConverter(typeof(CameraConverter)), JsonProperty("Camera")]
+            //public List<Camera> Camera { get; set; }
+            //[JsonProperty("SpeakerTrack")]
             public SpeakerTrack SpeakerTrack { get; set; }
+
+            public Cameras()
+            {
+                //Camera = new List<Camera>();
+                SpeakerTrack = new SpeakerTrack();
+            }
+        }
+
+        public class CameraConverter : JsonConverter
+        {
+            // this is currently not working
+            public override bool CanConvert(System.Type objectType)
+            {
+                return objectType == typeof(Camera) || objectType == typeof(List<Camera>); // This should not be called but is required for implmentation
+            }
+
+            public override object ReadJson(JsonReader reader, System.Type objectType, object existingValue, JsonSerializer serializer)
+            {
+                try
+                {
+                    if (reader.TokenType == JsonToken.StartArray)
+                    {
+                        var l = new List<Camera>();
+                        reader.Read();
+                        while (reader.TokenType != JsonToken.EndArray)
+                        {
+                            l.Add(reader.Value as Camera);
+                            reader.Read();
+                        }
+                        Debug.Console(1, "[xConfiguration]: Cameras converted as list");
+                        return l;
+                    }
+                    else
+                    {
+                        Debug.Console(1, "[xConfiguration]: Camera converted as single object and added to list");
+                        return new List<Camera> { reader.Value as Camera };
+                    }
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(1, "[xConfiguration]: Unable to convert JSON for camera objects: {0}", e);
+
+                    return new List<Camera>();
+                }
+            }
+
+            public override bool CanWrite
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+            {
+                throw new NotImplementedException("Write not implemented");
+            }
         }
 
         public class Delay

Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/xStatus.cs

@@ -315,17 +315,70 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         public class Cameras
         {
-			//[JsonConverter(typeof(CameraConverter))]
-			//public List<Camera> Camera { get; set; }
+//            [JsonConverter(typeof(CameraConverter))]
+            public List<Camera> Camera { get; set; }
             public SpeakerTrack SpeakerTrack { get; set; }
 
             public Cameras()
             {
-				//Camera = new List<Camera>();
+                Camera = new List<Camera>();
                 SpeakerTrack = new SpeakerTrack();
             }
         }
 
+        //public class CameraConverter : JsonConverter
+        //{
+
+        //    public override bool CanConvert(System.Type objectType)
+        //    {
+        //        return true; // objectType == typeof(Camera) || objectType == typeof(List<Camera>); // This should not be called but is required for implmentation
+        //    }
+
+        //    public override object ReadJson(JsonReader reader, System.Type objectType, object existingValue, JsonSerializer serializer)
+        //    {
+        //        try
+        //        {
+        //            if (reader.TokenType == JsonToken.StartArray)
+        //            {
+        //                var l = new List<Camera>();
+        //                reader.Read();
+        //                while (reader.TokenType != JsonToken.EndArray)
+        //                {
+        //                    l.Add(reader.Value as Camera);
+        //                    reader.Read();
+        //                }
+        //                Debug.Console(1, "[xStatus]: Cameras converted as list");
+        //                return l;
+        //            }
+        //            else
+        //            {
+        //                Debug.Console(1, "[xStatus]: Camera converted as single object and added to list");
+        //                return new List<Camera> { reader.Value as Camera };
+        //            }
+        //        }
+        //        catch (Exception e)
+        //        {
+        //            Debug.Console(1, "[xStatus]: Unable to convert JSON for camera objects: {0}", e);
+
+        //            return new List<Camera>();
+        //        }
+        //    }
+
+        //    public override bool CanWrite
+        //    {
+        //        get
+        //        {
+        //            return false;
+        //        }
+        //    }
+
+        //    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        //    {
+        //        throw new NotImplementedException("Write not implemented");
+        //    }
+        //}
+
+
         public class MaxActiveCalls
         {
             public string Value { get; set; }

Essentials Devices Common/Essentials Devices Common/VideoCodec/Interfaces/IHasCodecLayouts.cs

@@ -16,5 +16,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
         StringFeedback LocalLayoutFeedback { get; }
 
         void LocalLayoutToggle();
+		void MinMaxLayoutToggle();
     }
 }

Essentials Devices Common/Essentials Devices Common/VideoCodec/MockVC/MockVC.cs

@@ -402,12 +402,22 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
             get { return true; }
         }
 
-        public override string IpAddress
+        public override string E164Alias
         {
-            get { return "xx.xx.xx.xx"; }
+            get { return "someE164alias"; }
         }
 
-        public override string PhoneNumber
+        public override string H323Id
+        {
+            get { return "someH323Id"; }
+        }
+
+        public override string IpAddress
+        {
+            get { return "xxx.xxx.xxx.xxx"; }
+        }
+
+        public override string SipPhoneNumber
         {
             get { return "333-444-5555"; }
         }

Essentials Devices Common/Essentials Devices Common/VideoCodec/VideoCodecBase.cs

@@ -43,8 +43,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
         public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
 
-        bool wasIsInCall;
-
         /// <summary>
         /// Returns true when any call is not in state Unknown, Disconnecting, Disconnected
         /// </summary>
@@ -52,7 +50,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
         { 
             get
             {
-                var value = ActiveCalls.Any(c => c.IsActiveCall);
+                bool value;
+
+                if (ActiveCalls != null)
+                    value = ActiveCalls.Any(c => c.IsActiveCall);
+                else
+                    value = false;
                 return value; 
             } 
         }

Essentials/PepperDashEssentials/Config/EssentialsConfig.cs

@@ -16,7 +16,10 @@ namespace PepperDash.Essentials
 	/// </summary>
 	public class EssentialsConfig : BasicConfig
 	{
+		[JsonProperty("system_url")]
         public string SystemUrl { get; set; }
+
+		[JsonProperty("template_url")]
         public string TemplateUrl { get; set; }
 
         public CotijaConfig Cotija { get; private set; }
@@ -25,7 +28,7 @@ namespace PepperDash.Essentials
         {
             get
             {
-                var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/templates\/(.*)#.*");
+                var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
 
                 string uuid = result.Groups[1].Value;
 
@@ -37,7 +40,7 @@ namespace PepperDash.Essentials
         {
             get
             {
-                var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)#.*");
+                var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
 
                 string uuid = result.Groups[1].Value;
 

Essentials/PepperDashEssentials/ControlSystem.cs

@@ -130,31 +130,6 @@ namespace PepperDash.Essentials
 					Debug.Console(0, "WARNING: Cannot load unknown device type '{0}', key '{1}'.", devConf.Type, devConf.Key);
 			}
 
-            // CODEC TESTING
-            /*
-            try
-            {
-                GenericSshClient TestCodecClient = new GenericSshClient("TestCodec-1--SshClient", "10.11.50.135", 22, "crestron", "2H3Zu&OvgXp6");
-
-                var props = new PepperDash.Essentials.Devices.Common.Codec.CiscoCodecPropertiesConfig();
-
-                props.PhonebookMode = "Local";
-                props.Favorites = new System.Collections.Generic.List<PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem>();
-                props.Favorites.Add(new PepperDash.Essentials.Devices.Common.Codec.CodecActiveCallItem() { Name = "NYU Cisco Webex", Number = "10.11.50.211" });
-
-                PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.CiscoCodec TestCodec =
-                    new PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.CiscoCodec("TestCodec-1", "Cisco Spark Room Kit", TestCodecClient, props);
-
-                TestCodec.CommDebuggingIsOn = true;
-
-                TestCodec.CustomActivate();
-            }
-            catch (Exception e)
-            {
-                Debug.Console(0, "Error in something Neil is working on ;) \r{0}", e);
-            }
-            */
-            // CODEC TESTING
 		}
 
 		/// <summary>

Essentials/PepperDashEssentials/OTHER/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -97,6 +97,8 @@ namespace PepperDash.Essentials.Fusion
 
         CTimer PushNotificationTimer = null;
 
+        CTimer DailyTimeRequestTimer = null;
+
         // Default poll time is 5 min unless overridden by config value
         public long SchedulePollInterval = 300000;
 
@@ -465,16 +467,35 @@ namespace PepperDash.Essentials.Fusion
 
 
                 // Request current Fusion Server Time
+                RequestLocalDateTime(null);
 
-                string timeRequestID = "TimeRequest";
+                // Setup timer to request time daily
+                if (DailyTimeRequestTimer != null && !DailyTimeRequestTimer.Disposed)
+                {
+                    DailyTimeRequestTimer.Stop();
+                    DailyTimeRequestTimer.Dispose();
+                }
 
-                string timeRequest = string.Format("<LocalTimeRequest><RequestID>{0}</RequestID></LocalTimeRequest>", timeRequestID);
+                DailyTimeRequestTimer = new CTimer(RequestLocalDateTime, null, 86400000, 86400000);
 
-                FusionRoom.ExtenderFusionRoomDataReservedSigs.LocalDateTimeQuery.StringValue = timeRequest;
+                DailyTimeRequestTimer.Reset(86400000, 86400000);
             }
 
         }
 
+        /// <summary>
+        /// Requests the local date and time from the Fusion Server
+        /// </summary>
+        /// <param name="callbackObject"></param>
+        public void RequestLocalDateTime(object callbackObject)
+        {
+            string timeRequestID = "TimeRequest";
+
+            string timeRequest = string.Format("<LocalTimeRequest><RequestID>{0}</RequestID></LocalTimeRequest>", timeRequestID);
+
+            FusionRoom.ExtenderFusionRoomDataReservedSigs.LocalDateTimeQuery.StringValue = timeRequest;
+        }
+
         /// <summary>
         /// Generates a room schedule request for this room for the next 24 hours.
         /// </summary>

Essentials/PepperDashEssentials/PepperDashEssentials.csproj

@@ -70,23 +70,15 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
-    <Reference Include="Essentials Devices Common, Version=1.0.0.18129, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\Essentials Devices Common\Essentials Devices Common\bin\Essentials Devices Common.dll</HintPath>
-    </Reference>
     <Reference Include="mscorlib" />
     <Reference Include="PepperDashCorePortalSync, Version=1.0.0.27069, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\pepperdash-portal-sync\SspPortalSync\SspPortalSync\bin\PepperDashCorePortalSync.dll</HintPath>
     </Reference>
-    <Reference Include="PepperDash_Core, Version=1.0.0.18868, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.1.20241, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\pepperdash-simplsharp-core\Pepperdash Core\CLZ Builds\PepperDash_Core.dll</HintPath>
     </Reference>
-    <Reference Include="PepperDash_Essentials_Core, Version=1.0.0.18243, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\Essentials Core\PepperDashEssentialsBase\bin\PepperDash_Essentials_Core.dll</HintPath>
-    </Reference>
     <Reference Include="PepperDash_Essentials_DM, Version=1.0.0.19343, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\Essentials DM\Essentials_DM\bin\PepperDash_Essentials_DM.dll</HintPath>
@@ -169,7 +161,7 @@
     <Compile Include="FOR REFERENCE UI\Panels\SmartGraphicsTouchpanelControllerBase.cs" />
     <Compile Include="UIDrivers\SigInterlock.cs" />
     <Compile Include="UIDrivers\EssentialsHuddleVTC\EssentialsHuddlePresentationUiDriver.cs" />
-    <Compile Include="UIDrivers\EssentialsHuddleVTC\EssentialsHuddleTechPageDriver.cs" />
+    <Compile Include="UIDrivers\EssentialsHuddle\EssentialsHuddleTechPageDriver.cs" />
     <Compile Include="UI\HttpLogoServer.cs" />
     <Compile Include="UI\SmartObjectHeaderButtonList.cs" />
     <Compile Include="UI\SubpageReferenceListCallStagingItem.cs" />
@@ -185,7 +177,7 @@
     <Compile Include="UIDrivers\Page Drivers\SingleSubpageModalDriver.cs" />
     <Compile Include="UIDrivers\Essentials\EssentialsPanelMainInterfaceDriver.cs" />
     <Compile Include="UIDrivers\enums and base.cs" />
-    <Compile Include="UIDrivers\Essentials\EssentialsHuddlePanelAvFunctionsDriver.cs" />
+    <Compile Include="UIDrivers\EssentialsHuddle\EssentialsHuddlePanelAvFunctionsDriver.cs" />
     <Compile Include="UIDrivers\Page Drivers\SingleSubpageModalAndBackDriver.cs" />
     <Compile Include="UIDrivers\SmartObjectRoomsList.cs" />
     <Compile Include="UI\JoinConstants\UIBoolJoin.cs" />
@@ -201,6 +193,16 @@
     <None Include="app.config" />
     <None Include="Properties\ControlSystem.cfg" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj">
+      <Project>{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}</Project>
+      <Name>PepperDash_Essentials_Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Essentials Devices Common\Essentials Devices Common\Essentials Devices Common.csproj">
+      <Project>{892B761C-E479-44CE-BD74-243E9214AF13}</Project>
+      <Name>Essentials Devices Common</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>

Essentials/PepperDashEssentials/Properties/AssemblyInfo.cs

@@ -4,5 +4,5 @@
 [assembly: AssemblyCompany("PepperDash Technology Corp")]
 [assembly: AssemblyProduct("PepperDashEssentials")]
 [assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2017")]
-[assembly: AssemblyVersion("1.0.1.*")]
+[assembly: AssemblyVersion("1.0.7.*")]
 

Essentials/PepperDashEssentials/Room/Config/EssentialsRoomConfig.cs

@@ -73,6 +73,8 @@ namespace PepperDash.Essentials.Room.Config
                 rm.DefaultSourceItem = props.DefaultSourceItem;
                 rm.DefaultVolume = (ushort)(props.Volumes.Master.Level * 65535 / 100);
 
+                rm.MicrophonePrivacy = GetMicrophonePrivacy(props, rm); // Get Microphone Privacy object, if any
+
                 rm.Emergency = GetEmergency(props, rm); // Get emergency object, if any
 
                 return rm;
@@ -97,6 +99,58 @@ namespace PepperDash.Essentials.Room.Config
             }
             return null;
         }
+
+        PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController GetMicrophonePrivacy(EssentialsRoomPropertiesConfig props, EssentialsHuddleVtc1Room room)
+        {
+            var microphonePrivacy = props.MicrophonePrivacy;
+            if (microphonePrivacy != null)
+            {
+                // Get the MicrophonePrivacy device from the device manager
+                var mP = (DeviceManager.GetDeviceForKey(props.MicrophonePrivacy.DeviceKey) as PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController);
+                // Set this room as the IPrivacy device
+                if (mP != null)
+                {
+                    mP.SetPrivacyDevice(room);
+
+                    var behaviour = props.MicrophonePrivacy.Behaviour.ToLower();
+
+                    if (behaviour != null)
+                    {
+                        if (behaviour == "trackroomstate")
+                        {
+                            // Tie LED enable to room power state
+                            room.OnFeedback.OutputChange += (o, a) =>
+                            {
+                                if (room.OnFeedback.BoolValue)
+                                    mP.EnableLeds = true;
+                                else
+                                    mP.EnableLeds = false;
+                            };
+
+                            mP.EnableLeds = room.OnFeedback.BoolValue;
+                        }
+                        else if (behaviour == "trackcallstate")
+                        {
+                            // Tie LED enable to room power state
+                            room.InCallFeedback.OutputChange += (o, a) =>
+                            {
+                                if (room.InCallFeedback.BoolValue)
+                                    mP.EnableLeds = true;
+                                else
+                                    mP.EnableLeds = false;
+                            };
+
+                            mP.EnableLeds = room.InCallFeedback.BoolValue;
+                        }
+                    }
+                    else
+                        Debug.Console(0, "No behaviour defined for MicrophonePrivacyController");
+
+                    return mP;
+                }
+            }
+            return null;
+        }
 	}
 
     /// <summary>
@@ -105,6 +159,7 @@ namespace PepperDash.Essentials.Room.Config
 	public class EssentialsRoomPropertiesConfig
 	{
         public EssentialsRoomEmergencyConfig Emergency { get; set; }
+        public EssentialsRoomMicrophonePrivacyConfig MicrophonePrivacy {get; set;}
 		public string HelpMessage { get; set; }
         public string Description { get; set; }
         public int ShutdownVacancySeconds { get; set; }
@@ -118,6 +173,12 @@ namespace PepperDash.Essentials.Room.Config
         public EssentialsRoomVolumesConfig Volumes { get; set; }
 	}
 
+    public class EssentialsRoomMicrophonePrivacyConfig
+    {
+        public string DeviceKey { get; set; }
+        public string Behaviour { get; set; }
+    }
+
     /// <summary>
     /// Properties for the help text box
     /// </summary>

Essentials/PepperDashEssentials/Room/Cotija/CotijaConfig.cs

@@ -5,10 +5,13 @@ using System.Text;
 using Crestron.SimplSharp;
 using PepperDash.Essentials.Core.Config;
 
+using Newtonsoft.Json;
+
 namespace PepperDash.Essentials
 {
     public class CotijaConfig : DeviceConfig
     {       
-        public string serverUrl { get; set; }     
+		[JsonProperty("serverUrl")]
+        public string ServerUrl { get; set; }     
     }
 }

Essentials/PepperDashEssentials/Room/Cotija/CotijaSystemController.cs

@@ -22,17 +22,17 @@ namespace PepperDash.Essentials
 
         CotijaConfig Config;
 
-        HttpClient Client;
+		HttpClient Client;
 
         Dictionary<string, Object> ActionDictionary = new Dictionary<string, Object>(StringComparer.InvariantCultureIgnoreCase);
 
         Dictionary<string, CTimer> PushedActions = new Dictionary<string, CTimer>();
 
-        CTimer ServerHeartbeat;
+        CTimer ServerHeartbeatCheckTimer;
 
         long ServerHeartbeatInterval = 20000;
 
-        CTimer ServerReconnect;
+        CTimer ServerReconnectTimer;
 
         long ServerReconnectInterval = 5000;
 
@@ -48,10 +48,15 @@ namespace PepperDash.Essentials
 
             CotijaRooms = new List<CotijaEssentialsHuddleSpaceRoomBridge>();
 
-            CrestronConsole.AddNewConsoleCommand(RegisterSystemToServer, "InitializeHttpClient", "Initializes a new HTTP client connection to a specified URL", ConsoleAccessLevelEnum.AccessOperator);
-            CrestronConsole.AddNewConsoleCommand(DisconnectSseClient, "CloseHttpClient", "Closes the active HTTP client", ConsoleAccessLevelEnum.AccessOperator);
+			//CrestronConsole.AddNewConsoleCommand(s => RegisterSystemToServer(), 
+			//    "CotiInitializeHttpClient", "Initializes a new HTTP client connection to a specified URL", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(DisconnectSseClient, 
+				"CloseHttpClient", "Closes the active HTTP client", ConsoleAccessLevelEnum.AccessOperator);
 
-            AddPostActivationAction(() => RegisterSystemToServer(null));
+			CrestronConsole.AddNewConsoleCommand(AuthorizeSystem,
+				"cotijaauth", "Authorizes system to talk to cotija server", ConsoleAccessLevelEnum.AccessOperator);
+
+            AddPostActivationAction(() => RegisterSystemToServer());
         }
 
         /// <summary>
@@ -67,12 +72,12 @@ namespace PepperDash.Essentials
             }
             else
             {
-                Debug.Console(1, this, "Cannot add action with key '{0}' because key already exists in ActionDictionary.");
+                Debug.Console(1, this, "Cannot add action with key '{0}' because key already exists in ActionDictionary.", key);
             }
         }
 
         /// <summary>
-        /// Removes and action from the dictionary
+        /// Removes an action from the dictionary
         /// </summary>
         /// <param name="key"></param>
         public void RemoveAction(string key)
@@ -81,18 +86,60 @@ namespace PepperDash.Essentials
                 ActionDictionary.Remove(key);
         }
 
-        void ReconnectToServer(object o)
+        void ReconnectToServerTimerCallback(object o)
         {
-            RegisterSystemToServer(null);
+            RegisterSystemToServer();
         }
 
+		/// <summary>
+		/// Verifies system connection with servers
+		/// </summary>
+		/// <param name="command"></param>
+		void AuthorizeSystem(string code)
+		{
+			if (string.IsNullOrEmpty(code))
+			{
+				CrestronConsole.ConsoleCommandResponse("Please enter a user code to authorize a system");
+				return;
+			}
+
+
+			var req = new HttpClientRequest();
+			string url = string.Format("http://{0}/api/system/grantcode/{1}", Config.ServerUrl, code);
+			Debug.Console(0, this, "Authorizing to: {0}", url);
+
+			if (string.IsNullOrEmpty(Config.ServerUrl))
+			{
+				CrestronConsole.ConsoleCommandResponse("Config URL address is not set.  Check portal configuration");
+				return;
+			}
+			try
+			{
+				req.Url.Parse(url);
+				new HttpClient().DispatchAsync(req, (r, e) =>
+				{
+					if (r.Code == 200)
+					{
+						Debug.Console(0, this, "System authorized, sending config.");
+						RegisterSystemToServer();
+					}
+					else
+						Debug.Console(0, this, "HTTP Error {0} in authorizing system", r.Code);
+				});
+			}
+			catch (Exception e)
+			{
+				Debug.Console(0, this, "Error in authorizing: {0}", e);
+			}
+		}
+
         /// <summary>
         /// Registers the room with the server
         /// </summary>
         /// <param name="url">URL of the server, including the port number, if not 80.  Format: "serverUrlOrIp:port"</param>
-        void RegisterSystemToServer(string command)
+        void RegisterSystemToServer()
         {
-            try
+			try
             {
                 string filePath = string.Format(@"\NVRAM\Program{0}\configurationFile.json", Global.ControlSystem.ProgramNumber);
                 string postBody = null;
@@ -122,23 +169,23 @@ namespace PepperDash.Essentials
                 }
                 else
                 {
-                    Client = new HttpClient();
-
-                    HttpClientRequest request = new HttpClientRequest();
-
-                    Client.Verbose = true;
-                    Client.KeepAlive = true;
-
+					//if(Client == null)
+	                Client = new HttpClient();
+					Client.Verbose = true;
+					Client.KeepAlive = true;
+	
                     SystemUuid = Essentials.ConfigReader.ConfigObject.SystemUuid;
 
-                    string url = string.Format("http://{0}/api/system/join/{1}", Config.serverUrl, SystemUuid);
+                    string url = string.Format("http://{0}/api/system/join/{1}", Config.ServerUrl, SystemUuid);
+					Debug.Console(1, this, "Sending config to {0}", url);
 
+                    HttpClientRequest request = new HttpClientRequest();
                     request.Url.Parse(url);
                     request.RequestType = RequestType.Post;
                     request.Header.SetHeaderValue("Content-Type", "application/json");
                     request.ContentString = postBody;
 
-                    Client.DispatchAsync(request, PostConnectionCallback);
+					Client.DispatchAsync(request, PostConnectionCallback);
                 }
 
             }
@@ -158,18 +205,14 @@ namespace PepperDash.Essentials
         {
             try
             {
-                if (Client == null)
-                    Client = new HttpClient();
+				if(Client == null)
+	                Client = new HttpClient();
+				Client.Verbose = true;
+				Client.KeepAlive = true;
 
-                //HttpClient client = new HttpClient();
+                string url = string.Format("http://{0}/api/system/{1}/status", Config.ServerUrl, SystemUuid);
 
                 HttpClientRequest request = new HttpClientRequest();
-
-                Client.Verbose = true;
-                Client.KeepAlive = true;
-
-                string url = string.Format("http://{0}/api/room/{1}/status", Config.serverUrl, string.Format("{0}--{1}", SystemUuid, room.Key));
-
                 request.Url.Parse(url);
                 request.RequestType = RequestType.Post;
                 request.Header.SetHeaderValue("Content-Type", "application/json");
@@ -180,10 +223,17 @@ namespace PepperDash.Essentials
                 request.ContentString = ignored;
 
                 Debug.Console(1, this, "Posting to '{0}':\n{1}", url, request.ContentString);
+				try
+				{
+					Client.DispatchAsync(request, (r, err) => { if (r != null) { Debug.Console(1, this, "Status Response Code: {0}", r.Code); } });
+				}
+				catch (Exception e)
+				{
 
-                Client.DispatchAsync(request, (r, err) => { if (r != null) { Debug.Console(1, this, "Status Response Code: {0}", r.Code); } });
+					Debug.Console(1, this, "PostToServer exception: {0}", e);
+				}
 
-                StartReconnectTimer(ServerReconnectInterval, ServerReconnectInterval);
+				//ResetOrStartHearbeatTimer();
             }
             catch(Exception e)
             {
@@ -200,11 +250,11 @@ namespace PepperDash.Essentials
             if(SseClient != null)
                 SseClient.Disconnect();
 
-            if (ServerHeartbeat != null)
+            if (ServerHeartbeatCheckTimer != null)
             {
-                ServerHeartbeat.Stop();
+                ServerHeartbeatCheckTimer.Stop();
 
-                ServerHeartbeat = null;
+                ServerHeartbeatCheckTimer = null;
             }
         }
         
@@ -219,17 +269,18 @@ namespace PepperDash.Essentials
             {
                 if (resp != null && resp.Code == 200)
                 {
-                    if(ServerReconnect != null)
+                    if(ServerReconnectTimer != null)
                     {
-                        ServerReconnect.Stop();
+                        ServerReconnectTimer.Stop();
 
-                        ServerReconnect = null;
+                        ServerReconnectTimer = null;
                     }
 
-                    if (SseClient == null)
-                    {
+#warning The SSE Client from a previous session might need to be killed...
+					//if (SseClient == null)
+					//{
                         ConnectSseClient(null);
-                    }
+					//}
                 }
                 else
                 {
@@ -249,40 +300,48 @@ namespace PepperDash.Essentials
         /// Executes when we don't get a heartbeat message in time.  Triggers reconnect.
         /// </summary>
         /// <param name="o"></param>
-        void HeartbeatExpired(object o)
+        void HeartbeatExpiredTimerCallback(object o)
         {
-             if (ServerHeartbeat != null)
+			Debug.Console(1, this, "Heartbeat Timer Expired.");
+			if (ServerHeartbeatCheckTimer != null)
             {
-                Debug.Console(1, this, "Heartbeat Timer Expired.");
-
-                ServerHeartbeat.Stop();
-
-                ServerHeartbeat = null;
+                ServerHeartbeatCheckTimer.Stop();
+                ServerHeartbeatCheckTimer = null;
             }
-
-             StartReconnectTimer(ServerReconnectInterval, ServerReconnectInterval);
+            StartReconnectTimer();
         }
 
-        void StartReconnectTimer(long dueTime, long repeatTime)
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="dueTime"></param>
+		/// <param name="repeatTime"></param>
+        void StartReconnectTimer()
         {
             // Start the reconnect timer
-            ServerReconnect = new CTimer(ReconnectToServer, null, dueTime, repeatTime);
-
-            ServerReconnect.Reset(dueTime, repeatTime);
+			if (ServerReconnectTimer == null)
+			{
+				ServerReconnectTimer = new CTimer(ReconnectToServerTimerCallback, null, ServerReconnectInterval, ServerReconnectInterval);
+				Debug.Console(1, this, "Reconnect Timer Started.");
+			}
+			ServerReconnectTimer.Reset(ServerReconnectInterval, ServerReconnectInterval);
         }
 
-        void StartHearbeatTimer(long dueTime, long repeatTime)
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="dueTime"></param>
+		/// <param name="repeatTime"></param>
+        void ResetOrStartHearbeatTimer()
         {
-            if (ServerHeartbeat == null)
+            if (ServerHeartbeatCheckTimer == null)
             {
-                ServerHeartbeat = new CTimer(HeartbeatExpired, null, dueTime, repeatTime);
+				ServerHeartbeatCheckTimer = new CTimer(HeartbeatExpiredTimerCallback, null, ServerHeartbeatInterval, ServerHeartbeatInterval);
 
-                Debug.Console(2, this, "Heartbeat Timer Started.");
+                Debug.Console(1, this, "Heartbeat Timer Started.");
             }
 
-            ServerHeartbeat.Reset(dueTime, repeatTime);
-
-            Debug.Console(2, this, "Heartbeat Timer Reset.");
+			ServerHeartbeatCheckTimer.Reset(ServerHeartbeatInterval, ServerHeartbeatInterval);
         }
 
 
@@ -312,12 +371,16 @@ namespace PepperDash.Essentials
 
             string uuid = Essentials.ConfigReader.ConfigObject.SystemUuid;
 
-            SseClient.Url = string.Format("http://{0}/api/system/stream/{1}", Config.serverUrl, uuid);
+            SseClient.Url = string.Format("http://{0}/api/system/stream/{1}", Config.ServerUrl, uuid);
 
             SseClient.Connect();
         }
             
-
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
         void LineGathered_LineReceived(object sender, GenericCommMethodReceiveTextArgs e)
         {
             //Debug.Console(1, this, "Received from Server: '{0}'", e.Text);
@@ -336,101 +399,102 @@ namespace PepperDash.Essentials
 
                     if (type == "hello")
                     {
-                        StartHearbeatTimer(ServerHeartbeatInterval, ServerHeartbeatInterval);
+                        ResetOrStartHearbeatTimer();
                     }
-                    else if (type == "/system/heartbeat")
-                    {
-                        StartHearbeatTimer(ServerHeartbeatInterval, ServerHeartbeatInterval);
-                    }
-                    else if (type == "close")
-                    {
-                        SseClient.Disconnect();
+					else if (type == "/system/heartbeat")
+					{
+						ResetOrStartHearbeatTimer();
+					}
+					else if (type == "close")
+					{
+						SseClient.Disconnect();
 
-                        // Start the reconnect timer
-                        ServerReconnect = new CTimer(ConnectSseClient, null, ServerReconnectInterval, ServerReconnectInterval);
+						ServerHeartbeatCheckTimer.Stop();
+						// Start the reconnect timer
+						StartReconnectTimer();
+						//ServerReconnectTimer = new CTimer(ConnectSseClient, null, ServerReconnectInterval, ServerReconnectInterval);
+						//ServerReconnectTimer.Reset(ServerReconnectInterval, ServerReconnectInterval);
+					}
+					else
+					{
+						// Check path against Action dictionary
+						if (ActionDictionary.ContainsKey(type))
+						{
+							var action = ActionDictionary[type];
 
-                        ServerReconnect.Reset(ServerReconnectInterval, ServerReconnectInterval);
-                    }
-                    else
-                    {
-                        // Check path against Action dictionary
-                        if (ActionDictionary.ContainsKey(type))
-                        {
-                            var action = ActionDictionary[type];
+							if (action is Action)
+							{
+								(action as Action)();
+							}
+							else if (action is PressAndHoldAction)
+							{
+								var stateString = messageObj["content"]["state"].Value<string>();
 
-                            if (action is Action)
-                            {
-                                (action as Action)();
-                            }
-                            else if (action is PressAndHoldAction)
-                            {
-                                var stateString = messageObj["content"]["state"].Value<string>();
+								// Look for a button press event
+								if (!string.IsNullOrEmpty(stateString))
+								{
+									switch (stateString)
+									{
+										case "true":
+											{
+												if (!PushedActions.ContainsKey(type))
+												{
+													PushedActions.Add(type, new CTimer(o =>
+													{
+														(action as PressAndHoldAction)(false);
+														PushedActions.Remove(type);
+													}, null, ButtonHeartbeatInterval, ButtonHeartbeatInterval));
+												}
+												// Maybe add an else to reset the timer
+												break;
+											}
+										case "held":
+											{
+												if (!PushedActions.ContainsKey(type))
+												{
+													PushedActions[type].Reset(ButtonHeartbeatInterval, ButtonHeartbeatInterval);
+												}
+												return;
+											}
+										case "false":
+											{
+												if (PushedActions.ContainsKey(type))
+												{
+													PushedActions[type].Stop();
+													PushedActions.Remove(type);
+												}
+												break;
+											}
+									}
 
-                                // Look for a button press event
-                                if (!string.IsNullOrEmpty(stateString))
-                                {
-                                    switch (stateString)
-                                    {
-                                        case "true":
-                                            {
-                                                if (!PushedActions.ContainsKey(type))
-                                                {
-                                                    PushedActions.Add(type, new CTimer(o => 
-                                                    {
-                                                        (action as PressAndHoldAction)(false);
-                                                       PushedActions.Remove(type);
-                                                    }, null, ButtonHeartbeatInterval, ButtonHeartbeatInterval));
-                                                }
-                                                // Maybe add an else to reset the timer
-                                                break;
-                                            }
-                                        case "held":
-                                            {
-                                                if (!PushedActions.ContainsKey(type))
-                                                {
-                                                    PushedActions[type].Reset(ButtonHeartbeatInterval, ButtonHeartbeatInterval);
-                                                }
-                                                return;
-                                            }
-                                        case "false":
-                                            {
-                                                if (PushedActions.ContainsKey(type))
-                                                {
-                                                    PushedActions[type].Stop();
-                                                    PushedActions.Remove(type);
-                                                }
-                                                break;
-                                            }
-                                    }
+									(action as PressAndHoldAction)(stateString == "true");
+								}
+							}
+							else if (action is Action<bool>)
+							{
+								var stateString = messageObj["content"]["state"].Value<string>();
 
-                                    (action as PressAndHoldAction)(stateString == "true");
-                                }
-                            }
-                            else if (action is Action<bool>)
-                            {
-                                var stateString = messageObj["content"]["state"].Value<string>();
+								if (!string.IsNullOrEmpty(stateString))
+								{
+									(action as Action<bool>)(stateString == "true");
+								}
+							}
+							else if (action is Action<ushort>)
+							{
+								(action as Action<ushort>)(messageObj["content"]["value"].Value<ushort>());
+							}
+							else if (action is Action<string>)
+							{
+								(action as Action<string>)(messageObj["content"]["value"].Value<string>());
+							}
+							else if (action is Action<SourceSelectMessageContent>)
+							{
+								(action as Action<SourceSelectMessageContent>)(messageObj["content"]
+									.ToObject<SourceSelectMessageContent>());
+							}
+						}
 
-                                if (!string.IsNullOrEmpty(stateString))
-                                {
-                                    (action as Action<bool>)(stateString == "true");
-                                }
-                            }
-                            else if (action is Action<ushort>)
-                            {
-                                (action as Action<ushort>)(messageObj["content"]["value"].Value<ushort>());
-                            }
-                            else if (action is Action<string>)
-                            {
-                                (action as Action<string>)(messageObj["content"]["value"].Value<string>());
-                            }
-                            else if (action is Action<SourceSelectMessageContent>)
-                            {
-                                (action as Action<SourceSelectMessageContent>)(messageObj["content"]
-                                    .ToObject<SourceSelectMessageContent>());
-                            }
-                        }
-
-                    }
+					}
 
                 }
                 catch (Exception err)

Essentials/PepperDashEssentials/Room/Types/EssentialsHuddleSpaceRoom.cs

@@ -24,8 +24,8 @@ namespace PepperDash.Essentials
                     var disp = DefaultDisplay as DisplayBase;
                     var val = CurrentSourceInfo != null
                         && CurrentSourceInfo.Type == eSourceListItemType.Route
-                        && disp != null
-                        && disp.PowerIsOnFeedback.BoolValue;
+                        && disp != null;
+                        //&& disp.PowerIsOnFeedback.BoolValue;
                     return val;
                 };
             }
@@ -202,6 +202,12 @@ namespace PepperDash.Essentials
         /// </summary>
         protected override void EndShutdown()
         {
+            SetDefaultLevels();
+
+            RunDefaultRoute();
+
+            CrestronEnvironment.Sleep(200);
+
             RunRouteAction("roomOff");
         }
 
@@ -370,7 +376,10 @@ namespace PepperDash.Essentials
         /// </summary>
         public override void SetDefaultLevels()
         {
-            Debug.Console(0, this, "SetDefaultLevels not implemented");
+            Debug.Console(1, this, "Restoring default levels");
+            var vc = CurrentVolumeControls as IBasicVolumeWithFeedback;
+            if (vc != null)
+                vc.SetVolume(DefaultVolume);
         }
 
 		/// <summary>

Essentials/PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs

@@ -243,7 +243,10 @@ namespace PepperDash.Essentials
             }
 
             InCallFeedback = new BoolFeedback(() => VideoCodec.IsInCall);
-            IsSharingFeedback = new BoolFeedback(() => VideoCodec.SharingSourceFeedback.StringValue != null); 
+            VideoCodec.CallStatusChange += (o, a) => this.InCallFeedback.FireUpdate();
+
+            IsSharingFeedback = new BoolFeedback(() => VideoCodec.SharingContentIsOnFeedback.BoolValue);
+            VideoCodec.SharingContentIsOnFeedback.OutputChange += (o, a) => this.IsSharingFeedback.FireUpdate();
 
             // link privacy to VC (for now?)
             PrivacyModeIsOnFeedback = new BoolFeedback(() => VideoCodec.PrivacyModeIsOnFeedback.BoolValue);
@@ -262,6 +265,13 @@ namespace PepperDash.Essentials
         protected override void EndShutdown()
         {
             VideoCodec.EndAllCalls();
+
+            SetDefaultLevels();
+
+            RunDefaultPresentRoute();
+
+            CrestronEnvironment.Sleep(200);
+
             RunRouteAction("roomOff");
         }
 

Essentials/PepperDashEssentials/Room/Types/EssentialsRoomBase.cs

@@ -51,6 +51,8 @@ namespace PepperDash.Essentials
 
         public PepperDash.Essentials.Room.EssentialsRoomEmergencyBase Emergency { get; set; }
 
+        public PepperDash.Essentials.Devices.Common.Microphones.MicrophonePrivacyController MicrophonePrivacy { get; set; }
+
         public string LogoUrl { get; set; }
 
         protected SecondsCountdownTimer RoomVacancyShutdownTimer { get; private set; }

Essentials/PepperDashEssentials/UI/JoinConstants/UIBoolJoin.cs

@@ -207,11 +207,23 @@ namespace PepperDash.Essentials
 		/// <summary>
 		/// 1252
 		/// </summary>
-		public const uint VCRemoteViewTogglePress = 1252;
+		public const uint VCLayoutTogglePress = 1252;
 		/// <summary>
 		/// 1253
 		/// </summary>
 		public const uint VCSelfViewPipTogglePress = 1253;
+		/// <summary>
+		/// 1254
+		/// </summary>
+		public const uint VCLayoutToggleEnable = 1254;
+		/// <summary>
+		/// 1255
+		/// </summary>
+		public const uint VCMinMaxPress = 1255;
+		/// <summary>
+		/// 1256
+		/// </summary>
+		public const uint VCMinMaxEnable = 1256; 
 
 
         //******************************************************

Essentials/PepperDashEssentials/UI/JoinConstants/UISmartObjectJoin.cs

@@ -28,6 +28,10 @@
         /// 1204
         /// </summary>
         public const uint VCFavoritesList = 1204;
+		/// <summary>
+		/// 1205 Layout buttons dynamic list
+		/// </summary>
+		public const uint VCLayoutsList = 1205;
 
 
         //******************************************************

Essentials/PepperDashEssentials/UI/JoinConstants/UIStringlJoin.cs

@@ -118,10 +118,6 @@ namespace PepperDash.Essentials
         /// </summary>
         public const uint RoomPhoneText = 3904;
         /// <summary>
-        /// 3905 - SIP address for room header
-        /// </summary>
-        public const uint RoomSipText = 3905;
-        /// <summary>
         /// 3906 - The separator for verbose-header text on addresses
         /// </summary>
         public const uint RoomAddressPipeText = 3906;

Essentials/PepperDashEssentials/UIDrivers/EssentialsHuddle/EssentialsHuddleTechPageDriver.cs

@@ -1,300 +1,325 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro.DeviceSupport;
-
-using PepperDash.Core;
-using PepperDash.Essentials;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.SmartObjects;
-using PepperDash.Essentials.Core.Touchpanels.Keyboards;
-using PepperDash.Essentials.Devices.Displays;
-using PepperDash.Essentials.Room.Config;
-
-namespace PepperDash.Essentials.UIDrivers
-{
-    public class EssentialsHuddleTechPageDriver : PanelDriverBase
-    {
-        /// <summary>
-        /// 
-        /// </summary>
-        SmartObjectDynamicList MenuList;
-        /// <summary>
-        /// 
-        /// </summary>
-        SubpageReferenceList StatusList;
-        /// <summary>
-        /// The list of display controls
-        /// </summary>
-        SubpageReferenceList DisplayList;
-        /// <summary>
-        /// References lines in the list against device instances
-        /// </summary>
-        Dictionary<ICommunicationMonitor, uint> StatusListDeviceIndexes;
-        /// <summary>
-        /// 
-        /// </summary>
-        IAVDriver Parent;
-        /// <summary>
-        /// 
-        /// </summary>
-        JoinedSigInterlock PagesInterlock;
-
-        /// <summary>
-        /// 1
-        /// </summary>
-        public const uint JoinText = 1;
-
-        CTimer PinAuthorizedTimer;
-
-		EssentialsRoomTechConfig Config;
-
-        StringBuilder PinEntryBuilder = new StringBuilder(4);
-
-        bool IsAuthorized;
-
-        SmartObjectNumeric PinKeypad;
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="trilist"></param>
-        /// <param name="parent"></param>
-        public EssentialsHuddleTechPageDriver(BasicTriListWithSmartObject trilist, IAVDriver parent, EssentialsRoomTechConfig config)
-            : base(trilist)
-        {
-            Parent = parent;
-			Config = config;
-
-            PagesInterlock = new JoinedSigInterlock(trilist);
-            PagesInterlock.SetButDontShow(UIBoolJoin.TechSystemStatusVisible);
-
-            trilist.SetSigFalseAction(UIBoolJoin.TechExitButton, Hide);
-
-            MenuList = new SmartObjectDynamicList(trilist.SmartObjects[UISmartObjectJoin.TechMenuList], 
-                true, 3100);
-
-            MenuList.SetFeedback(1, true); // initial fb
-
-            MenuList.SetItemMainText(1, "System Status");
-            MenuList.SetItemButtonAction(1, b => { 
-                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechSystemStatusVisible); 
-                MenuList.SetFeedback(1, true);
-            });
-
-            MenuList.SetItemMainText(2, "Display Controls");
-            MenuList.SetItemButtonAction(2, b => { 
-                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechDisplayControlsVisible); 
-                MenuList.SetFeedback(2, true);
-            });           
-            
-            MenuList.SetItemMainText(3, "Panel Setup");
-            MenuList.SetItemButtonAction(3, b => { 
-                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechPanelSetupVisible);
-                MenuList.SetFeedback(3, true);
-            });
-            MenuList.Count = 3;
-
-            BuildStatusList();
-
-            BuildDisplayList();
-
-            SetupPinModal();
-        }
-        
-        /// <summary>
-        /// 
-        /// </summary>
-        public override void Show()
-        {
-            // divert to PIN if we need auth
-            if (IsAuthorized)
-            {
-                // Cancel the auth timer so we don't deauth after coming back in
-                if (PinAuthorizedTimer != null)
-                    PinAuthorizedTimer.Stop();
-
-                TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, true);
-                PagesInterlock.Show();
-                base.Show();
-            }
-            else
-            {
-                TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, true);
-            }
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public override void Hide()
-        {
-            // Leave it authorized for 60 seconds.
-            if (IsAuthorized)
-                PinAuthorizedTimer = new CTimer(o => { 
-                    IsAuthorized = false;
-                    PinAuthorizedTimer = null;
-                }, 60000);
-            TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, false);
-            PagesInterlock.Hide();
-            base.Hide();
-        }
-
-        /// <summary>
-        /// Wire up the keypad and buttons
-        /// </summary>
-        void SetupPinModal()
-        {
-            TriList.SetSigFalseAction(UIBoolJoin.PinDialogCancelPress, CancelPinDialog);
-            PinKeypad = new SmartObjectNumeric(TriList.SmartObjects[UISmartObjectJoin.TechPinDialogKeypad], true);
-            PinKeypad.Digit0.UserObject = new Action<bool>(b => { if (b)DialPinDigit('0'); });
-            PinKeypad.Digit1.UserObject = new Action<bool>(b => { if (b)DialPinDigit('1'); });
-            PinKeypad.Digit2.UserObject = new Action<bool>(b => { if (b)DialPinDigit('2'); });
-            PinKeypad.Digit3.UserObject = new Action<bool>(b => { if (b)DialPinDigit('3'); });
-            PinKeypad.Digit4.UserObject = new Action<bool>(b => { if (b)DialPinDigit('4'); });
-            PinKeypad.Digit5.UserObject = new Action<bool>(b => { if (b)DialPinDigit('5'); });
-            PinKeypad.Digit6.UserObject = new Action<bool>(b => { if (b)DialPinDigit('6'); });
-            PinKeypad.Digit7.UserObject = new Action<bool>(b => { if (b)DialPinDigit('7'); });
-            PinKeypad.Digit8.UserObject = new Action<bool>(b => { if (b)DialPinDigit('8'); });
-            PinKeypad.Digit9.UserObject = new Action<bool>(b => { if (b)DialPinDigit('9'); });
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="d"></param>
-        void DialPinDigit(char d)
-        {
-            PinEntryBuilder.Append(d);
-            var len = PinEntryBuilder.Length;
-            SetPinDotsFeedback(len);
-
-            // check it!
-            if (len == 4)
-            {
-                if (Config.Password == PinEntryBuilder.ToString())
-                {
-                    IsAuthorized = true;
-                    SetPinDotsFeedback(0);
-                    TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
-                    Show();
-                }
-                else
-                {
-                    SetPinDotsFeedback(0);
-                    TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, true);
-                    new CTimer(o => 
-                        {
-                            TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, false);
-                        }, 1500);
-                }
-
-                PinEntryBuilder.Remove(0, len); // clear it either way
-            }
-        }
-
-        /// <summary>
-        /// Draws the dots as pin is entered
-        /// </summary>
-        /// <param name="len"></param>
-        void SetPinDotsFeedback(int len)
-        {
-            TriList.SetBool(UIBoolJoin.PinDialogDot1, len >= 1);
-            TriList.SetBool(UIBoolJoin.PinDialogDot2, len >= 2);
-            TriList.SetBool(UIBoolJoin.PinDialogDot3, len >= 3);
-            TriList.SetBool(UIBoolJoin.PinDialogDot4, len == 4);
-
-        }
-
-        /// <summary>
-        /// Does what it says
-        /// </summary>
-        void CancelPinDialog()
-        {
-            PinEntryBuilder.Remove(0, PinEntryBuilder.Length);
-            TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
-        }
-
-
-        /// <summary>
-        /// 
-        /// </summary>
-        void BuildStatusList()
-        {
-            StatusList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechStatusList, 3, 3, 3);
-            StatusListDeviceIndexes = new Dictionary<ICommunicationMonitor, uint>();
-            uint i = 0;
-            foreach (var d in DeviceManager.AllDevices)
-            {
-                // make sure it is both ICommunicationMonitor and a Device
-                var sd = d as ICommunicationMonitor;
-                if (sd == null)
-                    continue;
-                var dd = sd as Device;
-                if(dd == null)
-                    continue;
-                i++;
-                StatusList.StringInputSig(i, 1).StringValue = dd.Name;
-                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)sd.CommunicationMonitor.Status;
-                StatusListDeviceIndexes.Add(sd, i);
-                sd.CommunicationMonitor.StatusChange += CommunicationMonitor_StatusChange ;
-            }
-            StatusList.Count = (ushort)i;
-        }
-
-        /// <summary>
-        /// Builds the list of display controls
-        /// </summary>
-        void BuildDisplayList()
-        {
-            DisplayList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechDisplayControlsList, 10, 3, 3);
-
-            var devKeys = ConfigReader.ConfigObject.Devices.Where(d =>
-                d.Group.Equals("display", StringComparison.OrdinalIgnoreCase)
-                || d.Group.Equals("projector", StringComparison.OrdinalIgnoreCase))
-                .Select(dd => dd.Key);
-            var disps = DeviceManager.AllDevices.Where(d =>
-                devKeys.Contains(d.Key));
-            ushort i = 0;
-            foreach (var disp in disps)
-            {
-                var display = disp as DisplayBase;
-                if (display != null)
-                {
-                    i++;
-                    DisplayList.StringInputSig(i, 1).StringValue = display.Name;
-                    DisplayList.GetBoolFeedbackSig(i, 1).SetSigFalseAction(display.PowerOn);
-                    DisplayList.GetBoolFeedbackSig(i, 2).SetSigFalseAction(display.PowerOff);
-                    DisplayList.GetBoolFeedbackSig(i, 3).SetSigFalseAction(() =>
-                        { if (display is IInputHdmi1) (display as IInputHdmi1).InputHdmi1(); });
-                    DisplayList.GetBoolFeedbackSig(i, 4).SetSigFalseAction(() =>
-                    { if (display is IInputHdmi2) (display as IInputHdmi2).InputHdmi2(); });
-                    DisplayList.GetBoolFeedbackSig(i, 5).SetSigFalseAction(() =>
-                    { if (display is IInputHdmi3) (display as IInputHdmi3).InputHdmi3(); });
-                    DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
-                    { if (display is IInputHdmi4) (display as IInputHdmi4).InputHdmi4(); });
-                    DisplayList.GetBoolFeedbackSig(i, 7).SetSigFalseAction(() =>
-                    { if (display is IInputDisplayPort1) (display as IInputDisplayPort1).InputDisplayPort1(); });
-                }
-            }
-
-            DisplayList.Count = i;
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        void CommunicationMonitor_StatusChange(object sender, MonitorStatusChangeEventArgs e)
-        {
-            var c = sender as ICommunicationMonitor;
-            if (StatusListDeviceIndexes.ContainsKey(c))
-            {
-                var i = StatusListDeviceIndexes[c];
-                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)e.Status;
-            }
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.SmartObjects;
+using PepperDash.Essentials.Core.Touchpanels.Keyboards;
+using PepperDash.Essentials.Devices.Displays;
+using PepperDash.Essentials.Room.Config;
+
+namespace PepperDash.Essentials.UIDrivers
+{
+    public class EssentialsHuddleTechPageDriver : PanelDriverBase
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        SmartObjectDynamicList MenuList;
+        /// <summary>
+        /// 
+        /// </summary>
+        SubpageReferenceList StatusList;
+        /// <summary>
+        /// The list of display controls
+        /// </summary>
+        SubpageReferenceList DisplayList;
+        /// <summary>
+        /// References lines in the list against device instances
+        /// </summary>
+        Dictionary<ICommunicationMonitor, uint> StatusListDeviceIndexes;
+        /// <summary>
+        /// 
+        /// </summary>
+        JoinedSigInterlock PagesInterlock;
+
+        /// <summary>
+        /// 1
+        /// </summary>
+        public const uint JoinText = 1;
+
+        CTimer PinAuthorizedTimer;
+
+		EssentialsRoomTechConfig Config;
+
+        StringBuilder PinEntryBuilder = new StringBuilder(4);
+
+        bool IsAuthorized;
+
+        SmartObjectNumeric PinKeypad;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="trilist"></param>
+        /// <param name="parent"></param>
+        public EssentialsHuddleTechPageDriver(BasicTriListWithSmartObject trilist, EssentialsRoomTechConfig config)
+            : base(trilist)
+        {
+			Config = config;
+
+            PagesInterlock = new JoinedSigInterlock(trilist);
+            PagesInterlock.SetButDontShow(UIBoolJoin.TechSystemStatusVisible);
+
+            trilist.SetSigFalseAction(UIBoolJoin.TechExitButton, Hide);
+
+            MenuList = new SmartObjectDynamicList(trilist.SmartObjects[UISmartObjectJoin.TechMenuList], 
+                true, 3100);
+
+            MenuList.SetFeedback(1, true); // initial fb
+			ushort count = 0;
+
+            MenuList.SetItemMainText(1, "System Status");
+            MenuList.SetItemButtonAction(1, b => { 
+                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechSystemStatusVisible); 
+                MenuList.SetFeedback(1, true);
+            });
+
+            MenuList.SetItemMainText(2, "Display Controls");
+            MenuList.SetItemButtonAction(2, b => { 
+                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechDisplayControlsVisible); 
+                MenuList.SetFeedback(2, true);
+            });
+
+			count = 2;
+
+			// Don't show panel setup on iPad or xpanel
+			if (TriList is Crestron.SimplSharpPro.DeviceSupport.TswFt5Button)
+			{
+				count++;
+				MenuList.SetItemMainText(count, "Panel Setup");
+				MenuList.SetItemButtonAction(count, b =>
+				{
+					if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechPanelSetupVisible);
+					MenuList.SetFeedback(count, true);
+				});
+			}
+
+            MenuList.Count = count;
+            BuildStatusList();
+            BuildDisplayList();
+            SetupPinModal();
+        }
+        
+        /// <summary>
+        /// 
+        /// </summary>
+        public override void Show()
+        {
+            // divert to PIN if we need auth
+            if (IsAuthorized)
+            {
+                // Cancel the auth timer so we don't deauth after coming back in
+                if (PinAuthorizedTimer != null)
+                    PinAuthorizedTimer.Stop();
+
+                TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, true);
+                PagesInterlock.Show();
+                base.Show();
+            }
+            else
+            {
+                TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, true);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public override void Hide()
+        {
+            // Leave it authorized for 60 seconds.
+            if (IsAuthorized)
+                PinAuthorizedTimer = new CTimer(o => { 
+                    IsAuthorized = false;
+                    PinAuthorizedTimer = null;
+                }, 60000);
+            TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, false);
+            PagesInterlock.Hide();
+            base.Hide();
+        }
+
+        /// <summary>
+        /// Wire up the keypad and buttons
+        /// </summary>
+        void SetupPinModal()
+        {
+            TriList.SetSigFalseAction(UIBoolJoin.PinDialogCancelPress, CancelPinDialog);
+            PinKeypad = new SmartObjectNumeric(TriList.SmartObjects[UISmartObjectJoin.TechPinDialogKeypad], true);
+            PinKeypad.Digit0.UserObject = new Action<bool>(b => { if (b)DialPinDigit('0'); });
+            PinKeypad.Digit1.UserObject = new Action<bool>(b => { if (b)DialPinDigit('1'); });
+            PinKeypad.Digit2.UserObject = new Action<bool>(b => { if (b)DialPinDigit('2'); });
+            PinKeypad.Digit3.UserObject = new Action<bool>(b => { if (b)DialPinDigit('3'); });
+            PinKeypad.Digit4.UserObject = new Action<bool>(b => { if (b)DialPinDigit('4'); });
+            PinKeypad.Digit5.UserObject = new Action<bool>(b => { if (b)DialPinDigit('5'); });
+            PinKeypad.Digit6.UserObject = new Action<bool>(b => { if (b)DialPinDigit('6'); });
+            PinKeypad.Digit7.UserObject = new Action<bool>(b => { if (b)DialPinDigit('7'); });
+            PinKeypad.Digit8.UserObject = new Action<bool>(b => { if (b)DialPinDigit('8'); });
+            PinKeypad.Digit9.UserObject = new Action<bool>(b => { if (b)DialPinDigit('9'); });
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="d"></param>
+        void DialPinDigit(char d)
+        {
+            PinEntryBuilder.Append(d);
+            var len = PinEntryBuilder.Length;
+            SetPinDotsFeedback(len);
+
+            // check it!
+            if (len == 4)
+            {
+                if (Config.Password == PinEntryBuilder.ToString())
+                {
+                    IsAuthorized = true;
+                    SetPinDotsFeedback(0);
+                    TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
+                    Show();
+                }
+                else
+                {
+                    SetPinDotsFeedback(0);
+                    TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, true);
+                    new CTimer(o => 
+                        {
+                            TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, false);
+                        }, 1500);
+                }
+
+                PinEntryBuilder.Remove(0, len); // clear it either way
+            }
+        }
+
+        /// <summary>
+        /// Draws the dots as pin is entered
+        /// </summary>
+        /// <param name="len"></param>
+        void SetPinDotsFeedback(int len)
+        {
+            TriList.SetBool(UIBoolJoin.PinDialogDot1, len >= 1);
+            TriList.SetBool(UIBoolJoin.PinDialogDot2, len >= 2);
+            TriList.SetBool(UIBoolJoin.PinDialogDot3, len >= 3);
+            TriList.SetBool(UIBoolJoin.PinDialogDot4, len == 4);
+
+        }
+
+        /// <summary>
+        /// Does what it says
+        /// </summary>
+        void CancelPinDialog()
+        {
+            PinEntryBuilder.Remove(0, PinEntryBuilder.Length);
+            TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void BuildStatusList()
+        {
+            StatusList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechStatusList, 3, 3, 3);
+            StatusListDeviceIndexes = new Dictionary<ICommunicationMonitor, uint>();
+            uint i = 0;
+            foreach (var d in DeviceManager.AllDevices)
+            {
+                // make sure it is both ICommunicationMonitor and a Device
+                var sd = d as ICommunicationMonitor;
+                if (sd == null)
+                    continue;
+                var dd = sd as Device;
+                if(dd == null)
+                    continue;
+                i++;
+                StatusList.StringInputSig(i, 1).StringValue = dd.Name;
+                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)sd.CommunicationMonitor.Status;
+                StatusListDeviceIndexes.Add(sd, i);
+                sd.CommunicationMonitor.StatusChange += CommunicationMonitor_StatusChange ;
+            }
+            StatusList.Count = (ushort)i;
+        }
+
+        /// <summary>
+        /// Builds the list of display controls
+        /// </summary>
+        void BuildDisplayList()
+        {
+            DisplayList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechDisplayControlsList, 10, 3, 3);
+
+            var devKeys = ConfigReader.ConfigObject.Devices.Where(d =>
+                d.Group.Equals("display", StringComparison.OrdinalIgnoreCase)
+                || d.Group.Equals("projector", StringComparison.OrdinalIgnoreCase))
+                .Select(dd => dd.Key);
+            var disps = DeviceManager.AllDevices.Where(d =>
+                devKeys.Contains(d.Key));
+            ushort i = 0;
+            foreach (var disp in disps)
+            {
+                var display = disp as DisplayBase;
+                if (display != null)
+                {
+                    i++;
+                    DisplayList.StringInputSig(i, 1).StringValue = display.Name;
+                    DisplayList.GetBoolFeedbackSig(i, 1).SetSigFalseAction(display.PowerOn);      
+                    DisplayList.GetBoolFeedbackSig(i, 2).SetSigFalseAction(display.PowerOff);
+                    if (display is TwoWayDisplayBase)
+                    {
+                        var powerOnSig = DisplayList.BoolInputSig(i, 1);
+                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkInputSig(powerOnSig);
+
+                        var powerOffSig = DisplayList.BoolInputSig(1, 2);
+                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkComplementInputSig(powerOffSig);
+                    } 
+                    DisplayList.GetBoolFeedbackSig(i, 3).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi1) (display as IInputHdmi1).InputHdmi1(); });
+                    DisplayList.GetBoolFeedbackSig(i, 4).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi2) (display as IInputHdmi2).InputHdmi2(); });
+                    DisplayList.GetBoolFeedbackSig(i, 5).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi3) (display as IInputHdmi3).InputHdmi3(); });
+                    //DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
+                    //{ if (display is IInputHdmi4) (display as IInputHdmi4).InputHdmi4(); });
+                    DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
+                        { if (display is IInputDisplayPort1) (display as IInputDisplayPort1).InputDisplayPort1(); });
+
+                
+                    // Figure out some way to provide current input feedback
+                    if (display is TwoWayDisplayBase)
+                    {
+                        (display as TwoWayDisplayBase).CurrentInputFeedback.OutputChange += new EventHandler<EventArgs>(CurrentInputFeedback_OutputChange);
+                    }
+                }
+
+                
+            }
+
+            DisplayList.Count = i;
+        }
+
+
+        void CurrentInputFeedback_OutputChange(object sender, EventArgs e)
+        {
+            
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void CommunicationMonitor_StatusChange(object sender, MonitorStatusChangeEventArgs e)
+        {
+            var c = sender as ICommunicationMonitor;
+            if (StatusListDeviceIndexes.ContainsKey(c))
+            {
+                var i = StatusListDeviceIndexes[c];
+                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)e.Status;
+            }
+        }
+    }
 }

Essentials/PepperDashEssentials/UIDrivers/EssentialsHuddleVTC/EssentialsHuddleVtc1PanelAvFunctionsDriver.cs

@@ -164,7 +164,7 @@ namespace PepperDash.Essentials
             get
             {
                 if (_TechDriver == null)
-                    _TechDriver = new PepperDash.Essentials.UIDrivers.EssentialsHuddleTechPageDriver(TriList, this, CurrentRoom.Config.Tech);
+                    _TechDriver = new PepperDash.Essentials.UIDrivers.EssentialsHuddleTechPageDriver(TriList, CurrentRoom.Config.Tech);
                 return _TechDriver;
             }
         }
@@ -190,7 +190,7 @@ namespace PepperDash.Essentials
 		/// <summary>
 		/// Tracks the last meeting that was cancelled
 		/// </summary>
-		Meeting LastMeetingDismissed;
+		string LastMeetingDismissedId;
 
         /// <summary>
         /// Constructor
@@ -422,37 +422,42 @@ namespace PepperDash.Essentials
 			var ss = CurrentRoom.ScheduleSource;
 			if (ss != null)
 			{
-				NextMeetingTimer = new CTimer(o => ShowNextMeetingCallback(), null, 0, 60000);
+				NextMeetingTimer = new CTimer(o => ShowNextMeetingTimerCallback(), null, 0, 60000);
 			}
 		}
 
 		/// <summary>
 		/// 
 		/// </summary>
-		void ShowNextMeetingCallback()
+		void ShowNextMeetingTimerCallback()
 		{
-			// Every 60 seconds, check meetings list for the closest, joinable meeting
+			// Every 60 seconds, refresh the calendar
+			RefreshMeetingsList();
+			// check meetings list for the closest, joinable meeting
 			var ss = CurrentRoom.ScheduleSource;
 			var meetings = ss.CodecSchedule.Meetings;
 
 			if (meetings.Count > 0)
 			{
-				var meeting = meetings.FirstOrDefault(m => m.Joinable);
-
 				// If the room is off pester the user
 				// If the room is on, and the meeting is joinable
 				// and the LastMeetingDismissed != this meeting
 
+				var lastMeetingDismissed = meetings.FirstOrDefault(m => m.Id == LastMeetingDismissedId);
+				Debug.Console(0, "*#* Room on: {0}, lastMeetingDismissedId: {1} {2} *#*", 
+					CurrentRoom.OnFeedback.BoolValue,
+					LastMeetingDismissedId,
+					lastMeetingDismissed != null ? lastMeetingDismissed.StartTime.ToShortTimeString() : "");
 
-				Debug.Console(0, "*#* Room on: {0}, LastMeetingDismissed: {1} *#*", CurrentRoom.OnFeedback.BoolValue,
-					LastMeetingDismissed != null ? LastMeetingDismissed.StartTime.ToShortTimeString() : "null");
+				var meeting = meetings.LastOrDefault(m => m.Joinable);
 				if (CurrentRoom.OnFeedback.BoolValue
-					&& LastMeetingDismissed == meeting)
+					&& lastMeetingDismissed == meeting)
 				{
 					return;
 				}
 
-				LastMeetingDismissed = null;
+				LastMeetingDismissedId = null;
+				// Clear the popup when we run out of meetings
 				if (meeting == null)
 				{
 					HideNextMeetingPopup();
@@ -468,13 +473,16 @@ namespace PepperDash.Essentials
 					TriList.SetSigFalseAction(UIBoolJoin.NextMeetingJoinPress, () =>
 					{
 						HideNextMeetingPopup();
+						PopupInterlock.Hide();
 						RoomOnAndDialMeeting(meeting);
 					});
 					TriList.SetString(UIStringJoin.NextMeetingSecondaryButtonLabel, "Show Schedule");
 					TriList.SetSigFalseAction(UIBoolJoin.CalendarHeaderButtonPress, () =>
 					{
 						HideNextMeetingPopup();
-						CalendarPress();
+						//CalendarPress();
+						RefreshMeetingsList();
+						PopupInterlock.ShowInterlocked(UIBoolJoin.MeetingsOrContacMethodsListVisible);
 					});
 					var indexOfNext = meetings.IndexOf(meeting) + 1;
 
@@ -489,7 +497,7 @@ namespace PepperDash.Essentials
 						{
 							// Mark the meeting to not re-harass the user
 							if(CurrentRoom.OnFeedback.BoolValue)
-								LastMeetingDismissed = meeting;
+								LastMeetingDismissedId = meeting.Id;
 							HideNextMeetingPopup();
 						});
 
@@ -512,7 +520,7 @@ namespace PepperDash.Essentials
 		/// </summary>
 		void CalendarPress()
 		{
-			RefreshMeetingsList();
+			//RefreshMeetingsList(); // List should be up-to-date
 			PopupInterlock.ShowInterlockedWithToggle(UIBoolJoin.MeetingsOrContacMethodsListVisible);
 		}
 
@@ -527,6 +535,7 @@ namespace PepperDash.Essentials
                     if (d != null)
                     {
                         d.Dial(meeting);
+						LastMeetingDismissedId = meeting.Id; // To prevent prompts for already-joined call
                     }
 				};
 			if (CurrentRoom.OnFeedback.BoolValue)
@@ -942,6 +951,7 @@ namespace PepperDash.Essentials
                 _CurrentRoom.CurrentSingleSourceChange += CurrentRoom_SourceInfoChange;
                 RefreshSourceInfo();
 
+				(_CurrentRoom.VideoCodec as IHasScheduleAwareness).CodecSchedule.MeetingsListHasChanged += CodecSchedule_MeetingsListHasChanged;
 
                 CallSharingInfoVisibleFeedback = new BoolFeedback(() => _CurrentRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue);
                 _CurrentRoom.VideoCodec.SharingContentIsOnFeedback.OutputChange += new EventHandler<EventArgs>(SharingContentIsOnFeedback_OutputChange);
@@ -963,6 +973,16 @@ namespace PepperDash.Essentials
             }
         }
 
+		/// <summary>
+		/// If the schedule changes, this event will fire
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
+		void CodecSchedule_MeetingsListHasChanged(object sender, EventArgs e)
+		{
+			RefreshMeetingsList();
+		}
+
         /// <summary>
         /// Updates the current shared source label on the call list when the source changes
         /// </summary>
@@ -971,7 +991,7 @@ namespace PepperDash.Essentials
         /// <param name="type"></param>
         void CurrentRoom_CurrentSingleSourceChange(EssentialsRoomBase room, SourceListItem info, ChangeType type)
         {
-            if (_CurrentRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue)
+            if (_CurrentRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue && _CurrentRoom.CurrentSourceInfo != null)
                 TriList.StringInput[UIStringJoin.CallSharedSourceNameText].StringValue = _CurrentRoom.CurrentSourceInfo.PreferredName;
         }
 
@@ -994,10 +1014,14 @@ namespace PepperDash.Essentials
 
             string callListSharedSourceLabel;
 
-            if (_CurrentRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue)
-                callListSharedSourceLabel = _CurrentRoom.CurrentSourceInfo.PreferredName;
-            else
-                callListSharedSourceLabel = "None";
+			if (_CurrentRoom.VideoCodec.SharingContentIsOnFeedback.BoolValue && _CurrentRoom.CurrentSourceInfo != null)
+			{
+				Debug.Console(0, "*#* CurrentRoom.CurrentSourceInfo = {0}", 
+					_CurrentRoom.CurrentSourceInfo != null ? _CurrentRoom.CurrentSourceInfo.SourceKey : "Nada!");
+				callListSharedSourceLabel = _CurrentRoom.CurrentSourceInfo.PreferredName;
+			}
+			else
+				callListSharedSourceLabel = "None";
 
             TriList.StringInput[UIStringJoin.CallSharedSourceNameText].StringValue = callListSharedSourceLabel;
         }
@@ -1157,7 +1181,8 @@ namespace PepperDash.Essentials
 		void RefreshMeetingsList()
 		{
             // See if this is helpful or if the callback response in the codec class maybe doesn't come it time?
-            CurrentRoom.ScheduleSource.GetSchedule();
+            // Let's build list from event
+			// CurrentRoom.ScheduleSource.GetSchedule();
 
             TriList.SetString(UIStringJoin.MeetingsOrContactMethodListIcon, "Calendar");
             TriList.SetString(UIStringJoin.MeetingsOrContactMethodListTitleText, "Today's Meetings");
@@ -1232,7 +1257,7 @@ namespace PepperDash.Essentials
                 TriList.BooleanInput[UIBoolJoin.VolumeDualMute1Visible].BoolValue = false;
                 TriList.BooleanInput[UIBoolJoin.SourceStagingBarVisible].BoolValue = false;
 				// Clear this so that the pesky meeting warning can resurface every minute when off
-				LastMeetingDismissed = null;
+				LastMeetingDismissedId = null;
             }
         }
 
@@ -1244,15 +1269,10 @@ namespace PepperDash.Essentials
             if (CurrentRoom.IsWarmingUpFeedback.BoolValue)
             {
 				ShowNotificationRibbon("Room is powering on. Please wait...", 0);
-				//WarmingCoolingModal = new ModalDialog(TriList);
-				//WarmingCoolingModal.PresentModalDialog(0, "Powering Up", "Power", "<p>Room is powering up</p><p>Please wait</p>",
-				//    "", "", false, false, null);
             }
             else
             {
 				ShowNotificationRibbon("Room is powered on. Welcome.", 2000);
-				//if (WarmingCoolingModal != null)
-				//    WarmingCoolingModal.CancelDialog();
             }
         }
 
@@ -1266,16 +1286,10 @@ namespace PepperDash.Essentials
             if (CurrentRoom.IsCoolingDownFeedback.BoolValue)
             {
 				ShowNotificationRibbon("Room is powering off. Please wait.", 0);
-
-				//WarmingCoolingModal = new ModalDialog(TriList);
-				//WarmingCoolingModal.PresentModalDialog(0, "Power Off", "Power", "<p>Room is powering off</p><p>Please wait</p>",
-				//    "", "", false, false, null);
             }
             else
             {
 				HideNotificationRibbon();
-				//if (WarmingCoolingModal != null)
-				//    WarmingCoolingModal.CancelDialog();
             }
         }
 
@@ -1460,13 +1474,13 @@ namespace PepperDash.Essentials
         void ComputeHeaderCallStatus(VideoCodecBase codec);
         bool HeaderButtonsAreSetUp { get; }
         SubpageReferenceList MeetingOrContactMethodModalSrl { get; }
-		/// <summary>
-		/// Exposes the ability to switch into call mode
-		/// </summary>
-		void ActivityCallButtonPressed();
-		/// <summary>
-		/// Allows the codec to trigger the main UI to clear up if call is coming in.
-		/// </summary>
-		void PrepareForCodecIncomingCall();
+        /// <summary>
+        /// Exposes the ability to switch into call mode
+        /// </summary>
+        void ActivityCallButtonPressed();
+        /// <summary>
+        /// Allows the codec to trigger the main UI to clear up if call is coming in.
+        /// </summary>
+        void PrepareForCodecIncomingCall();
     }
 }

Essentials/PepperDashEssentials/UIDrivers/VC/EssentialsVideoCodecUiDriver.cs

@@ -107,7 +107,7 @@ namespace PepperDash.Essentials.UIDrivers.VC
                 SetupDirectoryList();
                 SetupRecentCallsList();
                 SetupFavorites();
-                SetupSelfViewControls();
+                SetupLayoutControls();
 
                 codec.CallStatusChange += new EventHandler<CodecCallStatusItemChangeEventArgs>(Codec_CallStatusChange);
 
@@ -175,7 +175,6 @@ namespace PepperDash.Essentials.UIDrivers.VC
 
                 triList.SetSigFalseAction(UIBoolJoin.VCDirectorySearchTextPress, RevealKeyboard);
 
-                //TriList.SetSigFalseAction(UIBoolJoin.VCDirectoryBackspacePress, SearchKeypadBackspacePress);
                 triList.SetSigHeldAction(UIBoolJoin.VCDirectoryBackspacePress, 500,
                     StartSearchBackspaceRepeat, StopSearchBackspaceRepeat, SearchKeypadBackspacePress);
 
@@ -194,8 +193,16 @@ namespace PepperDash.Essentials.UIDrivers.VC
         /// <param name="e"></param>
         void Codec_IsReady()
         {
-            TriList.SetString(UIStringJoin.RoomPhoneText, GetFormattedPhoneNumber(Codec.CodecInfo.PhoneNumber));
-            TriList.SetString(UIStringJoin.RoomSipText, Codec.CodecInfo.SipUri);
+            string roomNumberSipUri = "";
+            if (!string.IsNullOrEmpty(Codec.CodecInfo.SipUri)) // If both values are present, format the string with a pipe divider
+                roomNumberSipUri = string.Format("{0} | {1}", GetFormattedPhoneNumber(Codec.CodecInfo.SipPhoneNumber), Codec.CodecInfo.SipUri);
+            else                                               // If only one value present, just show the phone number
+                roomNumberSipUri = Codec.CodecInfo.SipPhoneNumber;
+
+            if(string.IsNullOrEmpty(roomNumberSipUri))
+                roomNumberSipUri = string.Format("{0} | {1}", GetFormattedPhoneNumber(Codec.CodecInfo.E164Alias), Codec.CodecInfo.H323Id);
+
+            TriList.SetString(UIStringJoin.RoomPhoneText, roomNumberSipUri);
 
             if(Parent.HeaderButtonsAreSetUp)
                 Parent.ComputeHeaderCallStatus(Codec);
@@ -729,23 +736,51 @@ namespace PepperDash.Essentials.UIDrivers.VC
 		/// <summary>
 		/// 
 		/// </summary>
-		void SetupSelfViewControls()
+		void SetupLayoutControls()
 		{
-
 			TriList.SetSigFalseAction(UIBoolJoin.VCStagingSelfViewLayoutPress, this.ShowSelfViewLayout);
 			var svc = Codec as IHasCodecSelfview;
 			if (svc != null)
 			{
 				TriList.SetSigFalseAction(UIBoolJoin.VCSelfViewTogglePress, svc.SelfviewModeToggle);
 				svc.SelfviewIsOnFeedback.LinkInputSig(TriList.BooleanInput[UIBoolJoin.VCSelfViewTogglePress]);
-
-				//TriList.SetSigFalseAction(UIBoolJoin.VCSelfViewPipTogglePress, () => { });
 			}
 			var lc = Codec as IHasCodecLayouts;
 			if (lc != null)
 			{
-				TriList.SetSigFalseAction(UIBoolJoin.VCRemoteViewTogglePress, lc.LocalLayoutToggle);
+				TriList.SetSigFalseAction(UIBoolJoin.VCLayoutTogglePress, lc.LocalLayoutToggle);
 				lc.LocalLayoutFeedback.LinkInputSig(TriList.StringInput[UIStringJoin.VCLayoutModeText]);
+
+				// attach to cisco special things to enable buttons
+				var cisco = Codec as PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.CiscoSparkCodec;
+				if (cisco != null)
+				{
+					// Cisco has min/max buttons that need special sauce
+					cisco.SharingContentIsOnFeedback.OutputChange += CiscoSharingAndPresentation_OutputChanges;
+					cisco.PresentationViewMaximizedFeedback.OutputChange += CiscoSharingAndPresentation_OutputChanges;
+
+					TriList.SetSigFalseAction(UIBoolJoin.VCMinMaxPress, cisco.MinMaxLayoutToggle);
+				}
+				 
+			}
+		}
+
+		/// <summary>
+		/// This should only be linked by cisco classes (spark initially)
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="e"></param>
+		void CiscoSharingAndPresentation_OutputChanges(object sender, EventArgs e)
+		{
+			var cisco = Codec as PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.CiscoSparkCodec;
+			if (cisco != null)
+			{
+				var sharing = cisco.SharingContentIsOnFeedback.BoolValue;
+				var maximized = cisco.PresentationViewMaximizedFeedback.BoolValue;
+				//set feedback and enables
+				TriList.BooleanInput[UIBoolJoin.VCMinMaxEnable].BoolValue = sharing;
+				TriList.BooleanInput[UIBoolJoin.VCLayoutToggleEnable].BoolValue = sharing && maximized;
+				TriList.BooleanInput[UIBoolJoin.VCMinMaxPress].BoolValue = maximized;
 			}
 		}