Merged with Development

Multiple Changes

PepperDashEssentials.sln

@@ -4,6 +4,7 @@ Microsoft Visual Studio Solution File, Format Version 10.00
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDashEssentials", "PepperDashEssentials\PepperDashEssentials.csproj", "{1BED5BA9-88C4-4365-9362-6F4B128071D3}"
 	ProjectSection(ProjectDependencies) = postProject
 		{892B761C-E479-44CE-BD74-243E9214AF13} = {892B761C-E479-44CE-BD74-243E9214AF13}
+		{9199CE8A-0C9F-4952-8672-3EED798B284F} = {9199CE8A-0C9F-4952-8672-3EED798B284F}
 		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
 	EndProjectSection
 EndProject
@@ -14,6 +15,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials Devices Common",
 		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PepperDash_Essentials_DM", "essentials-framework\Essentials DM\Essentials_DM\PepperDash_Essentials_DM.csproj", "{9199CE8A-0C9F-4952-8672-3EED798B284F}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5} = {A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -32,6 +38,10 @@ Global
 		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

PepperDashEssentials/Audio/EssentialsVolumeLevelConfig.cs

@@ -10,6 +10,7 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Devices.Common.DSP;
+using PepperDash.Essentials.DM;
 
 namespace PepperDash.Essentials
 {
@@ -33,5 +34,44 @@ namespace PepperDash.Essentials
         public string Label { get; set; }
         public int Level { get; set; }
 
+        /// <summary>
+        /// Helper to get the device associated with key - one timer.
+        /// </summary>
+        public IBasicVolumeWithFeedback GetDevice()
+        {
+            // DM output card format: deviceKey--output~number, dm8x8-1--output~4
+            var match = Regex.Match(DeviceKey, @"([-_\w]+)--(\w+)~(\d+)");
+            if (match.Success)
+            {
+                var devKey = match.Groups[1].Value;
+                var chassis = DeviceManager.GetDeviceForKey(devKey) as DmChassisController;
+                if (chassis != null)
+                {
+                    var outputNum = Convert.ToUInt32(match.Groups[3].Value);
+                    if (chassis.VolumeControls.ContainsKey(outputNum)) // should always...
+                        return chassis.VolumeControls[outputNum];
+                }
+                // No volume for some reason. We have failed as developers
+                return null;
+            }
+
+            // DSP format: deviceKey--levelName, biampTesira-1--master
+            match = Regex.Match(DeviceKey, @"([-_\w]+)--(.+)");
+            if (match.Success)
+            {
+                var devKey = match.Groups[1].Value;
+                var dsp = DeviceManager.GetDeviceForKey(devKey) as BiampTesiraForteDsp;
+                if (dsp != null)
+                {
+                    var levelTag = match.Groups[2].Value;
+                    if (dsp.LevelControlPoints.ContainsKey(levelTag)) // should always...
+                        return dsp.LevelControlPoints[levelTag];
+                }
+                // No volume for some reason. We have failed as developers
+                return null;
+            }
+
+            return null;
+        }
     }
 }

PepperDashEssentials/ControlSystem.cs

@@ -12,6 +12,9 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Fusion;
+using PepperDash.Essentials.Devices.Common;
+using PepperDash.Essentials.DM;
 using PepperDash.Essentials.Fusion;
 using PepperDash.Essentials.Room.Config;
 
@@ -219,6 +222,7 @@ namespace PepperDash.Essentials
 
                 new Core.DeviceFactory();
                 new Devices.Common.DeviceFactory();
+                new DM.DeviceFactory();
                 new DeviceFactory();
 
                 Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials load from configuration");
@@ -367,8 +371,6 @@ namespace PepperDash.Essentials
                                 devConf.Type.ToUpper(), Global.ControlSystem.ControllerPrompt.ToUpper());
 
                         // Check if the processor is a DMPS model
-                            //TODO[] This needs dealt with in the eventual plugin - 2.0 feature
-                        /*
                         if (this.ControllerPrompt.IndexOf("dmps", StringComparison.OrdinalIgnoreCase) > -1)
                         {
                             Debug.Console(2, "Adding DmpsRoutingController for {0} to Device Manager.", this.ControllerPrompt);
@@ -380,7 +382,6 @@ namespace PepperDash.Essentials
 
                             DeviceManager.AddDevice(DmpsRoutingController.GetDmpsRoutingController("processor-avRouting", this.ControllerPrompt, propertiesConfig));
                         }
-                         */
                         else if (this.ControllerPrompt.IndexOf("mpc3", StringComparison.OrdinalIgnoreCase) > -1)
                         {
                             Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");

PepperDashEssentials/PepperDashEssentials.csproj

@@ -217,6 +217,10 @@
       <Project>{892B761C-E479-44CE-BD74-243E9214AF13}</Project>
       <Name>Essentials Devices Common</Name>
     </ProjectReference>
+    <ProjectReference Include="..\essentials-framework\Essentials DM\Essentials_DM\PepperDash_Essentials_DM.csproj">
+      <Project>{9199CE8A-0C9F-4952-8672-3EED798B284F}</Project>
+      <Name>PepperDash_Essentials_DM</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
   <ProjectExtensions>

PepperDashEssentials/UIDrivers/Environment Drivers/EssentialsShadeDriver.cs

@@ -97,10 +97,10 @@ namespace PepperDash.Essentials
             {
                 TriList.SetSigFalseAction(ButtonPressJoinBase + 1, ShadeDevice.Open);
 
-                TriList.SetSigFalseAction(ButtonPressJoinBase + 2, (ShadeDevice as IShadesOpenCloseStop).Stop);
-
-                if (ShadeDevice is IShadesOpenCloseStop)
-                    TriList.SetString(StringJoinBase + 2, "Stop");
+                TriList.SetSigFalseAction(ButtonPressJoinBase + 2, (ShadeDevice as IShadesOpenCloseStop).StopOrPreset);
+
+                if(ShadeDevice is RelayControlledShade)
+                    TriList.SetString(StringJoinBase + 2, (ShadeDevice as RelayControlledShade).StopOrPresetButtonLabel);
                 
                 TriList.SetSigFalseAction(ButtonPressJoinBase + 3, ShadeDevice.Close);
             }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/VideoCodecControllerJoinMap.cs

@@ -398,6 +398,21 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
+        [JoinName("DirectoryClearSelection")]
+        public JoinDataComplete DirectoryClearSelection = new JoinDataComplete(
+            new JoinData
+            {
+                JoinNumber = 100,
+                JoinSpan = 1
+            },
+            new JoinMetadata
+            {
+                Description = "Directory Search Busy FB",
+                JoinCapabilities = eJoinCapabilities.FromSIMPL,
+                JoinType = eJoinType.Digital
+            });
+
+
 
 		[JoinName("DirectoryEntryIsContact")]
 		public JoinDataComplete DirectoryEntryIsContact = new JoinDataComplete(
@@ -525,21 +540,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
                 JoinType = eJoinType.Digital
             });
 
