fix: add missing LoadSmartObjects call

The constructor was checking the wrong
variable, leading to it always being null
and failing to build the `EssentialsTouchpanelController`
class.

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;
 
@@ -192,6 +195,8 @@ namespace PepperDash.Essentials
                 }
                 else   // Handles Linux OS (Virtual Control)
                 {
+                    Debug.SetDebugLevel(2);
+
                     Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", Global.AssemblyVersion);
 
                     // Set path to User/
@@ -219,6 +224,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 +373,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 +384,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>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/BridgeBase.cs

@@ -394,35 +394,51 @@ namespace PepperDash.Essentials.Core.Bridges
 
             var controlProperties = CommFactory.GetControlPropertiesConfig(dc);
 
+            BasicTriList eisc;
+
             switch (dc.Type.ToLower())
             {
                 case "eiscapiadv":
                 case "eiscapiadvanced":
                 {
-                    var eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
+                    eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
                         controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                    break;
                 }
                 case "eiscapiadvancedserver":
                 {
-                    var eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                    eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
+                    break;
                 }
                 case "eiscapiadvancedclient":
                 {
-                    var eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                    eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
+                    break;
                 }
                 case "vceiscapiadv":
                 case "vceiscapiadvanced":
                 {
-                    var eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, InitialParametersClass.RoomId,
+                    if (string.IsNullOrEmpty(controlProperties.RoomId))
+                    {
+                        Debug.Console(0, Debug.ErrorLogLevel.Error, "Unable to build VC-4 EISC Client for device {0}. Room ID is missing or empty", dc.Key);
+                        eisc = null;
+                        break;
+                    }
+                    eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, controlProperties.RoomId,
                         Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
+                    break;
                 }
                 default:
-                    return null;
+                    eisc = null;
+                    break;
             }
+
+            if (eisc == null)
+            {
+                return null;
+            }
+
+            return new EiscApiAdvanced(dc, eisc);
         }
     }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/UI/TouchpanelBase.cs

@@ -31,7 +31,7 @@ namespace PepperDash.Essentials.Core.UI
             :base(key, name)
         {
 
-            if (Panel == null)
+            if (panel == null)
             {
                 Debug.Console(0, this, "Panel is not valid. Touchpanel class WILL NOT work correctly");
                 return;
@@ -71,6 +71,8 @@ namespace PepperDash.Essentials.Core.UI
                         return;
                     }
                 }
+
+                Panel.LoadSmartObjects(sgdName);
             });
 
             AddPostActivationAction(() =>

essentials-framework/Essentials Devices Common/Essentials Devices Common/Cameras/CameraBase.cs

@@ -223,7 +223,7 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
 
                 SendCameraPresetNamesToApi(presetsCamera, joinMap, trilist);
 
-                for (int i = 0; i < joinMap.NumberOfPresets.JoinNumber; i++)
+                for (int i = 0; i < joinMap.NumberOfPresets.JoinSpan; i++)
                 {
                     int tempNum = i;
 

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/VideoCodec/VideoCodecBase.cs

@@ -1393,11 +1393,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[stringIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
                 if(call.Duration != null)
                 {
                     // May need to verify correct string format here
@@ -1417,12 +1417,12 @@ 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[stringIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
+                tokenArray[stringIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;

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

@@ -64,9 +64,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		private bool _meetingPasswordRequired;
 
+        private bool _waitingForUserToAcceptOrRejectIncomingCall;
+
 		public void Poll(string pollString)
 		{
-			if(_meetingPasswordRequired) return;
+			if(_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 			
 			SendText(string.Format("{0}{1}", pollString, SendDelimiter));
 		}
@@ -968,6 +970,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void SendText(string command)
 		{
+            if (_meetingPasswordRequired)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to enter meeting password");
+                return;
+            }
+
+            if (_waitingForUserToAcceptOrRejectIncomingCall)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to accept or reject incoming call");
+                return;
+            }
+
 			if (CommDebuggingIsOn)
 			{
 				Debug.Console(1, this, "Sending: '{0}'", command);
@@ -1592,6 +1606,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										Id = incomingCall.callerJID
 									};
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = true;
+
 									ActiveCalls.Add(newCall);
 
 									OnCallStatusChange(newCall);
@@ -1618,6 +1634,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										OnCallStatusChange(existingCall);
 									}
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 									UpdateCallStatus();
 								}
 
@@ -2000,7 +2018,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		/// </summary>
 		private void GetBookings()
 		{
-			if (_meetingPasswordRequired) return;
+			if (_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 
 			SendText("zCommand Bookings List");
 		}
@@ -2560,7 +2578,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			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);
+                Debug.Console(2, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
 
 				if (args.LoginAttemptCancelled)
 				{
@@ -2637,6 +2655,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void AcceptCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2646,6 +2666,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void AcceptCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Accept callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Connected;
@@ -2657,6 +2679,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void RejectCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2666,6 +2690,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void RejectCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Reject callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Disconnected;
@@ -2792,16 +2818,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void LeaveMeeting()
         {
-            SendText("zCommand Call Leave");
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
+			SendText("zCommand Call Leave");
         }
 
 		public override void EndCall(CodecActiveCallItem call)
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
 		public override void EndAllCalls()
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
@@ -3451,20 +3486,21 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void SubmitPassword(string password)
         {
+            _meetingPasswordRequired = false;
             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)
         {
+			_meetingPasswordRequired = !loginFailed || !loginCancelled;
+
             var handler = PasswordRequired;
             if (handler != null)
-            {
-				if(!loginFailed || !loginCancelled)
-					_meetingPasswordRequired = true;
-				
-                handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
+            {	            
+				Debug.Console(2, this, "Meeting Password Required: {0}", _meetingPasswordRequired);
+
+	            handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
             }
         }
 

packages.config

@@ -1,3 +1,3 @@
 <packages>
-  <package id="PepperDashCore" version="1.1.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
+  <package id="PepperDashCore" version="1.1.3" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
 </packages>