-        [JoinName("DirectoryClearSelected")]
-        public JoinDataComplete DirectoryClearSelected = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 110,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Clear Selected Entry and String from Search",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-
 		[JoinName("CameraTiltUp")]
 		public JoinDataComplete CameraTiltUp = new JoinDataComplete(
 			new JoinData
@@ -792,16 +792,44 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("DialMeetingStart")]
-		public JoinDataComplete DialMeetingStart = new JoinDataComplete(
+		[JoinName("DialMeeting1")]
+		public JoinDataComplete DialMeeting1 = new JoinDataComplete(
 			new JoinData
 			{
 				JoinNumber = 161,
-				JoinSpan = 10
+				JoinSpan = 1
 			},
 			new JoinMetadata
 			{
-				Description = "Join meeting",
+				Description = "Join first meeting",
+				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("DialMeeting2")]
+		public JoinDataComplete DialMeeting2 = new JoinDataComplete(
+			new JoinData
+			{
+				JoinNumber = 162,
+				JoinSpan = 1
+			},
+			new JoinMetadata
+			{
+				Description = "Join second meeting",
+				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("DialMeeting3")]
+		public JoinDataComplete DialMeeting3 = new JoinDataComplete(
+			new JoinData
+			{
+				JoinNumber = 163,
+				JoinSpan = 1
+			},
+			new JoinMetadata
+			{
+				Description = "Join third meeting",
 				JoinCapabilities = eJoinCapabilities.FromSIMPL,
 				JoinType = eJoinType.Digital
 			});

essentials-framework/Essentials Core/PepperDashEssentialsBase/DeviceTypeInterfaces/IPasswordPrompt.cs

@@ -1,56 +1,56 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-namespace PepperDash.Essentials.Core
-{
-    /// <summary>
-    /// Describes the functionality required to prompt a user to enter a password
-    /// </summary>
-    public interface IPasswordPrompt
-    {
-        /// <summary>
-        /// Notifies when a password is required or is entered incorrectly
-        /// </summary>
-        event EventHandler<PasswordPromptEventArgs> PasswordRequired;
-
-        /// <summary>
-        /// Submits the password
-        /// </summary>
-        /// <param name="password"></param>
-        void SubmitPassword(string password);
-    }
-
-    public class PasswordPromptEventArgs : EventArgs
-    {
-        /// <summary>
-        /// Indicates if the last submitted password was incorrect
-        /// </summary>
-        public bool LastAttemptWasIncorrect { get; private set; }
-
-        /// <summary>
-        /// Indicates that the login attempt has failed
-        /// </summary>
-        public bool LoginAttemptFailed { get; private set; }
-
-        /// <summary>
-        /// Indicates that the process was cancelled and the prompt should be dismissed
-        /// </summary>
-        public bool LoginAttemptCancelled { get; private set; }
-
-        /// <summary>
-        /// A message to be displayed to the user
-        /// </summary>
-        public string Message { get; private set; }
-
-        public PasswordPromptEventArgs(bool lastAttemptIncorrect, bool loginFailed, bool loginCancelled, string message)
-        {
-            LastAttemptWasIncorrect = lastAttemptIncorrect;
-            LoginAttemptFailed = loginFailed;
-            LoginAttemptCancelled = loginCancelled;
-            Message = message;
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Describes the functionality required to prompt a user to enter a password
+    /// </summary>
+    public interface IPasswordPrompt
+    {
+        /// <summary>
+        /// Notifies when a password is required or is entered incorrectly
+        /// </summary>
+        event EventHandler<PasswordPromptEventArgs> PasswordRequired;
+
+        /// <summary>
+        /// Submits the password
+        /// </summary>
+        /// <param name="password"></param>
+        void SubmitPassword(string password);
+    }
+
+    public class PasswordPromptEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Indicates if the last submitted password was incorrect
+        /// </summary>
+        public bool LastAttemptWasIncorrect { get; private set; }
+
+        /// <summary>
+        /// Indicates that the login attempt has failed
+        /// </summary>
+        public bool LoginAttemptFailed { get; private set; }
+
+        /// <summary>
+        /// Indicates that the process was cancelled and the prompt should be dismissed
+        /// </summary>
+        public bool LoginAttemptCancelled { get; private set; }
+
+        /// <summary>
+        /// A message to be displayed to the user
+        /// </summary>
+        public string Message { get; private set; }
+
+        public PasswordPromptEventArgs(bool lastAttemptIncorrect, bool loginFailed, bool loginCancelled, string message)
+        {
+            LastAttemptWasIncorrect = lastAttemptIncorrect;
+            LoginAttemptFailed = loginFailed;
+            LoginAttemptCancelled = loginCancelled;
+            Message = message;
+        }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/JoinMaps/JoinMapBase.cs

@@ -283,10 +283,9 @@ namespace PepperDash.Essentials.Core
             foreach (var join in joins)
             {
                 Debug.Console(0,
-                    @"Join Number: {0} | JoinSpan: '{1}' | JoinName: {2} | Description: '{3}' | Type: '{4}' | Capabilities: '{5}'",
+                    @"Join Number: {0} | JoinSpan: '{1}' | Description: '{2}' | Type: '{3}' | Capabilities: '{4}'",
                         join.Value.JoinNumber,
                         join.Value.JoinSpan,
-                        join.Key,
                         String.IsNullOrEmpty(join.Value.AttributeName) ? join.Value.Metadata.Label : join.Value.AttributeName,
                         join.Value.Metadata.JoinType.ToString(),
                         join.Value.Metadata.JoinCapabilities.ToString());

essentials-framework/Essentials Core/PepperDashEssentialsBase/Shades/Shade Interfaces.cs

@@ -19,7 +19,6 @@ namespace PepperDash.Essentials.Core.Shades
     /// <summary>
     /// Requirements for a device that implements basic Open/Close shade control
     /// </summary>
-    [Obsolete("Please use IShadesOpenCloseStop instead")]
     public interface IShadesOpenClose
     {
         void Open();
@@ -29,26 +28,15 @@ namespace PepperDash.Essentials.Core.Shades
     /// <summary>
     /// Requirements for a device that implements basic Open/Close/Stop shade control (Uses 3 relays)
     /// </summary>
-    public interface IShadesOpenCloseStop
-    {
-        void Open();
-        void Close();
-        void Stop();
-    }
-
-    public interface IShadesOpenClosePreset : IShadesOpenCloseStop
-    {
-        void RecallPreset(uint presetNumber);
-        void SavePreset(uint presetNumber);
-        string StopOrPresetButtonLabel { get; }
-
-        event EventHandler PresetSaved;
+    public interface IShadesOpenCloseStop : IShadesOpenClose
+    {
+        void StopOrPreset();
+        string StopOrPresetButtonLabel { get; }
     }
 
 	/// <summary>
 	/// Requirements for a shade that implements press/hold raise/lower functions
-	/// </summary>
-    [Obsolete("Please use IShadesOpenCloseStop instead")]
+	/// </summary>
 	public interface IShadesRaiseLower
 	{
 		void Raise(bool state);
@@ -67,7 +55,7 @@ namespace PepperDash.Essentials.Core.Shades
 	/// <summary>
 	/// Requirements for a shade/scene that is open or closed
 	/// </summary>
-	public interface IShadesOpenClosedFeedback: IShadesOpenCloseStop
+	public interface IShadesOpenClosedFeedback: IShadesOpenClose
 	{
 		BoolFeedback ShadeIsOpenFeedback { get; }
 		BoolFeedback ShadeIsClosedFeedback { get; }
@@ -75,16 +63,15 @@ namespace PepperDash.Essentials.Core.Shades
 
 	/// <summary>
 	/// 
-	/// </summary>
-    [Obsolete("Please use IShadesOpenCloseStop instead")]
-    public interface IShadesStop
+	/// </summary>
+	public interface IShadesStop
 	{
 		void Stop();
 	}
 
 	/// <summary>
-	/// Used to implement raise/stop/lower/stop from single button
-	/// </summary>
+	/// 
+	/// </summary>
 	public interface IShadesStopOrMove
 	{
 		void OpenOrStop();
@@ -95,7 +82,7 @@ namespace PepperDash.Essentials.Core.Shades
 	/// <summary>
 	/// Basic feedback for shades/scene stopped
 	/// </summary>
-	public interface IShadesStopFeedback : IShadesOpenCloseStop
+	public interface IShadesStopFeedback
 	{
 		BoolFeedback IsStoppedFeedback { get; }
 	}	

essentials-framework/Essentials Core/PepperDashEssentialsBase/Shades/ShadeBase.cs

@@ -12,7 +12,7 @@ namespace PepperDash.Essentials.Core.Shades
     /// <summary>
     /// Base class for a shade device
     /// </summary>
-    public abstract class ShadeBase : EssentialsDevice, IShadesOpenCloseStop
+    public abstract class ShadeBase : EssentialsDevice, IShadesOpenClose
     {
         public ShadeBase(string key, string name)
             : base(key, name)
@@ -23,7 +23,7 @@ namespace PepperDash.Essentials.Core.Shades
         #region iShadesOpenClose Members
 
         public abstract void Open();
-        public abstract void Stop();
+        public abstract void StopOrPreset();
         public abstract void Close();
 
         #endregion

essentials-framework/Essentials Devices Common/Essentials Devices Common/Codec/iHasDirectory.cs

@@ -49,6 +49,10 @@ namespace PepperDash.Essentials.Devices.Common.Codec
         Stack<CodecDirectory> DirectoryBrowseHistoryStack { get; } 
     }
 
+    public interface IHasDirectoryClearSelection : IHasDirectory
+    {
+        void DirectoryClearSelection();
+    }
 
 	/// <summary>
 	/// 

essentials-framework/Essentials Devices Common/Essentials Devices Common/DSP/BiampTesira/BiampTesiraForteDsp.cs

@@ -1 +1,396 @@
-using System;
+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.Config;
+using System.Text.RegularExpressions;
+
+
+namespace PepperDash.Essentials.Devices.Common.DSP
+{
+
+    // QUESTIONS:
+    // 
+    // When subscribing, just use the Instance ID for Custom Name?
+
+    // Verbose on subscriptions?
+
+    // Example subscription feedback responses
+    // ! "publishToken":"name" "value":-77.0
+    // ! "myLevelName" -77
+
+    public class BiampTesiraForteDsp : DspBase
+    {
+        public IBasicCommunication Communication { get; private set; }
+        public CommunicationGather PortGather { get; private set; }
+        public StatusMonitorBase CommunicationMonitor { get; private set; }
+
+        public new Dictionary<string, TesiraForteLevelControl> LevelControlPoints { get; private set; }
+
+        public bool isSubscribed;
+
+        private CTimer SubscriptionTimer;
+
+        private CrestronQueue CommandQueue;
+
+        private bool CommandQueueInProgress = false;
+
+        //new public Dictionary<string, DspControlPoint> DialerControlPoints { get; private set; }
+
+        //new public Dictionary<string, DspControlPoint> SwitcherControlPoints { get; private set; }
+
+        /// <summary>
+        /// Shows received lines as hex
+        /// </summary>
+        public bool ShowHexResponse { get; set; }
+
+        public BiampTesiraForteDsp(string key, string name, IBasicCommunication comm,
+            BiampTesiraFortePropertiesConfig props) :
+                base(key, name)
+        {
+            CommandQueue = new CrestronQueue(100);
+
+            Communication = comm;
+            var socket = comm as ISocketStatus;
+            if (socket != null)
+            {
+                // This instance uses IP control
+
+                socket.ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(socket_ConnectionChange);
+            }
+            else
+            {
+                // This instance uses RS-232 control
+            }
+            PortGather = new CommunicationGather(Communication, "\x0d\x0a");
+            PortGather.LineReceived += this.Port_LineReceived;
+            if (props.CommunicationMonitorProperties != null)
+            {
+                CommunicationMonitor = new GenericCommunicationMonitor(this, Communication,
+                    props.CommunicationMonitorProperties);
+            }
+            else
+            {
+//#warning Need to deal with this poll string
+                CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 120000, 120000, 300000,
+                    "SESSION get aliases\x0d\x0a");
+            }
+
+            LevelControlPoints = new Dictionary<string, TesiraForteLevelControl>();
+
+            foreach (KeyValuePair<string, BiampTesiraForteLevelControlBlockConfig> block in props.LevelControlBlocks)
+            {
+                this.LevelControlPoints.Add(block.Key, new TesiraForteLevelControl(block.Key, block.Value, this));
+            }
+
+        }
+
+        public override bool CustomActivate()
+        {
+            Communication.Connect();
+            CommunicationMonitor.StatusChange +=
+                (o, a) => { Debug.Console(2, this, "Communication monitor state: {0}", CommunicationMonitor.Status); };
+            CommunicationMonitor.Start();
+
+            CrestronConsole.AddNewConsoleCommand(SendLine, "send" + Key, "", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => Communication.Connect(), "con" + Key, "",
+                ConsoleAccessLevelEnum.AccessOperator);
+            return true;
+        }
+
+        private void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
+        {
+            Debug.Console(2, this, "Socket Status Change: {0}", e.Client.ClientStatus.ToString());
+
+            if (e.Client.IsConnected)
+            {
+                // Tasks on connect
+            }
+            else
+            {
+                // Cleanup items from this session
+
+                if (SubscriptionTimer != null)
+                {
+                    SubscriptionTimer.Stop();
+                    SubscriptionTimer = null;
+                }
+
+                isSubscribed = false;
+                CommandQueue.Clear();
+                CommandQueueInProgress = false;
+            }
+        }
+
+        /// <summary>
+        /// Initiates the subscription process to the DSP
+        /// </summary>
+        private void SubscribeToAttributes()
+        {
+            SendLine("SESSION set verbose true");
+
+            foreach (KeyValuePair<string, TesiraForteLevelControl> level in LevelControlPoints)
+            {
+                level.Value.Subscribe();
+            }
+
+            if (!CommandQueueInProgress)
+                SendNextQueuedCommand();
+
+            ResetSubscriptionTimer();
+        }
+
+        /// <summary>
+        /// Resets or Sets the subscription timer
+        /// </summary>
+        private void ResetSubscriptionTimer()
+        {
+            isSubscribed = true;
+
+            if (SubscriptionTimer != null)
+            {
+                SubscriptionTimer = new CTimer(o => SubscribeToAttributes(), 30000);
+                SubscriptionTimer.Reset();
+
+            }
+        }
+
+        /// <summary>
+        /// Handles a response message from the DSP
+        /// </summary>
+        /// <param name="dev"></param>
+        /// <param name="args"></param>
+        private void Port_LineReceived(object dev, GenericCommMethodReceiveTextArgs args)
+        {
+            try
+            {
+                if (args.Text.IndexOf("Welcome to the Tesira Text Protocol Server...") > -1)
+                {
+                    // Indicates a new TTP session
+
+                    SubscribeToAttributes();
+                }
+                else if (args.Text.IndexOf("publishToken") > -1)
+                {
+                    // response is from a subscribed attribute
+
+                    string pattern = "! \"publishToken\":[\"](.*)[\"] \"value\":(.*)";
+
+                    Match match = Regex.Match(args.Text, pattern);
+
+                    if (match.Success)
+                    {
+
+                        string key;
+
+                        string customName;
+
+                        string value;
+
+                        customName = match.Groups[1].Value;
+
+                        // Finds the key (everything before the '~' character
+                        key = customName.Substring(0, customName.IndexOf("~", 0) - 1);
+
+                        value = match.Groups[2].Value;
+
+                        foreach (KeyValuePair<string, TesiraForteLevelControl> controlPoint in LevelControlPoints)
+                        {
+                            if (customName == controlPoint.Value.LevelCustomName ||
+                                customName == controlPoint.Value.MuteCustomName)
+                            {
+                                controlPoint.Value.ParseSubscriptionMessage(customName, value);
+                                return;
+                            }
+
+                        }
+                    }
+
+                    /// same for dialers
+                    /// same for switchers
+
+                }
+                else if (args.Text.IndexOf("+OK") > -1)
+                {
+                    if (args.Text == "+OK" || args.Text.IndexOf("list\":") > -1)
+                        // Check for a simple "+OK" only 'ack' repsonse or a list response and ignore
+                        return;
+
+                    // response is not from a subscribed attribute.  From a get/set/toggle/increment/decrement command
+
+                    if (!CommandQueue.IsEmpty)
+                    {
+                        if (CommandQueue.Peek() is QueuedCommand)
+                        {
+                            // Expected response belongs to a child class
+                            QueuedCommand tempCommand = (QueuedCommand) CommandQueue.TryToDequeue();
+                            //Debug.Console(1, this, "Command Dequeued. CommandQueue Size: {0}", CommandQueue.Count);
+
+                            tempCommand.ControlPoint.ParseGetMessage(tempCommand.AttributeCode, args.Text);
+                        }
+                        else
+                        {
+                            // Expected response belongs to this class
+                            string temp = (string) CommandQueue.TryToDequeue();
+                            //Debug.Console(1, this, "Command Dequeued. CommandQueue Size: {0}", CommandQueue.Count);
+
+                        }
+
+                        if (CommandQueue.IsEmpty)
+                            CommandQueueInProgress = false;
+                        else
+                            SendNextQueuedCommand();
+
+                    }
+
+
+                }
+                else if (args.Text.IndexOf("-ERR") > -1)
+                {
+                    // Error response
+
+                    switch (args.Text)
+                    {
+                        case "-ERR ALREADY_SUBSCRIBED":
+                        {
+                            ResetSubscriptionTimer();
+                            break;
+                        }
+                        default:
+                        {
+                            Debug.Console(0, this, "Error From DSP: '{0}'", args.Text);
+                            break;
+                        }
+                    }
+
+                }
+            }
+            catch (Exception e)
+            {
+                if (Debug.Level == 2)
+                    Debug.Console(2, this, "Error parsing response: '{0}'\n{1}", args.Text, e);
+            }
+
+        }
+
+        /// <summary>
+        /// Sends a command to the DSP (with delimiter appended)
+        /// </summary>
+        /// <param name="s">Command to send</param>
+        public void SendLine(string s)
+        {
+            Communication.SendText(s + "\x0a");
+        }
+
+        /// <summary>
+        /// Adds a command from a child module to the queue
+        /// </summary>
+        /// <param name="command">Command object from child module</param>
+        public void EnqueueCommand(QueuedCommand commandToEnqueue)
+        {
+            CommandQueue.Enqueue(commandToEnqueue);
+            //Debug.Console(1, this, "Command (QueuedCommand) Enqueued '{0}'.  CommandQueue has '{1}' Elements.", commandToEnqueue.Command, CommandQueue.Count);
+
+            if (!CommandQueueInProgress)
+                SendNextQueuedCommand();
+        }
+
+
+        /// <summary>
+        /// Adds a raw string command to the queue
+        /// </summary>
+        /// <param name="command"></param>
+        public void EnqueueCommand(string command)
+        {
+            CommandQueue.Enqueue(command);
+            //Debug.Console(1, this, "Command (string) Enqueued '{0}'.  CommandQueue has '{1}' Elements.", command, CommandQueue.Count);
+
+            if (!CommandQueueInProgress)
+                SendNextQueuedCommand();
+        }
+
+        /// <summary>
+        /// Sends the next queued command to the DSP
+        /// </summary>
+        private void SendNextQueuedCommand()
+        {
+            //Debug.Console(2, this, "Attempting to send next queued command. CommandQueueInProgress: {0}  Communication isConnected: {1}", CommandQueueInProgress, Communication.IsConnected);
+
+            //if (CommandQueue.IsEmpty)
+            //    CommandQueueInProgress = false;
+
+            //Debug.Console(1, this, "CommandQueue has {0} Elements:\n", CommandQueue.Count);
+
+            //foreach (object o in CommandQueue)
+            //{
+            //    if (o is string)
+            //        Debug.Console(1, this, "{0}", o);
+            //    else if(o is QueuedCommand)
+            //    {
+            //        var item = (QueuedCommand)o;
+            //        Debug.Console(1, this, "{0}", item.Command);
+            //    }
+            //}
+
+            //Debug.Console(1, this, "End of CommandQueue");
+
+            if (Communication.IsConnected && !CommandQueue.IsEmpty)
+            {
+                CommandQueueInProgress = true;
+
+                if (CommandQueue.Peek() is QueuedCommand)
+                {
+                    QueuedCommand nextCommand = new QueuedCommand();
+
+                    nextCommand = (QueuedCommand) CommandQueue.Peek();
+
+                    SendLine(nextCommand.Command);
+                }
+                else
+                {
+                    string nextCommand = (string) CommandQueue.Peek();
+
+                    SendLine(nextCommand);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Sends a command to execute a preset
+        /// </summary>
+        /// <param name="name">Preset Name</param>
+        public void RunPreset(string name)
+        {
+            SendLine(string.Format("DEVICE recallPreset {0}", name));
+        }
+
+        public class QueuedCommand
+        {
+            public string Command { get; set; }
+            public string AttributeCode { get; set; }
+            public TesiraForteControlPoint ControlPoint { get; set; }
+        }
+    }
+
+    public class BiampTesiraForteDspFactory : EssentialsDeviceFactory<BiampTesiraForteDsp>
+    {
+        public BiampTesiraForteDspFactory()
+        {
+            TypeNames = new List<string>() {"biamptesira"};
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new BiampTesira Device");
+            var comm = CommFactory.CreateCommForDevice(dc);
+            var props = Newtonsoft.Json.JsonConvert.DeserializeObject<BiampTesiraFortePropertiesConfig>(
+                dc.Properties.ToString());
+            return new BiampTesiraForteDsp(dc.Key, dc.Name, comm, props);
+        }
+    }
+
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/DSP/BiampTesira/BiampTesiraForteDspLevel.cs

@@ -1 +1,379 @@
-
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using System.Text.RegularExpressions;
+
+
+namespace PepperDash.Essentials.Devices.Common.DSP
+{
+    public interface IBiampTesiraDspLevelControl : IBasicVolumeWithFeedback
+    {
+        /// <summary>
+        /// In BiAmp: Instance Tag, QSC: Named Control, Polycom: 
+        /// </summary>
+        string ControlPointTag { get; }
+        int Index1 { get; }
+        int Index2 { get; }
+        bool HasMute { get; }
+        bool HasLevel { get; }
+        bool AutomaticUnmuteOnVolumeUp { get; }
+    }
+
+    public class TesiraForteLevelControl : TesiraForteControlPoint, IBiampTesiraDspLevelControl, IKeyed
+    {
+        bool _IsMuted;
+        ushort _VolumeLevel;
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+
+        public bool Enabled { get; set; }
+        public string ControlPointTag { get { return base.InstanceTag; } }
+
+        /// <summary>
+        /// Used for to identify level subscription values
+        /// </summary>
+        public string LevelCustomName { get; private set; }
+
+        /// <summary>
+        /// Used for to identify mute subscription values
+        /// </summary>
+        public string MuteCustomName { get; private set; }
+
+        /// <summary>
+        /// Minimum fader level
+        /// </summary>
+        double MinLevel;
+
+        /// <summary>
+        /// Maximum fader level
+        /// </summary>
+        double MaxLevel;
+
+        /// <summary>
+        /// Checks if a valid subscription string has been recieved for all subscriptions
+        /// </summary>
+        public bool IsSubsribed
+        {
+            get
+            {
+                bool isSubscribed = false;
+
+                if (HasMute && MuteIsSubscribed)
+                    isSubscribed = true;
+
+                if (HasLevel && LevelIsSubscribed)
+                    isSubscribed = true;
+
+                return isSubscribed;
+            }
+        }
+
+        public bool AutomaticUnmuteOnVolumeUp { get; private set; }
+
+        public bool HasMute { get; private set; }
+
+        public bool HasLevel { get; private set; }
+
+        bool MuteIsSubscribed;
+
+        bool LevelIsSubscribed;
+
+        //public TesiraForteLevelControl(string label, string id, int index1, int index2, bool hasMute, bool hasLevel, BiampTesiraForteDsp parent)
+        //    : base(id, index1, index2, parent)
+        //{
+        //    Initialize(label, hasMute, hasLevel);
+        //}
+
+        public TesiraForteLevelControl(string key, BiampTesiraForteLevelControlBlockConfig config, BiampTesiraForteDsp parent)
+            : base(config.InstanceTag, config.Index1, config.Index2, parent)
+        {
+            Initialize(key, config.Label, config.HasMute, config.HasLevel);
+        }
+
+
+        /// <summary>
+        /// Initializes this attribute based on config values and generates subscriptions commands and adds commands to the parent's queue.
+        /// </summary>
+        public void Initialize(string key, string label, bool hasMute, bool hasLevel)
+        {
+            Key = string.Format("{0}--{1}", Parent.Key, key);
+
+            DeviceManager.AddDevice(this);
+
+            Debug.Console(2, this, "Adding LevelControl '{0}'", Key);
+
+            this.IsSubscribed = false;
+
+            MuteFeedback = new BoolFeedback(() => _IsMuted);
+
+            VolumeLevelFeedback = new IntFeedback(() => _VolumeLevel);
+
+            HasMute = hasMute;
+            HasLevel = hasLevel;
+        }
+
+        public void Subscribe()
+        {
+            // Do subscriptions and blah blah
+
+            // Subscribe to mute
+            if (this.HasMute)
+            {
+                MuteCustomName = string.Format("{0}~mute{1}", this.InstanceTag, this.Index1);
+
+                SendSubscriptionCommand(MuteCustomName, "mute", 500);
+            }
+
+            // Subscribe to level
+            if (this.HasLevel)
+            {
+                LevelCustomName = string.Format("{0}~level{1}", this.InstanceTag, this.Index1);
+
+                SendSubscriptionCommand(LevelCustomName, "level", 250);
+
+                SendFullCommand("get", "minLevel", null);
+
+                SendFullCommand("get", "maxLevel", null);
+            }
+        }
+
+
+        /// <summary>
+        /// Parses the response from the DspBase
+        /// </summary>
+        /// <param name="customName"></param>
+        /// <param name="value"></param>
+        public void ParseSubscriptionMessage(string customName, string value)
+        {
+
+            // Check for valid subscription response
+
+            if (this.HasMute && customName == MuteCustomName)
+            {
+                //if (value.IndexOf("+OK") > -1)
+                //{
+                //    int pointer = value.IndexOf(" +OK");
+
+                //    MuteIsSubscribed = true;
+
+                //    // Removes the +OK
+                //    value = value.Substring(0, value.Length - (value.Length - (pointer - 1)));
+                //}
+
+                if (value.IndexOf("true") > -1)
+                {
+                    _IsMuted = true;
+                    MuteIsSubscribed = true;
+
+                }
+                else if (value.IndexOf("false") > -1)
+                {
+                    _IsMuted = false;
+                    MuteIsSubscribed = true;
+                }
+
+                MuteFeedback.FireUpdate();
+            }
+            else if (this.HasLevel && customName == LevelCustomName)
+            {
+                //if (value.IndexOf("+OK") > -1)
+                //{
+                //    int pointer = value.IndexOf(" +OK");
+
+                //    LevelIsSubscribed = true;
+
+                //}
+
+                var _value = Double.Parse(value);
+
+                _VolumeLevel = (ushort)Scale(_value, MinLevel, MaxLevel, 0, 65535);
+
+                LevelIsSubscribed = true;
+
+                VolumeLevelFeedback.FireUpdate();
+            }
+            
+        }
+
+        /// <summary>
+        /// Parses a non subscription response
+        /// </summary>
+        /// <param name="attributeCode">The attribute code of the command</param>
+        /// <param name="message">The message to parse</param>
+        public override void ParseGetMessage(string attributeCode, string message)
+        {
+            try
+            {
+                // Parse an "+OK" message
+                string pattern = @"\+OK ""value"":(.*)";
+
+                Match match = Regex.Match(message, pattern);
+
+                if (match.Success)
+                {
+
+                    string value = match.Groups[1].Value;
+
+                    Debug.Console(1, this, "Response: '{0}' Value: '{1}'", attributeCode, value);
+
+                    if (message.IndexOf("\"value\":") > -1)
+                    {
+                        switch (attributeCode)
+                        {
+                            case "minLevel":
+                                {
+                                    MinLevel = Double.Parse(value);
+
+                                    Debug.Console(1, this, "MinLevel is '{0}'", MinLevel);
+
+                                    break;
+                                }
+                            case "maxLevel":
+                                {
+                                    MaxLevel = Double.Parse(value);
+
+                                    Debug.Console(1, this, "MaxLevel is '{0}'", MaxLevel);
+
+                                    break;
+                                }
+                            default:
+                                {
+                                    Debug.Console(2, "Response does not match expected attribute codes: '{0}'", message);
+
+                                    break;
+                                }
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Console(2, "Unable to parse message: '{0}'\n{1}", message, e);
+            }
+
+        }
+
+        /// <summary>
+        /// Turns the mute off
+        /// </summary>
+        public void MuteOff()
+        {
+            SendFullCommand("set", "mute", "false");
+        }
+
+        /// <summary>
+        /// Turns the mute on
+        /// </summary>
+        public void MuteOn()
+        {
+            SendFullCommand("set", "mute", "true");
+        }
+
+        /// <summary>
+        /// Sets the volume to a specified level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(1, this, "volume: {0}", level);
+            // Unmute volume if new level is higher than existing
+            if (level > _VolumeLevel && AutomaticUnmuteOnVolumeUp)
+                if(_IsMuted)
+                    MuteOff();
+
+            double volumeLevel = Scale(level, 0, 65535, MinLevel, MaxLevel);
+
+            SendFullCommand("set", "level", string.Format("{0:0.000000}", volumeLevel));          
+        }
+
+        /// <summary>
+        /// Toggles mute status
+        /// </summary>
+        public void MuteToggle()
+        {
+            SendFullCommand("toggle", "mute", "");
+        }
+
+        /// <summary>
+        /// Decrements volume level
+        /// </summary>
+        /// <param name="pressRelease"></param>
+        public void VolumeDown(bool pressRelease)
+        {
+            SendFullCommand("decrement", "level", "");
+        }
+
+        /// <summary>
+        /// Increments volume level
+        /// </summary>
+        /// <param name="pressRelease"></param>
+        public void VolumeUp(bool pressRelease)
+        {
+            SendFullCommand("increment", "level", "");
+
+            if (AutomaticUnmuteOnVolumeUp)
+                if (!_IsMuted)
+                    MuteOff();
+        }
+
+        ///// <summary>
+        ///// Scales the input from the input range to the output range
+        ///// </summary>
+        ///// <param name="input"></param>
+        ///// <param name="inMin"></param>
+        ///// <param name="inMax"></param>
+        ///// <param name="outMin"></param>
+        ///// <param name="outMax"></param>
+        ///// <returns></returns>
+        //int Scale(int input, int inMin, int inMax, int outMin, int outMax)
+        //{
+        //    Debug.Console(1, this, "Scaling (int) input '{0}' with min '{1}'/max '{2}' to output range min '{3}'/max '{4}'", input, inMin, inMax, outMin, outMax);
+
+        //    int inputRange = inMax - inMin;
+
+        //    int outputRange = outMax - outMin;
+
+        //    var output = (((input-inMin) * outputRange) / inputRange ) - outMin;
+
+        //    Debug.Console(1, this, "Scaled output '{0}'", output);
+
+        //    return output;
+        //}
+
+        /// <summary>
+        /// Scales the input from the input range to the output range
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="inMin"></param>
+        /// <param name="inMax"></param>
+        /// <param name="outMin"></param>
+        /// <param name="outMax"></param>
+        /// <returns></returns>
+        double Scale(double input, double inMin, double inMax, double outMin, double outMax)
+        {
+            Debug.Console(1, this, "Scaling (double) input '{0}' with min '{1}'/max '{2}' to output range min '{3}'/max '{4}'",input ,inMin ,inMax ,outMin, outMax);
+
+            double inputRange = inMax - inMin;
+
+            if (inputRange <= 0)
+            {
+                throw new ArithmeticException(string.Format("Invalid Input Range '{0}' for Scaling.  Min '{1}' Max '{2}'.", inputRange, inMin, inMax));
+            }
+
+            double outputRange = outMax - outMin;
+
+            var output = (((input - inMin) * outputRange) / inputRange) + outMin;
+
+            Debug.Console(1, this, "Scaled output '{0}'", output);
+
+            return output;
+        }
+    }
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/DSP/BiampTesira/TesiraForteControlPoint.cs

@@ -1 +1,115 @@
-
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Devices.Common.DSP
+{
+	public abstract class TesiraForteControlPoint : DspControlPoint
+	{
+        public string Key { get; protected set; }
+
+		public string InstanceTag { get; set; }
+        public int Index1 { get; private set; }
+        public int Index2 { get; private set; }
+		public BiampTesiraForteDsp Parent { get; private set; }
+
+        public bool IsSubscribed { get; protected set; }
+
+		protected TesiraForteControlPoint(string id, int index1, int index2,  BiampTesiraForteDsp parent)
+		{
+			InstanceTag = id;
+			Index1 = index1;
+            Index2 = index2;
+			Parent = parent;
+		}
+
+        virtual public void Initialize()
+        {
+        }
+
+        /// <summary>
+        /// Sends a command to the DSP
+        /// </summary>
+        /// <param name="command">command</param>
+        /// <param name="attribute">attribute code</param>
+        /// <param name="value">value (use "" if not applicable)</param>
+		public virtual void SendFullCommand(string command, string attributeCode, string value)
+		{
+			// Command Format: InstanceTag get/set/toggle/increment/decrement/subscribe/unsubscribe attributeCode [index] [value]
+			// Ex: "RoomLevel set level 1.00"
+
+            string cmd;
+
+            if (attributeCode == "level" || attributeCode == "mute" || attributeCode == "minLevel" || attributeCode == "maxLevel" || attributeCode == "label" || attributeCode == "rampInterval" || attributeCode == "rampStep")
+            {
+                //Command requires Index
+
+                if (String.IsNullOrEmpty(value))
+                {
+                    // format command without value
+                    cmd = string.Format("{0} {1} {2} {3}", InstanceTag, command, attributeCode, Index1);
+                }
+                else
+                {
+                    // format commadn with value
+                    cmd = string.Format("{0} {1} {2} {3} {4}", InstanceTag, command, attributeCode, Index1, value);
+                }
+
+            }
+            else
+            {
+                //Command does not require Index
+
+                if (String.IsNullOrEmpty(value))
+                {
+                    cmd = string.Format("{0} {1} {2} {3}", InstanceTag, command, attributeCode, value);
+                }
+                else
+                {
+                    cmd = string.Format("{0} {1} {2}", InstanceTag, command, attributeCode);
+                }
+            }
+
+            if (command == "get")
+            {
+                // This command will generate a return value response so it needs to be queued
+                Parent.EnqueueCommand(new BiampTesiraForteDsp.QueuedCommand{ Command = cmd, AttributeCode = attributeCode, ControlPoint = this });
+            }
+            else
+            {
+                // This command will generate a simple "+OK" response and doesn't need to be queued
+                Parent.SendLine(cmd);
+            }
+
+		}
+
+        virtual public void ParseGetMessage(string attributeCode, string message)
+        {
+        }
+
+
+
+        public virtual void SendSubscriptionCommand(string customName, string attributeCode, int responseRate)
+        {
+            // Subscription string format: InstanceTag subscribe attributeCode Index1 customName responseRate
+            // Ex: "RoomLevel subscribe level 1 MyRoomLevel 500"
+
+            string cmd;
+
+            if (responseRate > 0)
+            {
+                cmd = string.Format("{0} subscribe {1} {2} {3} {4}", InstanceTag, attributeCode, Index1, customName, responseRate);
+            }
+            else
+            {
+                cmd = string.Format("{0} subscribe {1} {2} {3}", InstanceTag, attributeCode, Index1, customName);
+            }
+
+            Parent.SendLine(cmd);
+        }
+
+        
+	}
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/Environment/Somfy/RelayControlledShade.cs

@@ -56,9 +56,9 @@ namespace PepperDash.Essentials.Devices.Common.Environment.Somfy
             PulseOutput(OpenRelay, RelayPulseTime);
         }
 
-        public override void Stop()
+        public override void StopOrPreset()
         {
-            Debug.Console(1, this, "Stopping Shade: '{0}'", this.Name);
+            Debug.Console(1, this, "Stopping or recalling preset on Shade: '{0}'", this.Name);
 
             PulseOutput(StopOrPresetRelay, RelayPulseTime);
         }

essentials-framework/Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj

@@ -185,7 +185,6 @@
     <Compile Include="VideoCodec\MockVC\MockVC.cs" />
     <Compile Include="VideoCodec\CiscoCodec\xStatus.cs" />
     <Compile Include="VideoCodec\VideoCodecBase.cs" />
-    <Compile Include="VideoCodec\ZoomRoom\IZoomWirelessShareInstructions.cs" />
     <Compile Include="VideoCodec\ZoomRoom\ResponseObjects.cs" />
     <Compile Include="VideoCodec\ZoomRoom\ZoomRoom.cs" />
     <Compile Include="VideoCodec\ZoomRoom\ZoomRoomCamera.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs

@@ -26,7 +26,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 	public enum eExternalSourceType {camera, desktop, document_camera, mediaplayer, PC, whiteboard, other}
 	public enum eExternalSourceMode {Ready, NotReady, Hidden, Error}
 
-    public class CiscoSparkCodec : VideoCodecBase, IHasCallHistory, IHasCallFavorites, IHasDirectory,
+    public class CiscoSparkCodec : VideoCodecBase, IHasCallHistory, IHasCallFavorites, IHasDirectoryClearSelection,
         IHasScheduleAwareness, IOccupancyStatusProvider, IHasCodecLayouts, IHasCodecSelfView,
         ICommunicationMonitor, IRouting, IHasCodecCameras, IHasCameraAutoMode, IHasCodecRoomPresets, 
         IHasExternalSourceSwitching, IHasBranding, IHasCameraOff, IHasCameraMute, IHasDoNotDisturbMode,
@@ -493,6 +493,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 			TieLineCollection.Default.Add(tl);
 		}
 
+        public void DirectoryClearSelection()
+        {
+            DirectoryClearSelectionBase();
+        }
+
         public void InitializeBranding(string roomKey)
         {
             Debug.Console(1, this, "Initializing Branding for room {0}", roomKey);

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/Interfaces/IHasMeetingInfo.cs

@@ -43,12 +43,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Interfaces
         [JsonProperty("isLocked", NullValueHandling = NullValueHandling.Ignore)]
         public Boolean IsLocked { get; private set; }
         [JsonProperty("isRecording", NullValueHandling = NullValueHandling.Ignore)]
-        public Boolean IsRecording { get; private set; }
-        [JsonProperty("canRecord", NullValueHandling = NullValueHandling.Ignore)]
-        public Boolean CanRecord { get; private set; }
+        public Boolean IsRecording { get; private set; }
 
 
-        public MeetingInfo(string id, string name, string host, string password, string shareStatus, bool isHost, bool isSharingMeeting, bool waitingForHost, bool isLocked, bool isRecording, bool canRecord)
+        public MeetingInfo(string id, string name, string host, string password, string shareStatus, bool isHost, bool isSharingMeeting, bool waitingForHost, bool isLocked, bool isRecording)
         {
             Id = id;
             Name = name;
@@ -59,8 +57,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Interfaces
             IsSharingMeeting = isSharingMeeting;
             WaitingForHost = waitingForHost;
             IsLocked = isLocked;
-            IsRecording = isRecording;
-            CanRecord = CanRecord;
+            IsRecording = isRecording;
         }
     }
 

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/Interfaces/IHasPresentationOnlyMeeting.cs

@@ -3,9 +3,9 @@
     public interface IHasPresentationOnlyMeeting
     {
         void StartSharingOnlyMeeting();
-        void StartSharingOnlyMeeting(eSharingMeetingMode displayMode);
-        void StartSharingOnlyMeeting(eSharingMeetingMode displayMode, uint duration);
-        void StartSharingOnlyMeeting(eSharingMeetingMode displayMode, uint duration, string password);
+        void StartSharingOnlyMeeting(eSharingMeetingMode mode);
+        void StartSharingOnlyMeeting(eSharingMeetingMode mode, ushort duration);
+        void StartSharingOnlyMeeting(eSharingMeetingMode mode, ushort duration, string password);
         void StartNormalMeetingFromSharingOnlyMeeting();
     }
 

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/VideoCodecBase.cs

@@ -224,8 +224,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				handler(this, new CodecCallStatusItemChangeEventArgs(item));
 			}
 
-            PrivacyModeIsOnFeedback.FireUpdate();
-
 			if (AutoShareContentWhileInCall)
 			{
 				StartSharing();
@@ -811,22 +809,35 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			    codec.CodecSchedule.MeetingWarningMinutes = i;
 			});
 
-
-            for (uint i = 0; i < joinMap.DialMeetingStart.JoinSpan; i++)
-            {
-                Debug.Console(1, this, "Setting action to Dial Meeting {0} to digital join {1}", i + 1, joinMap.DialMeetingStart.JoinNumber + i);
-                var joinNumber = joinMap.DialMeetingStart.JoinNumber + i;
-                var mtg = i + 1;
-                var index = (int)i;
-
-                trilist.SetSigFalseAction(joinNumber, () =>
-                {
-                    Debug.Console(1, this, "Meeting {0} Selected (EISC dig-o{1}) > _currentMeetings[{2}].Id: {3}, Title: {4}",
-                        mtg, joinMap.DialMeetingStart.JoinNumber + i, index, _currentMeetings[index].Id, _currentMeetings[index].Title);
-                    if (_currentMeetings[index] != null)
-                        Dial(_currentMeetings[index]);
-                });
-            }
+			trilist.SetSigFalseAction(joinMap.DialMeeting1.JoinNumber, () =>
+			{
+				var mtg = 1;
+				var index = mtg - 1;
+				Debug.Console(1, this, "Meeting {0} Selected (EISC dig-o{1}) > _currentMeetings[{2}].Id: {3}, Title: {4}",
+					mtg, joinMap.DialMeeting1.JoinNumber, index, _currentMeetings[index].Id, _currentMeetings[index].Title);
+				if (_currentMeetings[index] != null)
+					Dial(_currentMeetings[index]);
+			});
+			
+			trilist.SetSigFalseAction(joinMap.DialMeeting2.JoinNumber, () =>
+			{
+				var mtg = 2;
+				var index = mtg - 1;
+				Debug.Console(1, this, "Meeting {0} Selected (EISC dig-o{1}) > _currentMeetings[{2}].Id: {3}, Title: {4}",
+					mtg, joinMap.DialMeeting2.JoinNumber, index, _currentMeetings[index].Id, _currentMeetings[index].Title);
+				if (_currentMeetings[index] != null)
+					Dial(_currentMeetings[index]);
+			});
+			
+			trilist.SetSigFalseAction(joinMap.DialMeeting3.JoinNumber, () =>
+			{
+				var mtg = 3;
+				var index = mtg - 1;
+				Debug.Console(1, this, "Meeting {0} Selected (EISC dig-o{1}) > _currentMeetings[{2}].Id: {3}, Title: {4}",
+					mtg, joinMap.DialMeeting3.JoinNumber, index, _currentMeetings[index].Id, _currentMeetings[index].Title);
+				if (_currentMeetings[index] != null)
+					Dial(_currentMeetings[index]);
+			});
 
 			codec.CodecSchedule.MeetingsListHasChanged += (sender, args) => UpdateMeetingsList(codec, trilist, joinMap);
 			codec.CodecSchedule.MeetingEventChange += (sender, args) =>
@@ -837,6 +848,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 					}
 				};
 
+            // TODO [ ] hotfix/videocodecbase-max-meeting-xsig-set
             trilist.SetUShortSigAction(joinMap.MeetingsToDisplay.JoinNumber, m => MeetingsToDisplay = m);
             MeetingsToDisplayFeedback.LinkInputSig(trilist.UShortInput[joinMap.MeetingsToDisplay.JoinNumber]);
 
@@ -951,6 +963,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                 tokenArray[stringIndex + 5] = new XSigSerialToken(stringIndex + 6, meeting.EndTime.ToString(_timeFormatSpecifier.NullIfEmpty() ?? "t", Global.Culture));
 		        tokenArray[stringIndex + 6] = new XSigSerialToken(stringIndex + 7, meeting.Id);
 
+
 		        digitalIndex += maxDigitals;
 		        meetingIndex += offset;
 		        stringIndex += maxStrings;
@@ -982,6 +995,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 	        return GetXSigString(tokenArray);
         }
 
+	    protected void DirectoryClearSelectionBase()
+	    {
+	        SelectDirectoryEntry(_directoryCodec, 0, _directoryTrilist, _directoryJoinmap);
+	    }
 
 		private void LinkVideoCodecDirectoryToApi(IHasDirectory codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
@@ -993,8 +1010,15 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			trilist.SetUShortSigAction(joinMap.DirectorySelectRow.JoinNumber, (i) => SelectDirectoryEntry(codec, i, trilist, joinMap));
 
             //Special Change for protected directory clear
+		    _directoryCodec = codec as IHasDirectoryClearSelection;
+
+		    if (_directoryCodec != null)
+		    {
+		        _directoryTrilist = trilist;
+		        _directoryJoinmap = joinMap;
+		        trilist.SetBoolSigAction(joinMap.DirectoryClearSelection.JoinNumber, (b) =>  DirectoryClearSelectionBase());
+		    }
 
-            trilist.SetBoolSigAction(joinMap.DirectoryClearSelected.JoinNumber, (b) => SelectDirectoryEntry(_directoryCodec, 0, _directoryTrilist, _directoryJoinmap));
 
 		    // Report feedback for number of contact methods for selected contact
 
@@ -1184,49 +1208,51 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
             return GetXSigString(tokenArray);
         }
 
-	    private string UpdateDirectoryXSig(CodecDirectory directory, bool isRoot)
-	    {
-	        var xSigMaxIndex = 1023;
-	        var tokenArray = new XSigToken[directory.CurrentDirectoryResults.Count > xSigMaxIndex
-	            ? xSigMaxIndex
-	            : directory.CurrentDirectoryResults.Count];
+		private string UpdateDirectoryXSig(CodecDirectory directory, bool isRoot)
+		{
+            const int xSigMaxIndex = 1023;
+            var tokenArray = new XSigToken[directory.CurrentDirectoryResults.Count > xSigMaxIndex
+                ? xSigMaxIndex
+                : directory.CurrentDirectoryResults.Count];
 
-	        Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot,
-	            directory.CurrentDirectoryResults.Count, tokenArray.Length);
+            Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot, directory.CurrentDirectoryResults.Count, tokenArray.Length);
 
-	        var contacts = directory.CurrentDirectoryResults.Count > xSigMaxIndex
-	            ? directory.CurrentDirectoryResults.Take(xSigMaxIndex)
-	            : directory.CurrentDirectoryResults;
+            var contacts = directory.CurrentDirectoryResults.Count > xSigMaxIndex
+                ? directory.CurrentDirectoryResults.Take(xSigMaxIndex)
+                : directory.CurrentDirectoryResults;
 
-	        var counterIndex = 1;
-	        foreach (var entry in contacts)
-	        {
-	            var arrayIndex = counterIndex - 1;
-	            var entryIndex = counterIndex;
+            var contactsToDisplay = isRoot
+                ? contacts.Where(c => c.ParentFolderId == "root")
+                : contacts.Where(c => c.ParentFolderId != "root");
 
-	            Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}", entry.Name, entry.FolderId, entryIndex);
+            var counterIndex = 1;
+            foreach (var entry in contactsToDisplay)
+            {
+                var arrayIndex = counterIndex - 1;
+                var entryIndex = counterIndex;
 
-	            if (entry is DirectoryFolder && entry.ParentFolderId == "root")
-	            {
-	                tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, String.Format("[+] {0}", entry.Name));
+                Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}, Type: {3}, ParentFolderId: {4}",
+                    entry.Name, entry.FolderId, entryIndex, entry.GetType().GetCType().FullName, entry.ParentFolderId);
 
-	                counterIndex++;
-	                counterIndex++;
+                if (entry is DirectoryFolder)
+                {
+                    tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, String.Format("[+] {0}", entry.Name));
 
-	                continue;
-	            }
+                    counterIndex++;
 
-	            tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, entry.Name);
+                    continue;
+                }
 
-	            counterIndex++;
-	        }
+                tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, entry.Name);
 
-	        return GetXSigString(tokenArray);
+                counterIndex++;
+            }
 
+            return GetXSigString(tokenArray);
 
 		}
 
-	    private void LinkVideoCodecCallControlsToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
+		private void LinkVideoCodecCallControlsToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
 			trilist.SetSigFalseAction(joinMap.ManualDial.JoinNumber,
 				() => Dial(trilist.StringOutput[joinMap.CurrentDialString.JoinNumber].StringValue));
@@ -1393,11 +1419,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                 tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, call.IsOnHold);
 
 				//serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
+				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
+				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
+				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
+				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
+				tokenArray[arrayIndex + 5] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
                 if(call.Duration != null)
                 {
                     // May need to verify correct string format here
@@ -1407,9 +1433,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;
-                digitalIndex += maxDigitals;
+				digitalIndex++;
 			}
-            while (arrayIndex < maxCalls * offset)
+			while (digitalIndex < maxCalls)
 			{
 				//digitals
                 tokenArray[digitalIndex] = new XSigDigitalToken(digitalIndex + 1, false);
@@ -1417,16 +1443,16 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 
                 //serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
-                tokenArray[arrayIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
+				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 1, String.Empty);
+				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 2, String.Empty);
+				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 3, String.Empty);
+				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 4, String.Empty);
+				tokenArray[arrayIndex + 5] = new XSigSerialToken(stringIndex + 5, String.Empty);
+                tokenArray[arrayIndex + 6] = new XSigSerialToken(stringIndex + 6, String.Empty);
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;
-				digitalIndex += maxDigitals;
+				digitalIndex++;
 			}
 
 			return GetXSigString(tokenArray);

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/IZoomWirelessShareInstructions.cs

@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using PepperDash.Essentials.Core;
-
-using PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom;
-
-namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
-{
-    public class ShareInfoEventArgs : EventArgs
-    {
-        public zStatus.Sharing SharingStatus { get; private set; }
-
-        public ShareInfoEventArgs(zStatus.Sharing status)
-        {
-            SharingStatus = status;
-        }
-    }
-
-    public interface IZoomWirelessShareInstructions
-    {
-        event EventHandler<ShareInfoEventArgs> ShareInfoChanged;
-
-        zStatus.Sharing SharingState { get; }
-    }
-}

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ResponseObjects.cs

@@ -434,21 +434,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			public bool supports_Web_Settings_Push { get; set; }
 		}
 
-        public enum eDisplayState
-        {
-            None,
-            Laptop,
-            IOS,
-        }
-
 		public class Sharing : NotifiableObject
 		{
-            private eDisplayState _dispState;
+			private string _dispState;
 			private string _password;
             private bool _isAirHostClientConnected;
             private bool _isSharingBlackMagic;
             private bool _isDirectPresentationConnected;
-            private bool _isBlackMagicConnected;
 
 
 			public string directPresentationPairingCode { get; set; }
@@ -456,7 +448,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			/// Laptop client sharing key
 			/// </summary>
 			public string directPresentationSharingKey { get; set; }
-            public eDisplayState dispState
+			public string dispState
 			{
 				get
 				{
@@ -485,18 +477,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 }
             }
 
-			public bool isBlackMagicConnected
-            {
-                get { return _isBlackMagicConnected; }
-                set
-                {
-                    if (value != _isBlackMagicConnected)
-                    {
-                        _isBlackMagicConnected = value;
-                        NotifyPropertyChanged("isBlackMagicConnected");
-                    }
-                }
-            }
+			public bool isBlackMagicConnected { get; set; }
 			public bool isBlackMagicDataAvailable { get; set; }
 
 			public bool isDirectPresentationConnected
@@ -525,6 +506,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 }
             }
 
+
+
 			/// <summary>
 			/// IOS Airplay code
 			/// </summary>
@@ -639,7 +622,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			// backer variables
 			private bool _can_Switch_Speaker_View;
 			private bool _can_Switch_Wall_View;
-            private bool _can_Switch_Strip_View;
 			private bool _can_Switch_Share_On_All_Screens;
             private bool _can_Switch_Floating_Share_Content;
 			private bool _is_In_First_Page;
@@ -727,23 +709,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 				}
 			}
 
-            [JsonProperty("can_Switch_Strip_View")]
-            public bool can_Switch_Strip_View
-            {
-                get
-                {
-                    return _can_Switch_Strip_View;
-                }
-                set
-                {
-                    if (value != _can_Switch_Strip_View)
-                    {
-                        _can_Switch_Strip_View = value;
-                        NotifyPropertyChanged("can_Switch_Strip_View");
-                    }
-                }
-            }
-
 			[JsonProperty("is_In_First_Page")]
 			public bool is_In_First_Page
 			{
@@ -805,43 +770,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		public class CallRecordInfo : NotifiableObject
 		{
             private bool _meetingIsBeingRecorded;
-            private bool _canRecord;
-            private bool _emailRequired;
 
+			public bool canRecord { get; set; }
+			public bool emailRequired { get; set; }
 			public bool amIRecording { get; set; }
 
-            public bool canRecord
-            {
-                get
-                {
-                    return _canRecord;
-                }
-                set
-                {
-                    if (value != _canRecord)
-                    {
-                        _canRecord = value;
-                        NotifyPropertyChanged("canRecord");
-                    }
-                }
-            }
-
-            public bool emailRequired
-            {
-                get
-                {
-                    return _emailRequired;
-                }
-                set
-                {
-                    if (value != _emailRequired)
-                    {
-                        _emailRequired = value;
-                        NotifyPropertyChanged("emailRequired");
-                    }
-                }
-            }
-
 			public bool meetingIsBeingRecorded 
             {
                 get
@@ -860,17 +793,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 }
             }
 
-            /// <summary>
-            /// Indicates if recording is allowed (when meeting capable and and email is not required to be entered by the user)
-            /// </summary>
-            public bool AllowRecord
-            {
-                get
-                {
-                    return canRecord && !emailRequired;
-                }
-            }
-
             public CallRecordInfo()
             {
                 Debug.Console(2, Debug.ErrorLogLevel.Notice, "********************************************* CallRecordInfo() ******************************************");

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoom.cs

@@ -27,7 +27,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
         IHasScheduleAwareness, IHasCodecCameras, IHasParticipants, IHasCameraOff, IHasCameraMuteWithUnmuteReqeust, IHasCameraAutoMode,
 		IHasFarEndContentStatus, IHasSelfviewPosition, IHasPhoneDialing, IHasZoomRoomLayouts, IHasParticipantPinUnpin,
 		IHasParticipantAudioMute, IHasSelfviewSize, IPasswordPrompt, IHasStartMeeting, IHasMeetingInfo, IHasPresentationOnlyMeeting,
-        IHasMeetingLock, IHasMeetingRecordingWithPrompt, IZoomWirelessShareInstructions
+        IHasMeetingLock, IHasMeetingRecordingWithPrompt
 	{
         public event EventHandler VideoUnmuteRequested;
 
@@ -47,7 +47,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
         private const string JsonDelimiter = "\x0D\x0A\x7D\x0D\x0A";
 
         private string[] Delimiters = new string[] { EchoDelimiter, JsonDelimiter, "OK\x0D\x0A", "end\x0D\x0A" };
+        //"echo off\x0D\x0A\x0A\x0D\x0A"
 		private readonly GenericQueue _receiveQueue;
+		//private readonly CrestronQueue<string> _receiveQueue;
+
+
+		//private readonly Thread _receiveThread;
 
 		private readonly ZoomRoomSyncState _syncState;
 		public bool CommDebuggingIsOn;
@@ -59,18 +64,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		private CameraBase _selectedCamera;
         private string _lastDialedMeetingNumber;
 
-
 		private readonly ZoomRoomPropertiesConfig _props;
 
-		private bool _meetingPasswordRequired;
-
-		public void Poll(string pollString)
-		{
-			if(_meetingPasswordRequired) return;
-			
-			SendText(string.Format("{0}{1}", pollString, SendDelimiter));
-		}
-
 		public ZoomRoom(DeviceConfig config, IBasicCommunication comm)
 			: base(config)
 		{
@@ -84,12 +79,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			if (_props.CommunicationMonitorProperties != null)
 			{
-				CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, _props.CommunicationMonitorProperties.PollInterval, _props.CommunicationMonitorProperties.TimeToWarning, _props.CommunicationMonitorProperties.TimeToError,
-					() => Poll(_props.CommunicationMonitorProperties.PollString));
+				CommunicationMonitor = new GenericCommunicationMonitor(this, Communication,
+					_props.CommunicationMonitorProperties);
 			}
 			else
 			{
-				CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000, () => Poll("zStatus SystemUnit"));
+				CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000,
+					"zStatus SystemUnit" + SendDelimiter);
 			}
 
 			DeviceManager.AddDevice(CommunicationMonitor);
@@ -218,23 +214,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		protected override Func<bool> PrivacyModeIsOnFeedbackFunc
 		{
-            get
-            {
-                return () =>
-                    {
-                        //Debug.Console(2, this, "PrivacyModeIsOnFeedbackFunc. IsInCall: {0} muteState: {1}", IsInCall, Configuration.Call.Microphone.Mute);
-                        if (IsInCall)
-                        {
-                            //Debug.Console(2, this, "reporting muteState: ", Configuration.Call.Microphone.Mute);
-                            return Configuration.Call.Microphone.Mute;
-                        }
-                        else
-                        {
-                            //Debug.Console(2, this, "muteState: true", IsInCall);
-                            return false;
-                        }
-                    };
-            }
+			get { return () => Configuration.Call.Microphone.Mute; }
 		}
 
 		protected override Func<bool> StandbyIsOnFeedbackFunc
@@ -244,23 +224,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		protected override Func<string> SharingSourceFeedbackFunc
 		{
-            get
-            {
-                return () =>
-                    {
-                        if (Status.Sharing.isAirHostClientConnected)
-                            return "Airplay";
-                        else if (Status.Sharing.isDirectPresentationConnected || Status.Sharing.isBlackMagicConnected)
-                            return "Laptop";
-                        else return "None";
-
-                    };
-            }
+			get { return () => Status.Sharing.dispState; }
 		}
 
 		protected override Func<bool> SharingContentIsOnFeedbackFunc
 		{
-            get { return () => Status.Sharing.isAirHostClientConnected || Status.Sharing.isDirectPresentationConnected || Status.Sharing.isSharingBlackMagic; }
+			get { return () => Status.Call.Sharing.IsSharing; }
 		}
 
 		protected Func<bool> FarEndIsSharingContentFeedbackFunc
@@ -537,9 +506,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
         /// </summary>
 		private void SetUpCallFeedbackActions()
 		{
-            Status.Sharing.PropertyChanged -= HandleSharingStateUpdate;
-            Status.Sharing.PropertyChanged += HandleSharingStateUpdate;
-
             Status.Call.Sharing.PropertyChanged -= HandleSharingStateUpdate;
             Status.Call.Sharing.PropertyChanged += HandleSharingStateUpdate;
 
@@ -552,7 +518,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         private void HandleCallRecordInfoStateUpdate(object sender, PropertyChangedEventArgs a)
         {
-            if (a.PropertyName == "meetingIsBeingRecorded" || a.PropertyName == "emailRequired" || a.PropertyName == "canRecord")
+            if (a.PropertyName == "meetingIsBeingRecorded")
             {
                 MeetingIsRecordingFeedback.FireUpdate();
 
@@ -565,7 +531,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                     MeetingInfo.IsSharingMeeting,
                     MeetingInfo.WaitingForHost,
                     MeetingIsLockedFeedback.BoolValue,
-                    MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                    MeetingIsRecordingFeedback.BoolValue);
                 MeetingInfo = meetingInfo;
             }
         }
@@ -591,10 +557,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 	    private void HandleSharingStateUpdate(object sender, PropertyChangedEventArgs a)
 	    {
-            //if (a.PropertyName != "State")
-            //{
-            //    return;
-            //}
+            if (a.PropertyName != "State")
+            {
+                return;
+            }
 
             SharingContentIsOnFeedback.FireUpdate();
             ReceivingContent.FireUpdate();
@@ -604,19 +570,21 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 // Update the share status of the meeting info
                 if (MeetingInfo == null)
                 {
-                    MeetingInfo = new MeetingInfo("", "", "", "", GetSharingStatus(), GetIsHostMyself(), true, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                    var sharingStatus = GetSharingStatus();
+
+                    MeetingInfo = new MeetingInfo("", "", "", "", sharingStatus, GetIsHostMyself(), true, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
                     return;
                 }
 
                 var meetingInfo = new MeetingInfo(MeetingInfo.Id, MeetingInfo.Name, Participants.Host != null ? Participants.Host.Name : "None",
-                    MeetingInfo.Password, GetSharingStatus(), GetIsHostMyself(), MeetingInfo.IsSharingMeeting, MeetingInfo.WaitingForHost, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                    MeetingInfo.Password, GetSharingStatus(), GetIsHostMyself(), MeetingInfo.IsSharingMeeting, MeetingInfo.WaitingForHost, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
                 MeetingInfo = meetingInfo;
             }
             catch (Exception e)
             {
                 Debug.Console(1, this, "Error processing state property update. {0}", e.Message);
                 Debug.Console(2, this, e.StackTrace);
-                MeetingInfo = new MeetingInfo("", "", "", "", "None", false, false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, false);
+                MeetingInfo = new MeetingInfo("", "", "", "", "None", false, false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
             }
 	    }
 
@@ -723,7 +691,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                                 MeetingInfo.IsSharingMeeting, 
                                 MeetingInfo.WaitingForHost, 
                                 MeetingIsLockedFeedback.BoolValue,
-                                MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord
+                                MeetingIsRecordingFeedback.BoolValue
                             );
                     }
                 };
@@ -759,12 +727,15 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			Status.Sharing.PropertyChanged += (o, a) =>
 			{
-                OnShareInfoChanged(Status.Sharing);
-                SharingSourceFeedback.FireUpdate();
 				switch (a.PropertyName)
 				{
+					case "dispState":
+						SharingSourceFeedback.FireUpdate();
+						break;
 					case "password":
 						break;
+                    case "isAirHostClientConnected":
+                    case "isDirectPresentationConnected":
                     case "isSharingBlackMagic":
                         {
                             Debug.Console(2, this, "Updating sharing status: {0}", a.PropertyName);
@@ -785,7 +756,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                                 MeetingInfo.IsSharingMeeting, 
                                 MeetingInfo.WaitingForHost, 
                                 MeetingIsLockedFeedback.BoolValue,
-                                MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                MeetingIsRecordingFeedback.BoolValue);
                             MeetingInfo = meetingInfo;
                             break;
                         }
@@ -819,10 +790,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 				Debug.Console(1, this, "Status.Layout.PropertyChanged a.PropertyName: {0}", a.PropertyName);
 				switch (a.PropertyName.ToLower())
 				{
-					case "can_Switch_speaker_view":
+					case "can_switch_speaker_view":
 					case "can_switch_wall_view":
-                    case "can_switch_strip_view":
-                    case "video_type":
 					case "can_switch_share_on_all_screens":
 					{
 						ComputeAvailableLayouts();
@@ -838,7 +807,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 						LayoutViewIsOnLastPageFeedback.FireUpdate();
 						break;
 					}
-                    case "can_switch_floating_share_content":
+                    case "can_Switch_Floating_Share_Content":
                     {
                         CanSwapContentWithThumbnailFeedback.FireUpdate();
                         break;
@@ -1479,15 +1448,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                                     MeetingInfo.Id, 
                                     MeetingInfo.Name, 
                                     Participants.Host.Name, 
-                                    MeetingInfo.Password,
-                                    GetSharingStatus(), 
+                                    MeetingInfo.Password, 
+                                    MeetingInfo.ShareStatus, 
                                     GetIsHostMyself(), 
                                     MeetingInfo.IsSharingMeeting, 
                                     MeetingInfo.WaitingForHost, 
                                     MeetingIsLockedFeedback.BoolValue,
-                                    MeetingIsRecordingFeedback.BoolValue,
-                                    Status.Call.CallRecordInfo.AllowRecord
-                                    );
+                                    MeetingIsRecordingFeedback.BoolValue);
                                 MeetingInfo = meetingInfo;
 
 								PrintCurrentCallParticipants();
@@ -1572,7 +1539,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 							{
 								JsonConvert.PopulateObject(responseObj.ToString(), Status.Call.Sharing);
 
-								SetDefaultLayout();
+								SetLayout();
 
 								break;
 							}
@@ -1702,14 +1669,14 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 							        if (MeetingInfo == null)
 							        {
 							            MeetingInfo = new MeetingInfo("Waiting For Host", "Waiting For Host", "Waiting For Host", "",
-                                            GetSharingStatus(), false, false, true, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                            GetSharingStatus(), false, false, true, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
 
                                         UpdateCallStatus();
 							            break;
 							        }
 
                                     MeetingInfo = new MeetingInfo("Waiting For Host", "Waiting For Host", "Waiting For Host", "",
-                                        GetSharingStatus(), false, false, true, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                        GetSharingStatus(), false, false, true, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
 
 							        UpdateCallStatus();
 
@@ -1719,12 +1686,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 							    if (MeetingInfo == null)
 							    {
 							        MeetingInfo = new MeetingInfo("Waiting For Host", "Waiting For Host", "Waiting For Host", "",
-                                        GetSharingStatus(), false, false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                        GetSharingStatus(), false, false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
 							        break;
 							    }
 
 							    MeetingInfo = new MeetingInfo(MeetingInfo.Id, MeetingInfo.Name, MeetingInfo.Host, MeetingInfo.Password,
-                                    GetSharingStatus(), GetIsHostMyself(), false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                    GetSharingStatus(), GetIsHostMyself(), false, false, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
 
 							    break;
 							}
@@ -1814,7 +1781,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 						        if (result.Success)
 						        {
-                                    MeetingInfo = new MeetingInfo("", "", "", "", GetSharingStatus(), true, true, MeetingInfo.WaitingForHost, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord);
+                                    MeetingInfo = new MeetingInfo("", "", "", "", "", true, true, MeetingInfo.WaitingForHost, MeetingIsLockedFeedback.BoolValue, MeetingIsRecordingFeedback.BoolValue);
 						            break;
 						        }
 
@@ -1948,7 +1915,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			}
 		}
 
-		private void SetDefaultLayout()
+		private void SetLayout()
 		{
 			if (!_props.AutoDefaultLayouts) return;
 
@@ -1961,13 +1928,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			}
 			else
 			{
-                if (_props.DefaultCallLayout == (_props.DefaultCallLayout & AvailableLayouts))
-                {
-                    SendText(String.Format("zconfiguration call layout style: {0}",
-                        _props.DefaultCallLayout));
-                }
-                else
-                    Debug.Console(0, this, "Unable to set default Layout.  {0} not currently an available layout based on meeting state", _props.DefaultCallLayout);
+				SendText(String.Format("zconfiguration call layout style: {0}",
+					_props.DefaultCallLayout));
 			}
 		}
 
@@ -2000,8 +1962,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		/// </summary>
 		private void GetBookings()
 		{
-			if (_meetingPasswordRequired) return;
-
 			SendText("zCommand Bookings List");
 		}
 
@@ -2167,12 +2127,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                     !String.Equals(Status.Call.Info.meeting_type,"NORMAL"),
                     false,
                     MeetingIsLockedFeedback.BoolValue,
-                    MeetingIsRecordingFeedback.BoolValue, Status.Call.CallRecordInfo.AllowRecord
+                    MeetingIsRecordingFeedback.BoolValue
                     );
-
-                SetDefaultLayout();
             }
-
+            // TODO [ ] Issue #868
             else if (item.Status == eCodecCallStatus.Disconnected)
             {
                 MeetingInfo = new MeetingInfo(
@@ -2185,15 +2143,19 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                     false,
                     false,
                     false,
-                    false, Status.Call.CallRecordInfo.AllowRecord
+                    false
                     );
             }
 
-			_meetingPasswordRequired = false;
             base.OnCallStatusChange(item);
 
 			Debug.Console(1, this, "[OnCallStatusChange] Current Call Status: {0}",
 				Status.Call != null ? Status.Call.Status.ToString() : "no call");
+
+			if (_props.AutoDefaultLayouts)
+			{
+				SetLayout();
+			}
 		}
 
         private string GetSharingStatus()
@@ -2261,9 +2223,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             }
         }
 
-        /// <summary>
-        /// Starts sharing HDMI source
-        /// </summary>
 		public override void StartSharing()
 		{
 			SendText("zCommand Call Sharing HDMI Start");
@@ -2409,20 +2368,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		/// <param name="joinMap"></param>
 		public void LinkZoomRoomToApi(BasicTriList trilist, ZoomRoomJoinMap joinMap)
 		{
-            var meetingInfoCodec = this as IHasMeetingInfo;
-            if (meetingInfoCodec != null)
-            {
-                if (meetingInfoCodec.MeetingInfo != null)
-                {
-                    trilist.SetBool(joinMap.MeetingCanRecord.JoinNumber, meetingInfoCodec.MeetingInfo.CanRecord);
-                }
-
-                meetingInfoCodec.MeetingInfoChanged += (o, a) =>
-                    {
-                        trilist.SetBool(joinMap.MeetingCanRecord.JoinNumber, a.Info.CanRecord);
-                    };
-            }
-
             var recordingCodec = this as IHasMeetingRecordingWithPrompt;
             if (recordingCodec != null)
             {
@@ -2537,34 +2482,24 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 //trilist.SetString(joinMap.CurrentSource.JoinNumber, args.Info.ShareStatus);
 		    };
 
-		    trilist.SetSigFalseAction(joinMap.StartMeetingNow.JoinNumber, () => StartMeeting(0));
-            trilist.SetSigFalseAction(joinMap.ShareOnlyMeeting.JoinNumber, StartSharingOnlyMeeting);
-            trilist.SetSigFalseAction(joinMap.StartNormalMeetingFromSharingOnlyMeeting.JoinNumber, StartNormalMeetingFromSharingOnlyMeeting);
+		    trilist.SetSigTrueAction(joinMap.StartMeetingNow.JoinNumber, () => StartMeeting(0));
+		    trilist.SetSigTrueAction(joinMap.ShareOnlyMeeting.JoinNumber, StartSharingOnlyMeeting);
+            trilist.SetSigTrueAction(joinMap.StartNormalMeetingFromSharingOnlyMeeting.JoinNumber, StartNormalMeetingFromSharingOnlyMeeting);
+
+            // not sure if this would be needed here, should be handled by VideoCodecBase.cs LinkToApi methods
+            //DirectoryResultReturned += (device, args) =>
+            //{
+            //    // add logic here if necessary when event fires
+
+            //};
+
 
 			trilist.SetStringSigAction(joinMap.SubmitPassword.JoinNumber, SubmitPassword);
-
-            // Subscribe to call status to clear ShowPasswordPrompt when in meeting
-            this.CallStatusChange += (o, a) =>
-                {
-                    if (a.CallItem.Status == eCodecCallStatus.Connected || a.CallItem.Status == eCodecCallStatus.Disconnected)
-                    {
-                        trilist.SetBool(joinMap.MeetingPasswordRequired.JoinNumber, false);
-                    }
-
-                };
-
-            trilist.SetSigFalseAction(joinMap.CancelJoinAttempt.JoinNumber, () => {
-                trilist.SetBool(joinMap.MeetingPasswordRequired.JoinNumber, false);
-                EndAllCalls();
-            });
-
 			PasswordRequired += (devices, args) =>
 			{
-                Debug.Console(0, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
-
 				if (args.LoginAttemptCancelled)
 				{
-					trilist.SetBool(joinMap.MeetingPasswordRequired.JoinNumber, false);
+					trilist.SetBool(joinMap.ShowPasswordPrompt.JoinNumber, false);
 					return;
 				}
 
@@ -2580,7 +2515,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 				}
 
 				trilist.SetBool(joinMap.PasswordIncorrect.JoinNumber, args.LastAttemptWasIncorrect);
-				trilist.SetBool(joinMap.MeetingPasswordRequired.JoinNumber, true);
+				trilist.SetBool(joinMap.ShowPasswordPrompt.JoinNumber, true);
 			};
 
 			trilist.OnlineStatusChange += (device, args) =>
@@ -2596,34 +2531,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 				pinCodec.NumberOfScreensFeedback.FireUpdate();
 				layoutSizeCodec.SelfviewPipSizeFeedback.FireUpdate();
 			};
-
-            var wirelessInfoCodec = this as IZoomWirelessShareInstructions;
-            if (wirelessInfoCodec != null)
-            {
-                if (Status != null && Status.Sharing != null)
-                {
-                    SetSharingStateJoins(Status.Sharing, trilist, joinMap);
-                }
-
-                wirelessInfoCodec.ShareInfoChanged += (o, a) =>
-                    {
-                        SetSharingStateJoins(a.SharingStatus, trilist, joinMap);
-                    };
-            }
 		}
 
-        void SetSharingStateJoins(zStatus.Sharing state, BasicTriList trilist, ZoomRoomJoinMap joinMap)
-        {
-            trilist.SetBool(joinMap.IsSharingAirplay.JoinNumber, state.isAirHostClientConnected);
-            trilist.SetBool(joinMap.IsSharingHdmi.JoinNumber, state.isBlackMagicConnected || state.isDirectPresentationConnected);
-            
-            trilist.SetString(joinMap.DisplayState.JoinNumber, state.dispState.ToString());
-            trilist.SetString(joinMap.AirplayShareCode.JoinNumber, state.password);
-            trilist.SetString(joinMap.LaptopShareKey.JoinNumber, state.directPresentationSharingKey);
-            trilist.SetString(joinMap.WifiName.JoinNumber, state.wifiName);
-            trilist.SetString(joinMap.ServerName.JoinNumber, state.serverName);
-        }
-
 		public override void ExecuteSwitch(object selector)
 		{
 			var action = selector as Action;
@@ -3300,7 +3209,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			// There is no property that directly reports if strip mode is valid, but API stipulates
 			// that strip mode is available if the number of screens is 1
-			if (Status.NumberOfScreens.NumOfScreens == 1 || Status.Layout.can_Switch_Strip_View || Status.Layout.video_type.ToLower() == "strip")
+			if (Status.NumberOfScreens.NumOfScreens == 1)
 			{
 				availableLayouts |= zConfiguration.eLayoutStyle.Strip;
 			}
@@ -3315,15 +3224,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             var handler = LayoutInfoChanged;
             if (handler != null)
             {
-
-                var currentLayout = zConfiguration.eLayoutStyle.None;
-
-                currentLayout = (zConfiguration.eLayoutStyle)Enum.Parse(typeof(zConfiguration.eLayoutStyle), string.IsNullOrEmpty(LocalLayoutFeedback.StringValue) ? "None" : LocalLayoutFeedback.StringValue, true);            
-
                 handler(this, new LayoutInfoChangedEventArgs()
                 {
                     AvailableLayouts = AvailableLayouts,
-                    CurrentSelectedLayout = currentLayout,
+                    CurrentSelectedLayout = (zConfiguration.eLayoutStyle)Enum.Parse(typeof(zConfiguration.eLayoutStyle),string.IsNullOrEmpty(LocalLayoutFeedback.StringValue) ? "None" : LocalLayoutFeedback.StringValue , true),
                     LayoutViewIsOnFirstPage = LayoutViewIsOnFirstPageFeedback.BoolValue,
                     LayoutViewIsOnLastPage = LayoutViewIsOnLastPageFeedback.BoolValue,
                     CanSwapContentWithThumbnail = CanSwapContentWithThumbnailFeedback.BoolValue,
@@ -3453,7 +3357,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
         {
             Debug.Console(2, this, "Password Submitted: {0}", password);
             Dial(_lastDialedMeetingNumber, password);
-            //OnPasswordRequired(false, false, true, "");		
         }
 
         void OnPasswordRequired(bool lastAttemptIncorrect, bool loginFailed, bool loginCancelled, string message)
@@ -3461,9 +3364,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             var handler = PasswordRequired;
             if (handler != null)
             {
-				if(!loginFailed || !loginCancelled)
-					_meetingPasswordRequired = true;
-				
                 handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
             }
         }
@@ -3503,19 +3403,19 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 	        StartSharingOnlyMeeting(eSharingMeetingMode.None, 30, String.Empty);
 	    }
 
-	    public void StartSharingOnlyMeeting(eSharingMeetingMode displayMode)
+	    public void StartSharingOnlyMeeting(eSharingMeetingMode mode)
 	    {
-	        StartSharingOnlyMeeting(displayMode, DefaultMeetingDurationMin, String.Empty);
+	        StartSharingOnlyMeeting(mode, 30, String.Empty);
 	    }
 
-	    public void StartSharingOnlyMeeting(eSharingMeetingMode displayMode, uint duration)
+	    public void StartSharingOnlyMeeting(eSharingMeetingMode mode, ushort duration)
 	    {
-	        StartSharingOnlyMeeting(displayMode, duration, String.Empty);
+	        StartSharingOnlyMeeting(mode, duration, String.Empty);
 	    }
 
-	    public void StartSharingOnlyMeeting(eSharingMeetingMode displayMode, uint duration, string password)
+	    public void StartSharingOnlyMeeting(eSharingMeetingMode mode, ushort duration, string password)
 	    {
-            SendText(String.Format("zCommand Dial Sharing Duration: {0} DisplayState: {1} Password: {2}", duration, displayMode, password));
+            SendText(String.Format("zCommand Dial Sharing Duration: {0} DisplayState: {1} Password: {2}", duration, mode, password));
 	    }
 
 	    public void StartNormalMeetingFromSharingOnlyMeeting()
@@ -3592,41 +3492,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
         }
 
         #endregion
-
-        #region IZoomWirelessShareInstructions Members
-
-        public event EventHandler<ShareInfoEventArgs> ShareInfoChanged;
-
-        public zStatus.Sharing SharingState
-        {
-            get
-            {
-                return Status.Sharing;
-            }
-        }
-
-        void OnShareInfoChanged(zStatus.Sharing status)
-        {
-            Debug.Console(2, this,
-@"ShareInfoChanged:
-isSharingHDMI: {0}
-isSharingAirplay: {1}
-AirplayPassword: {2}
-OSD Display State: {3}
-",
-status.isSharingBlackMagic,
-status.isAirHostClientConnected,
-status.password,
-status.dispState);
-
-            var handler = ShareInfoChanged;
-            if (handler != null)
-            {
-                handler(this, new ShareInfoEventArgs(status));
-            }
-        }
-
-        #endregion
     }
 
 	/// <summary>

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoomJoinMap.cs

@@ -8,22 +8,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 	{
 		#region Digital
 
-        [JoinName("CancelJoinAttempt")]
-        public JoinDataComplete CancelJoinAttempt = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 5,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Pulse to hide the password prompt",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("MeetingPasswordRequired")]
-        public JoinDataComplete MeetingPasswordRequired = new JoinDataComplete(
+        // TODO [ ] Issue #868
+        [JoinName("ShowPasswordPrompt")]
+        public JoinDataComplete ShowPasswordPrompt = new JoinDataComplete(
             new JoinData
             {
                 JoinNumber = 6,
@@ -36,6 +23,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("PasswordIncorrect")]
         public JoinDataComplete PasswordIncorrect = new JoinDataComplete(
             new JoinData
@@ -50,7 +38,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
-        [JoinName("PasswordLoginFailed")]
+        // TODO [ ] Issue #868
+        [JoinName("PassowrdLoginFailed")]
         public JoinDataComplete PasswordLoginFailed = new JoinDataComplete(
             new JoinData
             {
@@ -64,6 +53,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("WaitingForHost")]
         public JoinDataComplete WaitingForHost = new JoinDataComplete(
             new JoinData
@@ -78,6 +68,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("IsHost")]
         public JoinDataComplete IsHost = new JoinDataComplete(
             new JoinData
@@ -92,6 +83,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("StartMeetingNow")]
         public JoinDataComplete StartMeetingNow = new JoinDataComplete(
             new JoinData
@@ -101,11 +93,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             },
             new JoinMetadata
             {
-                Description = "Pulse to start an ad-hoc meeting with the default duration",
+                Description = "FB Indicates the password prompt is active",
                 JoinCapabilities = eJoinCapabilities.FromSIMPL,
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("ShareOnlyMeeting")]
         public JoinDataComplete ShareOnlyMeeting = new JoinDataComplete(
             new JoinData
@@ -120,6 +113,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
+        // TODO [ ] Issue #868
         [JoinName("StartNormalMeetingFromSharingOnlyMeeting")]
         public JoinDataComplete StartNormalMeetingFromSharingOnlyMeeting = new JoinDataComplete(
             new JoinData
@@ -373,54 +367,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
                 JoinType = eJoinType.Digital
             });
 
-        [JoinName("MeetingCanRecord")]
-        public JoinDataComplete MeetingCanRecord = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 246,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "When high, indicated that the current meeting can be recorded",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-
-        #region Sharing Status
-
-        [JoinName("IsSharingAirplay")]
-        public JoinDataComplete IsSharingAirplay = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 250,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Indicates an Airplay source is sharing",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("IsSharingHdmi")]
-        public JoinDataComplete IsSharingHdmi = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 251,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Indicates an HDMI source is sharing",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-
-
-        #endregion
         //[JoinName("ParticipantAudioMuteToggleStart")]
         //public JoinDataComplete ParticipantAudioMuteToggleStart = new JoinDataComplete(
         //    new JoinData
@@ -605,92 +551,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 				JoinType = eJoinType.DigitalSerial
 			});
 
-        [JoinName("DisplayState")]
-        public JoinDataComplete DisplayState = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 250,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the instructions the ZoomRoom is displaying on the monitor. <None | Laptop | IOS>",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("AirplayShareCode")]
-        public JoinDataComplete AirplayShareCode = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 251,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the current code for Airplay Sharing.",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("LaptopShareKey")]
-        public JoinDataComplete LaptopShareKey = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 252,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "The alpha-only sharing key that users type into a laptop client to share with the Zoom Room.",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("LaptopSharePairingCode")]
-        public JoinDataComplete LaptopSharePairingCode = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 253,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "This is the paring code that is broadcast via an ultrasonic signal from the ZRC. It is different than the user-supplied paring code. The ZRC uses a Zoom-proprietary method of advertizing the ultrasonic pairing code, so it\'s not possible to advertize it using commonly available libraries.",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("WifiName")]
-        public JoinDataComplete WifiName = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 254,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the Wifi SSID used by the ZoomRoom.",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("ServerName")]
-        public JoinDataComplete ServerName = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 255,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the namne of the the ZoomRoom.",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-
-
 		#endregion
 
 		public ZoomRoomJoinMap(uint joinStart)

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoomPropertiesConfig.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 
@@ -30,13 +29,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         /* This layout will be selected when Sharing starts (either from Far end or locally)*/
         [JsonProperty("defaultSharingLayout")]
-        [JsonConverter(typeof(StringEnumConverter))]
-        public zConfiguration.eLayoutStyle DefaultSharingLayout { get; set; }
+        public string DefaultSharingLayout { get; set; }
 
         //This layout will be selected when a call is connected and no content is being shared
         [JsonProperty("defaultCallLayout")]
-        [JsonConverter(typeof(StringEnumConverter))]
-        public zConfiguration.eLayoutStyle DefaultCallLayout { get; set; }
+        public string DefaultCallLayout { get; set; }
 
         [JsonProperty("minutesBeforeMeetingStart")]
         public int MinutesBeforeMeetingStart { get; set; }