Merge branch 'development' into feature/room-combining

update MockVC and EssentialsVideoCodecUiDriver
updates to Cisco classes to address some exceptions at startup with EssentialsVideoCodecUiDriver

.github/workflows/docker.yml

@@ -22,7 +22,7 @@ env:
   RELEASE_BRANCH: main
 jobs:
   Build_Project:
-    runs-on: windows-2019
+    runs-on: windows-latest
     steps:
       # First we checkout the source repo
       - name: Checkout repo
@@ -98,7 +98,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   Push_Nuget_Package:
     needs: Build_Project
-    runs-on: windows-2019
+    runs-on: windows-latest
     steps:
       - name: Download Build Version Info
         uses: actions/download-artifact@v1

.github/workflows/main.yml

@@ -19,7 +19,7 @@ env:
   RELEASE_BRANCH: main
 jobs:
   Build_Project:
-    runs-on: windows-2019
+    runs-on: windows-latest
     steps:
       # First we checkout the source repo
       - name: Checkout repo
@@ -82,7 +82,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   Push_Nuget_Package:
     needs: Build_Project
-    runs-on: windows-2019
+    runs-on: windows-latest
     steps:
       - name: Download Build Version Info
         uses: actions/download-artifact@v1

PepperDashEssentials/ControlSystem.cs

@@ -506,8 +506,11 @@ namespace PepperDash.Essentials
                     {
                         DeviceManager.AddDevice(room);
 
-                        Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion with IP-ID {0:X2}", fusionIpId);
-                        DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((IEssentialsHuddleVtc1Room)room, fusionIpId, fusionJoinMapKey));
+                        if (!(room is EssentialsCombinedHuddleVtc1Room))
+                        {
+                            Debug.Console(0, Debug.ErrorLogLevel.Notice, "Room is EssentialsHuddleVtc1Room, attempting to add to DeviceManager with Fusion with IP-ID {0:X2}", fusionIpId);
+                            DeviceManager.AddDevice(new EssentialsHuddleVtc1FusionController((IEssentialsHuddleVtc1Room)room, fusionIpId, fusionJoinMapKey));
+                        }
 
                         Debug.Console(0, Debug.ErrorLogLevel.Notice, "Attempting to build Mobile Control Bridge...");
 

PepperDashEssentials/PepperDashEssentials.csproj

@@ -144,6 +144,7 @@
     <Compile Include="Room\Config\EssentialsRoomEmergencyConfig.cs" />
     <Compile Include="Room\Config\EssentialsTechRoomConfig.cs" />
     <Compile Include="Room\Emergency\EsentialsRoomEmergencyContactClosure.cs" />
+    <Compile Include="Room\Types\EssentialsCombinedHuddleVtc1Room.cs" />
     <Compile Include="Room\Types\EssentialsDualDisplayRoom.cs" />
     <Compile Include="Room\Types\EssentialsHuddleVtc1Room.cs" />
     <Compile Include="Room\Types\EssentialsNDisplayRoomBase.cs" />

PepperDashEssentials/Properties/ControlSystem.cfg

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <ControlSystem>
-  <Name>192.168.10.1</Name>
-  <Address>auto 192.168.10.1</Address>
+  <Name>Test RMC3</Name>
+  <Address>auto 192.168.1.40;username crestron</Address>
   <ProgramSlot>Program01</ProgramSlot>
   <Storage>Internal Flash</Storage>
 </ControlSystem>

PepperDashEssentials/Room/Config/EssentialsRoomConfig.cs

@@ -39,6 +39,10 @@ namespace PepperDash.Essentials.Room.Config
 		    {
 		        return new EssentialsDualDisplayRoom(roomConfig);
 		    }
+            if (typeName == "combinedhuddlevtc1")
+            {
+                return new EssentialsCombinedHuddleVtc1Room(roomConfig);
+            }
 
 		    return typeName != "techroom" ? null : new EssentialsTechRoom(roomConfig);
 		}
@@ -183,6 +187,12 @@ namespace PepperDash.Essentials.Room.Config
 		[JsonProperty("zeroVolumeWhenSwtichingVolumeDevices")]
 		public bool ZeroVolumeWhenSwtichingVolumeDevices { get; set; }
 
+        /// <summary>
+        /// Indicates if this room represents a combination of other rooms
+        /// </summary>
+        [JsonProperty("isRoomCombinationScenario")]
+        public bool IsRoomCombinationScenario { get; set; }
+
         public EssentialsRoomPropertiesConfig()
         {
             LogoLight = new EssentialsLogoPropertiesConfig();

PepperDashEssentials/Room/Types/EssentialsCombinedHuddleVtc1Room.cs

@@ -0,0 +1,821 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Room.Config;
+using PepperDash.Essentials.Devices.Common.Codec;
+using PepperDash.Essentials.Devices.Common.VideoCodec;
+using PepperDash.Essentials.Devices.Common.AudioCodec;
+using PepperDash.Essentials.Core.DeviceTypeInterfaces;
+
+namespace PepperDash.Essentials
+{
+    public class EssentialsCombinedHuddleVtc1Room : EssentialsRoomBase, IEssentialsHuddleVtc1Room
+    {
+        private bool _codecExternalSourceChange;
+        public event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
+        public event SourceInfoChangeHandler CurrentSourceChange;
+
+
+        //************************
+        // Call-related stuff
+
+        public BoolFeedback InCallFeedback { get; private set; }
+
+        ///// <summary>
+        ///// Make this more specific
+        ///// </summary>
+        //public List<CodecActiveCallItem> ActiveCalls { get; private set; }
+
+        /// <summary>
+        /// States: 0 for on hook, 1 for video, 2 for audio, 3 for telekenesis
+        /// </summary>
+        public IntFeedback CallTypeFeedback { get; private set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public BoolFeedback PrivacyModeIsOnFeedback { get; private set; }
+
+        /// <summary>
+        /// When something in the room is sharing with the far end or through other means
+        /// </summary>
+        public BoolFeedback IsSharingFeedback { get; private set; }
+
+        //************************
+
+        protected override Func<bool> OnFeedbackFunc
+        {
+            get
+            {
+                return () =>
+                {
+
+                    var displays = Displays.OfType<DisplayBase>().ToList();
+
+                    var val = CurrentSourceInfo != null
+                        && CurrentSourceInfo.Type == eSourceListItemType.Route
+                        && displays.Count > 0;
+                    //&& disp.PowerIsOnFeedback.BoolValue;
+                    return val;
+                };
+            }
+        }
+        /// <summary>
+        /// 
+        /// </summary>
+        protected override Func<bool> IsWarmingFeedbackFunc
+        {
+            get
+            {
+                return () => Displays.OfType<TwoWayDisplayBase>().Any((d) => d.IsWarmingUpFeedback.BoolValue);
+            }
+        }
+        /// <summary>
+        /// 
+        /// </summary>
+        protected override Func<bool> IsCoolingFeedbackFunc
+        {
+            get
+            {
+                return () => Displays.OfType<TwoWayDisplayBase>().Any((d) => d.IsCoolingDownFeedback.BoolValue);
+            }
+        }
+
+        public EssentialsConferenceRoomPropertiesConfig PropertiesConfig { get; private set; }
+
+        private List<IRoutingSinkWithSwitching> Displays;
+
+        public IRoutingSinkWithSwitching DefaultDisplay { get; private set; }
+
+        public IBasicVolumeControls DefaultAudioDevice { get; private set; }
+        public IBasicVolumeControls DefaultVolumeControls { get; private set; }
+
+        public VideoCodecBase VideoCodec { get; private set; }
+
+        public AudioCodecBase AudioCodec { get; private set; }
+
+        public bool ExcludeFromGlobalFunctions { get; set; }
+
+        public string DefaultSourceItem { get; set; }
+
+        public ushort DefaultVolume { get; set; }
+
+        /// <summary>
+        /// If room is off, enables power on to last source. Default true
+        /// </summary>
+        public bool EnablePowerOnToLastSource { get; set; }
+        string LastSourceKey;
+
+        /// <summary>
+        /// Sets the volume control device, and attaches/removes InUseTrackers with "audio"
+        /// tag to device.
+        /// </summary>
+        public IBasicVolumeControls CurrentVolumeControls
+        {
+            get { return _CurrentAudioDevice; }
+            set
+            {
+                if (value == _CurrentAudioDevice) return;
+
+                var oldDev = _CurrentAudioDevice;
+                // derigister this room from the device, if it can
+                if (oldDev is IInUseTracking)
+                    (oldDev as IInUseTracking).InUseTracker.RemoveUser(this, "audio");
+                var handler = CurrentVolumeDeviceChange;
+                if (handler != null)
+                    CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.WillChange));
+                _CurrentAudioDevice = value;
+                if (handler != null)
+                    CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.DidChange));
+                // register this room with new device, if it can
+                if (_CurrentAudioDevice is IInUseTracking)
+                    (_CurrentAudioDevice as IInUseTracking).InUseTracker.AddUser(this, "audio");
+            }
+        }
+        IBasicVolumeControls _CurrentAudioDevice;
+
+        /// <summary>
+        /// The SourceListItem last run - containing names and icons 
+        /// </summary>
+        public SourceListItem CurrentSourceInfo
+        {
+            get { return _CurrentSourceInfo; }
+            set
+            {
+                if (value == _CurrentSourceInfo) return;
+
+                var handler = CurrentSourceChange;
+                // remove from in-use tracker, if so equipped
+                if (_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
+                    (_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.RemoveUser(this, "control");
+
+                if (handler != null)
+                    handler(_CurrentSourceInfo, ChangeType.WillChange);
+
+                _CurrentSourceInfo = value;
+
+                // add to in-use tracking
+                if (_CurrentSourceInfo != null && _CurrentSourceInfo.SourceDevice is IInUseTracking)
+                    (_CurrentSourceInfo.SourceDevice as IInUseTracking).InUseTracker.AddUser(this, "control");
+                if (handler != null)
+                    handler(_CurrentSourceInfo, ChangeType.DidChange);
+
+                var vc = VideoCodec as IHasExternalSourceSwitching;
+                if (vc != null && !_codecExternalSourceChange)
+                {
+                    vc.SetSelectedSource(CurrentSourceInfoKey);
+                }
+
+                _codecExternalSourceChange = false;
+            }
+        }
+        SourceListItem _CurrentSourceInfo;
+
+        public string CurrentSourceInfoKey { get; set; }
+
+        /// <summary>
+        /// "codecOsd"
+        /// </summary>
+        public string DefaultCodecRouteString { get { return "codecOsd"; } }
+
+        /// <summary>
+        /// Temporary implementation. Returns the schedule-ready object or null if none. Fow now,
+        /// always returns the VideoCodec if it is capable
+        /// </summary>
+        public IHasScheduleAwareness ScheduleSource { get { return VideoCodec as IHasScheduleAwareness; } }
+
+        CCriticalSection SourceSelectLock = new CCriticalSection();
+
+        public EssentialsCombinedHuddleVtc1Room(DeviceConfig config)
+            : base(config)
+        {
+            try
+            {
+                PropertiesConfig = JsonConvert.DeserializeObject<EssentialsConferenceRoomPropertiesConfig>
+                    (config.Properties.ToString());
+
+                VideoCodec = DeviceManager.GetDeviceForKey(PropertiesConfig.VideoCodecKey) as
+                    PepperDash.Essentials.Devices.Common.VideoCodec.VideoCodecBase;
+
+
+                if (VideoCodec == null)
+                    throw new ArgumentNullException("codec cannot be null");
+
+                AudioCodec = DeviceManager.GetDeviceForKey(PropertiesConfig.AudioCodecKey) as
+                    PepperDash.Essentials.Devices.Common.AudioCodec.AudioCodecBase;
+                if (AudioCodec == null)
+                    Debug.Console(0, this, "No Audio Codec Found");
+
+                DefaultAudioDevice = DeviceManager.GetDeviceForKey(PropertiesConfig.DefaultAudioKey) as IBasicVolumeControls;
+
+                Displays = new List<IRoutingSinkWithSwitching>();
+
+                Initialize();
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Error building room: \n{0}", e);
+            }
+        }
+
+        void Initialize()
+        {
+            try
+            {
+                if (DefaultAudioDevice is IBasicVolumeControls)
+                    DefaultVolumeControls = DefaultAudioDevice as IBasicVolumeControls;
+                else if (DefaultAudioDevice is IHasVolumeDevice)
+                    DefaultVolumeControls = (DefaultAudioDevice as IHasVolumeDevice).VolumeDevice;
+                CurrentVolumeControls = DefaultVolumeControls;
+
+
+                // Combines call feedback from both codecs if available
+                InCallFeedback = new BoolFeedback(() =>
+                {
+                    bool inAudioCall = false;
+                    bool inVideoCall = false;
+
+                    if (AudioCodec != null)
+                        inAudioCall = AudioCodec.IsInCall;
+
+                    if (VideoCodec != null)
+                        inVideoCall = VideoCodec.IsInCall;
+
+                    if (inAudioCall || inVideoCall)
+                        return true;
+                    else
+                        return false;
+                });
+
+                SetupDisplays();
+
+                // Get Microphone Privacy object, if any  MUST HAPPEN AFTER setting InCallFeedback
+                this.MicrophonePrivacy = EssentialsRoomConfigHelper.GetMicrophonePrivacy(PropertiesConfig, this);
+
+                Debug.Console(2, this, "Microphone Privacy Config evaluated.");
+
+                // Get emergency object, if any
+                this.Emergency = EssentialsRoomConfigHelper.GetEmergency(PropertiesConfig, this);
+
+                Debug.Console(2, this, "Emergency Config evaluated.");
+
+
+                VideoCodec.CallStatusChange += (o, a) => this.InCallFeedback.FireUpdate();
+                VideoCodec.IsReadyChange += (o, a) => { this.SetCodecExternalSources(); SetCodecBranding(); };
+
+                if (AudioCodec != null)
+                    AudioCodec.CallStatusChange += (o, a) => this.InCallFeedback.FireUpdate();
+
+                IsSharingFeedback = new BoolFeedback(() => VideoCodec.SharingContentIsOnFeedback.BoolValue);
+                VideoCodec.SharingContentIsOnFeedback.OutputChange += (o, a) => this.IsSharingFeedback.FireUpdate();
+
+                // link privacy to VC (for now?)
+                PrivacyModeIsOnFeedback = new BoolFeedback(() => VideoCodec.PrivacyModeIsOnFeedback.BoolValue);
+                VideoCodec.PrivacyModeIsOnFeedback.OutputChange += (o, a) => this.PrivacyModeIsOnFeedback.FireUpdate();
+
+                CallTypeFeedback = new IntFeedback(() => 0);
+
+                SetSourceListKey();
+
+                EnablePowerOnToLastSource = true;
+            }
+            catch (Exception e)
+            {
+                Debug.Console(0, this, "Error Initializing Room: {0}", e);
+            }
+        }
+
+        private void SetupDisplays()
+        {
+            //DefaultDisplay = DeviceManager.GetDeviceForKey(PropertiesConfig.DefaultDisplayKey) as IRoutingSinkWithSwitching;
+
+            var destinationList = ConfigReader.ConfigObject.DestinationLists[PropertiesConfig.DestinationListKey];
+
+            foreach (var destination in destinationList)
+            {
+                var dest = destination.Value.SinkDevice as IRoutingSinkWithSwitching;
+
+                if (dest != null)
+                {
+                    Displays.Add(dest);
+                }
+
+                var display = dest as DisplayBase;
+                if (display != null)
+                {
+                    // Link power, warming, cooling to display
+                    var dispTwoWay = display as IHasPowerControlWithFeedback;
+                    if (dispTwoWay != null)
+                    {
+                        dispTwoWay.PowerIsOnFeedback.OutputChange += (o, a) =>
+                        {
+                            if (dispTwoWay.PowerIsOnFeedback.BoolValue != OnFeedback.BoolValue)
+                            {
+                                //if (!dispTwoWay.PowerIsOnFeedback.BoolValue)
+                                //    CurrentSourceInfo = null;
+                                OnFeedback.FireUpdate();
+                            }
+                            if (dispTwoWay.PowerIsOnFeedback.BoolValue)
+                            {
+                                SetDefaultLevels();
+                            }
+                        };
+                    }
+
+                    display.IsWarmingUpFeedback.OutputChange += (o, a) =>
+                    {
+                        IsWarmingUpFeedback.FireUpdate();
+                        if (!IsWarmingUpFeedback.BoolValue)
+                            (CurrentVolumeControls as IBasicVolumeWithFeedback).SetVolume(DefaultVolume);
+                    };
+                    display.IsCoolingDownFeedback.OutputChange += (o, a) =>
+                    {
+                        IsCoolingDownFeedback.FireUpdate();
+                    };
+
+                }
+            }
+        }
+
+        private void SetSourceListKey()
+        {
+            if (!string.IsNullOrEmpty(PropertiesConfig.SourceListKey))
+            {
+                SetSourceListKey(PropertiesConfig.SourceListKey);
+            }
+            else
+            {
+                SetSourceListKey(Key);
+            }
+
+            SetCodecExternalSources();
+        }
+
+        protected override void CustomSetConfig(DeviceConfig config)
+        {
+            var newPropertiesConfig = JsonConvert.DeserializeObject<EssentialsConferenceRoomPropertiesConfig>(config.Properties.ToString());
+
+            if (newPropertiesConfig != null)
+                PropertiesConfig = newPropertiesConfig;
+
+            ConfigWriter.UpdateRoomConfig(config);
+        }
+
+        public override bool CustomActivate()
+        {
+            // Add Occupancy object from config
+            if (PropertiesConfig.Occupancy != null)
+            {
+                Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Setting Occupancy Provider for room");
+                this.SetRoomOccupancy(DeviceManager.GetDeviceForKey(PropertiesConfig.Occupancy.DeviceKey) as
+                    IOccupancyStatusProvider, PropertiesConfig.Occupancy.TimeoutMinutes);
+            }
+
+            this.LogoUrlLightBkgnd = PropertiesConfig.LogoLight.GetLogoUrlLight();
+            this.LogoUrlDarkBkgnd = PropertiesConfig.LogoDark.GetLogoUrlDark();
+
+            this.DefaultSourceItem = PropertiesConfig.DefaultSourceItem;
+            this.DefaultVolume = (ushort)(PropertiesConfig.Volumes.Master.Level * 65535 / 100);
+
+            return base.CustomActivate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected override void EndShutdown()
+        {
+            VideoCodec.EndAllCalls();
+
+            SetDefaultLevels();
+
+            RunDefaultPresentRoute();
+
+            CrestronEnvironment.Sleep(1000);
+
+            Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Shutting down room");
+
+            RunRouteAction("roomOff");
+            VideoCodec.StopSharing();
+            VideoCodec.StandbyActivate();
+        }
+
+        /// <summary>
+        /// Routes the default source item, if any. Returns true when default route exists
+        /// </summary>
+        public override bool RunDefaultPresentRoute()
+        {
+            if (DefaultSourceItem != null)
+                RunRouteAction(DefaultSourceItem);
+
+            return DefaultSourceItem != null;
+        }
+
+        /// <summary>
+        /// Sets up the room when started into call mode without presenting a source
+        /// </summary>
+        /// <returns></returns>
+        public bool RunDefaultCallRoute()
+        {
+            RunRouteAction(DefaultCodecRouteString);
+            return true;
+        }
+
+        public void RunRouteActionCodec(string routeKey, string sourceListKey)
+        {
+            _codecExternalSourceChange = true;
+            RunRouteAction(routeKey, sourceListKey);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="routeKey"></param>
+        public void RunRouteAction(string routeKey)
+        {
+            RunRouteAction(routeKey, new Action(() => { }));
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="routeKey"></param>
+        /// <param name="souceListKey"></param>
+        /// <param name="successCallback"></param>
+        public void RunRouteAction(string routeKey, string sourceListKey)
+        {
+            if (string.IsNullOrEmpty(sourceListKey))
+            {
+                Debug.Console(1, this, "No sourceListKey present.  RunRouteAction assumes default source list.");
+                RunRouteAction(routeKey, new Action(() => { }));
+            }
+            else
+            {
+                Debug.Console(1, this, "sourceListKey present but not yet implemented");
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="routeKey"></param>
+        /// <param name="souceListKey"></param>
+        /// <param name="successCallback"></param>
+        public void RunRouteAction(string routeKey, string sourceListKey, Action successCallback)
+        {
+            if (string.IsNullOrEmpty(sourceListKey))
+            {
+                RunRouteAction(routeKey, successCallback);
+            }
+            else
+                throw new NotImplementedException();
+        }
+
+
+        /// <summary>
+        /// Gets a source from config list SourceListKey and dynamically build and executes the
+        /// route or commands
+        /// </summary>
+        /// <param name="name"></param>
+        public void RunRouteAction(string routeKey, Action successCallback)
+        {
+            // Run this on a separate thread
+            new CTimer(o =>
+            {
+                // try to prevent multiple simultaneous selections
+                SourceSelectLock.TryEnter();
+
+                try
+                {
+
+                    Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Run route action '{0}'", routeKey);
+                    var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
+                    if (dict == null)
+                    {
+                        Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
+                        return;
+                    }
+
+                    // Try to get the list item by it's string key
+                    if (!dict.ContainsKey(routeKey))
+                    {
+                        Debug.Console(1, this, "WARNING: No item '{0}' found on config list '{1}'",
+                            routeKey, SourceListKey);
+                        return;
+                    }
+
+                    // End usage timer on last source
+                    if (!string.IsNullOrEmpty(LastSourceKey))
+                    {
+                        var usageLastSource = dict[LastSourceKey].SourceDevice as IUsageTracking;
+                        if (usageLastSource != null && usageLastSource.UsageTracker != null)
+                        {
+                            try
+                            {
+                                // There MAY have been failures in here.  Protect
+                                usageLastSource.UsageTracker.EndDeviceUsage();
+                            }
+                            catch (Exception e)
+                            {
+                                Debug.Console(1, this, "*#* EXCEPTION in end usage tracking:\r{0}", e);
+                            }
+                        }
+                    }
+
+                    // Let's run it
+                    var item = dict[routeKey];
+                    if (routeKey.ToLower() != "roomoff")
+                    {
+
+                        LastSourceKey = routeKey;
+                    }
+                    else
+                        CurrentSourceInfoKey = null;
+
+                    // hand off the individual routes to this helper
+                    foreach (var route in item.RouteList)
+                        DoRouteItem(route);
+
+                    // Start usage timer on routed source
+                    var usageNewSource = item.SourceDevice as IUsageTracking;
+                    if (usageNewSource != null && usageNewSource.UsageTracker != null) // Have to make sure there is a usage tracker!
+                    {
+                        (item.SourceDevice as IUsageTracking).UsageTracker.StartDeviceUsage();
+                    }
+
+                    // See if this can be moved into common, base-class method -------------
+
+
+                    // Set volume control, using default if non provided
+                    IBasicVolumeControls volDev = null;
+                    // Handle special cases for volume control
+                    if (string.IsNullOrEmpty(item.VolumeControlKey)
+                        || item.VolumeControlKey.Equals("$defaultAudio", StringComparison.OrdinalIgnoreCase))
+                        volDev = DefaultVolumeControls;
+                    //else if (item.VolumeControlKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
+                    //    volDev = DefaultDisplay as IBasicVolumeControls;
+                    // Or a specific device, probably rarely used.
+                    else
+                    {
+                        var dev = DeviceManager.GetDeviceForKey(item.VolumeControlKey);
+                        if (dev is IBasicVolumeControls)
+                            volDev = dev as IBasicVolumeControls;
+                        else if (dev is IHasVolumeDevice)
+                            volDev = (dev as IHasVolumeDevice).VolumeDevice;
+                    }
+
+                    if (volDev != CurrentVolumeControls)
+                    {
+                        // zero the volume on the device we are leaving.  
+                        // Set the volume to default on device we are entering
+                        if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
+                        {
+                            var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
+                            SavedVolumeLevels[vd] = (uint)vd.VolumeLevelFeedback.IntValue;
+                            vd.SetVolume(0);
+                        }
+
+                        CurrentVolumeControls = volDev;
+                        if (ZeroVolumeWhenSwtichingVolumeDevices && CurrentVolumeControls is IBasicVolumeWithFeedback)
+                        {
+                            var vd = CurrentVolumeControls as IBasicVolumeWithFeedback;
+                            ushort vol = (SavedVolumeLevels.ContainsKey(vd) ? (ushort)SavedVolumeLevels[vd] : DefaultVolume);
+                            vd.SetVolume(vol);
+                        }
+                    }
+                    // -----------------------------------------------------------------------
+
+
+
+                    // store the name and UI info for routes
+                    if (item.SourceKey == "$off")
+                    {
+                        CurrentSourceInfoKey = routeKey;
+                        CurrentSourceInfo = null;
+                    }
+                    else if (item.SourceKey != null)
+                    {
+                        CurrentSourceInfoKey = routeKey;
+                        CurrentSourceInfo = item;
+                    }
+
+                    OnFeedback.FireUpdate();
+
+                    if (OnFeedback.BoolValue)
+                    {
+                        if (VideoCodec.UsageTracker.InUseTracker.InUseFeedback.BoolValue)
+                        {
+                            Debug.Console(1, this, "Video Codec in use, deactivating standby on codec");
+                            VideoCodec.StandbyDeactivate();
+                        }
+
+                        if (VideoCodec.StandbyIsOnFeedback.BoolValue)
+                        {
+                            VideoCodec.StandbyDeactivate();
+                        }
+                        else
+                        {
+                            Debug.Console(1, this, "Video codec not in standby. No need to wake.");
+                        }
+                    }
+                    else
+                    {
+                        Debug.Console(1, this, "Room OnFeedback state: {0}", OnFeedback.BoolValue);
+                    }
+
+                    // report back when done
+                    if (successCallback != null)
+                        successCallback();
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(1, this, "ERROR in routing: {0}", e);
+                }
+
+                SourceSelectLock.Leave();
+            }, 0); // end of CTimer
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="route"></param>
+        void DoRouteItem(SourceRouteListItem route)
+        {
+            // if there is a $defaultAll on route, run two separate
+            if (route.DestinationKey.Equals("$defaultAll", StringComparison.OrdinalIgnoreCase))
+            {
+                foreach (var display in Displays)
+                {
+                    var tempVideo = new SourceRouteListItem
+                    {
+                        DestinationKey = display.Key,
+                        SourceKey = route.SourceKey,
+                        Type = eRoutingSignalType.Video
+                    };
+                    DoRoute(tempVideo);
+                }
+            }
+            else
+                DoRoute(route);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="route"></param>
+        /// <returns></returns>
+        bool DoRoute(SourceRouteListItem route)
+        {
+            IRoutingSink dest = null;
+
+            if (route.DestinationKey.Equals("$defaultaudio", StringComparison.OrdinalIgnoreCase))
+                dest = DefaultAudioDevice as IRoutingSink;
+            //else if (route.DestinationKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
+            //    dest = DefaultDisplay;
+            else
+                dest = DeviceManager.GetDeviceForKey(route.DestinationKey) as IRoutingSink;
+
+            if (dest == null)
+            {
+                Debug.Console(1, this, "Cannot route, unknown destination '{0}'", route.DestinationKey);
+                return false;
+            }
+
+            if (route.SourceKey.Equals("$off", StringComparison.OrdinalIgnoreCase))
+            {
+                dest.ReleaseRoute();
+                if (dest is IHasPowerControl)
+                    (dest as IHasPowerControl).PowerOff();
+
+            }
+            else
+            {
+                var source = DeviceManager.GetDeviceForKey(route.SourceKey) as IRoutingOutputs;
+                if (source == null)
+                {
+                    Debug.Console(1, this, "Cannot route unknown source '{0}' to {1}", route.SourceKey, route.DestinationKey);
+                    return false;
+                }
+                dest.ReleaseAndMakeRoute(source, route.Type);
+            }
+            return true;
+        }
+
+        public override void RoomVacatedForTimeoutPeriod(object o)
+        {
+            //Implement this
+        }
+
+        /// <summary>
+        /// Does what it says
+        /// </summary>
+        public override void SetDefaultLevels()
+        {
+            Debug.Console(1, this, "Restoring default levels");
+            var vc = CurrentVolumeControls as IBasicVolumeWithFeedback;
+            if (vc != null)
+                vc.SetVolume(DefaultVolume);
+        }
+        /// <summary>
+        /// Will power the room on with the last-used source
+        /// </summary>
+        public override void PowerOnToDefaultOrLastSource()
+        {
+            if (!EnablePowerOnToLastSource || LastSourceKey == null)
+                return;
+            RunRouteAction(LastSourceKey);
+        }
+
+        /// <summary>
+        /// Runs "roomOff" action on all rooms not set to ExcludeFromGlobalFunctions
+        /// </summary>
+        public static void AllRoomsOff()
+        {
+            var allRooms = DeviceManager.AllDevices.Where(d =>
+                d is IEssentialsRoom && !(d as IEssentialsHuddleSpaceRoom).ExcludeFromGlobalFunctions);
+            foreach (var room in allRooms)
+                (room as IEssentialsHuddleSpaceRoom).RunRouteAction("roomOff");
+        }
+
+
+        /// <summary>
+        /// Setup the external sources for the Cisco Touch 10 devices that support IHasExternalSourceSwitch
+        /// </summary>
+        private void SetCodecExternalSources()
+        {
+            var videoCodecWithExternalSwitching = VideoCodec as IHasExternalSourceSwitching;
+
+            if (videoCodecWithExternalSwitching == null || !videoCodecWithExternalSwitching.ExternalSourceListEnabled)
+            {
+                return;
+            }
+
+            try
+            {
+                // Get the tie line that the external switcher is connected to
+                string codecInputConnectorName = ConfigReader.ConfigObject.TieLines.SingleOrDefault(
+                    x => x.DestinationKey == VideoCodec.Key && x.DestinationPort == videoCodecWithExternalSwitching.ExternalSourceInputPort).DestinationPort;
+
+                videoCodecWithExternalSwitching.ClearExternalSources();
+                videoCodecWithExternalSwitching.RunRouteAction = RunRouteActionCodec;
+                var srcList = ConfigReader.ConfigObject.SourceLists.SingleOrDefault(x => x.Key == SourceListKey).Value.OrderBy(kv => kv.Value.Order); ;
+
+                foreach (var kvp in srcList)
+                {
+                    var srcConfig = kvp.Value;
+
+                    if (kvp.Key != DefaultCodecRouteString && kvp.Key != "roomOff")
+                    {
+                        videoCodecWithExternalSwitching.AddExternalSource(codecInputConnectorName, kvp.Key, srcConfig.PreferredName, PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.eExternalSourceType.desktop);
+                        videoCodecWithExternalSwitching.SetExternalSourceState(kvp.Key, PepperDash.Essentials.Devices.Common.VideoCodec.Cisco.eExternalSourceMode.Ready);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Console(2, this, "Error setting codec external sources: {0}", e);
+            }
+        }
+
+        private void SetCodecBranding()
+        {
+            var vcWithBranding = VideoCodec as IHasBranding;
+
+            if (vcWithBranding == null) return;
+
+            Debug.Console(1, this, "Setting Codec Branding");
+            vcWithBranding.InitializeBranding(Key);
+        }
+
+        #region IPrivacy Members
+
+
+        public void PrivacyModeOff()
+        {
+            VideoCodec.PrivacyModeOff();
+        }
+
+        public void PrivacyModeOn()
+        {
+            VideoCodec.PrivacyModeOn();
+        }
+
+        public void PrivacyModeToggle()
+        {
+            VideoCodec.PrivacyModeToggle();
+        }
+
+        #endregion
+
+    }
+}

PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs

@@ -101,7 +101,7 @@ namespace PepperDash.Essentials
             }
         }
 
-        public EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; private set; }
+        public EssentialsConferenceRoomPropertiesConfig PropertiesConfig { get; private set; }
 
 		public IRoutingSinkWithSwitching DefaultDisplay { get; private set; }
 		public IBasicVolumeControls DefaultAudioDevice { get; private set; }
@@ -210,7 +210,7 @@ namespace PepperDash.Essentials
             {
                 PropertiesConfig = JsonConvert.DeserializeObject<EssentialsHuddleVtc1PropertiesConfig>
                     (config.Properties.ToString());
-                DefaultDisplay = DeviceManager.GetDeviceForKey(PropertiesConfig.DefaultDisplayKey) as IRoutingSinkWithSwitching;
+                DefaultDisplay = DeviceManager.GetDeviceForKey((PropertiesConfig as EssentialsHuddleVtc1PropertiesConfig).DefaultDisplayKey) as IRoutingSinkWithSwitching;
 
                 VideoCodec = DeviceManager.GetDeviceForKey(PropertiesConfig.VideoCodecKey) as
                     PepperDash.Essentials.Devices.Common.VideoCodec.VideoCodecBase;

PepperDashEssentials/Room/Types/Interfaces/IEssentialsHuddleVtc1Room.cs

@@ -10,7 +10,9 @@ namespace PepperDash.Essentials
     public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange,
          IPrivacy, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback
     {
-        EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
+        EssentialsConferenceRoomPropertiesConfig PropertiesConfig { get; }
+
+        bool ExcludeFromGlobalFunctions { get; }
 
         void RunRouteAction(string routeKey);
 

PepperDashEssentials/UI/EssentialsTouchpanelController.cs

@@ -16,6 +16,8 @@ namespace PepperDash.Essentials
 {
     public class EssentialsTouchpanelController : EssentialsDevice, IHasBasicTriListWithSmartObject
 	{
+        private CrestronTouchpanelPropertiesConfig _propertiesConfig;
+
 		public BasicTriListWithSmartObject Panel { get; private set; }
 
 		public PanelDriverBase PanelDriver { get; private set; }
@@ -27,7 +29,14 @@ namespace PepperDash.Essentials
 			: base(key, name)
 		{
 			Panel = tsw;
-			tsw.LoadSmartObjects(sgdPath);
+
+            if (!string.IsNullOrEmpty(sgdPath))
+                Panel.LoadSmartObjects(sgdPath);
+            else
+                Debug.Console(1, this, "No SGD file path defined");
+
+
+
 			tsw.SigChange += Panel_SigChange;
 		}
 
@@ -37,7 +46,7 @@ namespace PepperDash.Essentials
             Panel = dge;
 
             if (!string.IsNullOrEmpty(sgdPath))
-                dge.LoadSmartObjects(sgdPath);
+                Panel.LoadSmartObjects(sgdPath);
             else
                 Debug.Console(1, this, "No SGD file path defined");
 
@@ -50,6 +59,7 @@ namespace PepperDash.Essentials
 		public EssentialsTouchpanelController(string key, string name, string type, CrestronTouchpanelPropertiesConfig props, uint id)
 			: base(key, name)
 		{
+            _propertiesConfig = props;
 
             Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Creating touchpanel hardware...");
 			type = type.ToLower();
@@ -61,6 +71,8 @@ namespace PepperDash.Essentials
                     app.ParameterProjectName.Value = props.ProjectName;
                     Panel = app;
                 }
+                else if (type == "xpanel")
+                    Panel = new XpanelForSmartGraphics(id, Global.ControlSystem);
                 else if (type == "tsw550")
                     Panel = new Tsw550(id, Global.ControlSystem);
                 else if (type == "tsw552")
@@ -134,10 +146,194 @@ namespace PepperDash.Essentials
             Panel.LoadSmartObjects(sgdName);
             Panel.SigChange += Panel_SigChange;
 
+            AddPostActivationAction(() =>
+            {
+                // Check for IEssentialsRoomCombiner in DeviceManager and if found, subscribe to its event
+                var roomCombiner = DeviceManager.AllDevices.FirstOrDefault((d) => d is IEssentialsRoomCombiner) as IEssentialsRoomCombiner;
+
+                if (roomCombiner != null)
+                {
+                    // Subscribe to the even
+                    roomCombiner.RoomCombinationScenarioChanged += new EventHandler<EventArgs>(roomCombiner_RoomCombinationScenarioChanged);
+
+                    // Connect to the initial roomKey
+                    if (roomCombiner.CurrentScenario != null)
+                    {
+                        // Use the current scenario
+                        DetermineRoomKeyFromScenario(roomCombiner.CurrentScenario);
+                    }
+                    else
+                    {
+                        // Current Scenario not yet set.  Use default 
+                        SetupPanelDrivers(_propertiesConfig.DefaultRoomKey);
+                    }
+                }
+                else
+                {
+                    // No room combiner, use the default key
+                    SetupPanelDrivers(_propertiesConfig.DefaultRoomKey);
+                }
+            });
 		}
 
+        void roomCombiner_RoomCombinationScenarioChanged(object sender, EventArgs e)
+        {
+            var roomCombiner = sender as IEssentialsRoomCombiner;
+
+            DetermineRoomKeyFromScenario(roomCombiner.CurrentScenario);
+        }
+
+        /// <summary>
+        /// Determines the room key to use based on the scenario
+        /// </summary>
+        /// <param name="scenario"></param>
+        void DetermineRoomKeyFromScenario(IRoomCombinationScenario scenario)
+        {
+            string newRoomKey = null;
+
+            if (scenario.UiMap.ContainsKey(Key))
+            {
+                newRoomKey = scenario.UiMap[Key];
+            }
+            else if (scenario.UiMap.ContainsKey(_propertiesConfig.DefaultRoomKey))
+            {
+                newRoomKey = scenario.UiMap[_propertiesConfig.DefaultRoomKey];
+            }
+
+            SetupPanelDrivers(newRoomKey);
+        }
+
+
+        /// <summary>
+        /// Sets up drivers and links them to the room specified
+        /// </summary>
+        /// <param name="roomKey">key of room to link the drivers to</param>
+        void SetupPanelDrivers(string roomKey)
+        {
+            // Clear out any existing actions
+            Panel.ClearAllSigActions();
+
+            Debug.Console(0, this, "Linking TP '{0}' to Room '{1}'", Key, roomKey);
+
+            var mainDriver = new EssentialsPanelMainInterfaceDriver(Panel, _propertiesConfig);
+            // Then the sub drivers
+
+            // spin up different room drivers depending on room type
+            var room = DeviceManager.GetDeviceForKey(roomKey);
+            if (room is IEssentialsHuddleSpaceRoom)
+            {
+                // Screen Saver Driver
+
+                mainDriver.ScreenSaverController = new ScreenSaverController(mainDriver, _propertiesConfig);
+
+                // Header Driver
+                Debug.Console(0, this, "Adding header driver");
+                mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, _propertiesConfig);
+
+                // AV Driver
+                Debug.Console(0, this, "Adding huddle space AV driver");
+                var avDriver = new EssentialsHuddlePanelAvFunctionsDriver(mainDriver, _propertiesConfig);
+                avDriver.DefaultRoomKey = roomKey;
+                mainDriver.AvDriver = avDriver;
+                avDriver.CurrentRoom = room as IEssentialsHuddleSpaceRoom;
+
+                // Environment Driver
+                if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
+                {
+                    Debug.Console(0, this, "Adding environment driver");
+                    mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, _propertiesConfig);
+
+                    mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
+                }
+
+                mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
+
+                if (Panel is TswFt5ButtonSystem)
+                {
+                    var tsw = Panel as TswFt5ButtonSystem;
+                    // Wire up hard keys
+                    tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
+                    if (mainDriver.EnvironmentDriver != null)
+                        tsw.Lights.UserObject = new Action<bool>(b =>
+                        {
+                            if (!b)
+                            {
+                                mainDriver.EnvironmentDriver.Toggle();
+                            }
+                        });
+                    tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
+                    tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
+                }
+            }
+            else if (room is IEssentialsHuddleVtc1Room)
+            {
+                Debug.Console(0, this, "Adding huddle space VTC AV driver");
+
+                // Screen Saver Driver
+                mainDriver.ScreenSaverController = new ScreenSaverController(mainDriver, _propertiesConfig);
+
+                // Header Driver
+                mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, _propertiesConfig);
+
+                // AV Driver
+                var avDriver = new EssentialsHuddleVtc1PanelAvFunctionsDriver(mainDriver, _propertiesConfig);
+
+                var codecDriver = new PepperDash.Essentials.UIDrivers.VC.EssentialsVideoCodecUiDriver(Panel, avDriver,
+                    (room as IEssentialsHuddleVtc1Room).VideoCodec, mainDriver.HeaderDriver);
+                avDriver.SetVideoCodecDriver(codecDriver);
+                avDriver.DefaultRoomKey = roomKey;
+                mainDriver.AvDriver = avDriver;
+                avDriver.CurrentRoom = room as IEssentialsHuddleVtc1Room;
+
+                // Environment Driver
+                if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
+                {
+                    Debug.Console(0, this, "Adding environment driver");
+                    mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, _propertiesConfig);
+
+                    mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
+                }
+
+                mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
+
+
+                if (Panel is TswFt5ButtonSystem)
+                {
+                    var tsw = Panel as TswFt5ButtonSystem;
+                    // Wire up hard keys
+                    tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.EndMeetingPress(); });
+                    if (mainDriver.EnvironmentDriver != null)
+                        tsw.Lights.UserObject = new Action<bool>(b =>
+                        {
+                            if (!b)
+                            {
+                                mainDriver.EnvironmentDriver.Toggle();
+                            }
+                        });
+                    tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
+                    tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
+                }
+
+                LoadAndShowDriver(mainDriver);
+            }
+            else
+            {
+                Debug.Console(0, this, "ERROR: Cannot load AvFunctionsDriver for room '{0}'", roomKey);
+            }
+
+        }
+
 		public void LoadAndShowDriver(PanelDriverBase driver)
 		{
+            if (PanelDriver != null)
+            {
+                var mainDriver = PanelDriver as EssentialsPanelMainInterfaceDriver;
+                if (mainDriver != null)
+                {
+                    mainDriver.Dispose();
+                }
+            }
+
 			PanelDriver = driver;
 			driver.Show();
 		}
@@ -148,7 +344,6 @@ namespace PepperDash.Essentials
 				PanelDriver.BackButtonPressed();
 		}
 
-
 		void ExtenderSystemReservedSigs_DeviceExtenderSigChange(DeviceExtender currentDeviceExtender, SigEventArgs args)
 		{
 			// If the sig is transitioning on, mark it in case it was home button that transitioned it
@@ -225,119 +420,6 @@ namespace PepperDash.Essentials
 
             var panelController = new EssentialsTouchpanelController(dc.Key, dc.Name, dc.Type, props, comm.IpIdInt);
 
-            panelController.AddPostActivationAction(() =>
-            {
-                var mainDriver = new EssentialsPanelMainInterfaceDriver(panelController.Panel, props);
-                // Then the sub drivers
-
-                // spin up different room drivers depending on room type
-                var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey);
-                if (room is IEssentialsHuddleSpaceRoom)
-                {
-                    // Screen Saver Driver
-                    mainDriver.ScreenSaverController = new ScreenSaverController(mainDriver, props);
-
-                    // Header Driver
-                    Debug.Console(0, panelController, "Adding header driver");
-                    mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
-
-                    // AV Driver
-                    Debug.Console(0, panelController, "Adding huddle space AV driver");
-                    var avDriver = new EssentialsHuddlePanelAvFunctionsDriver(mainDriver, props);
-                    avDriver.DefaultRoomKey = props.DefaultRoomKey;
-                    mainDriver.AvDriver = avDriver;
-                    avDriver.CurrentRoom = room as IEssentialsHuddleSpaceRoom;
-
-                    // Environment Driver
-                    if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
-                    {
-                        Debug.Console(0, panelController, "Adding environment driver");
-                        mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
-
-                        mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
-                    }
-
-                    mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
-
-                    panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
-
-                    if (panelController.Panel is TswFt5ButtonSystem)
-                    {
-                        var tsw = panelController.Panel as TswFt5ButtonSystem;
-                        // Wire up hard keys
-                        tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
-                        //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
-                        if (mainDriver.EnvironmentDriver != null)
-                            tsw.Lights.UserObject = new Action<bool>(b =>
-                            {
-                                if (!b)
-                                {
-                                    //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
-                                    mainDriver.EnvironmentDriver.Toggle();
-                                }
-                            });
-                        tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
-                        tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
-                    }
-                }
-                else if (room is IEssentialsHuddleVtc1Room)
-                {
-                    Debug.Console(0, panelController, "Adding huddle space VTC AV driver");
-
-                    // Screen Saver Driver
-                    mainDriver.ScreenSaverController = new ScreenSaverController(mainDriver, props);
-
-                    // Header Driver
-                    mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
-
-                    // AV Driver
-                    var avDriver = new EssentialsHuddleVtc1PanelAvFunctionsDriver(mainDriver, props);
-
-                    var codecDriver = new PepperDash.Essentials.UIDrivers.VC.EssentialsVideoCodecUiDriver(panelController.Panel, avDriver,
-                        (room as IEssentialsHuddleVtc1Room).VideoCodec, mainDriver.HeaderDriver);
-                    avDriver.SetVideoCodecDriver(codecDriver);
-                    avDriver.DefaultRoomKey = props.DefaultRoomKey;
-                    mainDriver.AvDriver = avDriver;
-                    avDriver.CurrentRoom = room as IEssentialsHuddleVtc1Room;
-
-                    // Environment Driver
-                    if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
-                    {
-                        Debug.Console(0, panelController, "Adding environment driver");
-                        mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
-
-                        mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
-                    }
-
-                    mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
-
-                    panelController.LoadAndShowDriver(mainDriver);  // This is a little convoluted.
-
-                    if (panelController.Panel is TswFt5ButtonSystem)
-                    {
-                        var tsw = panelController.Panel as TswFt5ButtonSystem;
-                        // Wire up hard keys
-                        tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.EndMeetingPress(); });
-                        //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
-                        if (mainDriver.EnvironmentDriver != null)
-                            tsw.Lights.UserObject = new Action<bool>(b =>
-                            {
-                                if (!b)
-                                {
-                                    //mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
-                                    mainDriver.EnvironmentDriver.Toggle();
-                                }
-                            });
-                        tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
-                        tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
-                    }
-                }
-                else
-                {
-                    Debug.Console(0, panelController, "ERROR: Cannot load AvFunctionsDriver for room '{0}'", props.DefaultRoomKey);
-                }
-            });
-
             return panelController;
         }
     }

PepperDashEssentials/UI/SubpageReferenceListSourceItem.cs

@@ -14,6 +14,8 @@ namespace PepperDash.Essentials
     {
         public SourceListItem SourceItem { get; private set; }
 
+        private IHasCurrentSourceInfoChange _room;
+
         public SubpageReferenceListSourceItem(uint index, SubpageReferenceList owner,
             SourceListItem sourceItem, Action<bool> routeAction)
             : base(index, owner)
@@ -25,6 +27,7 @@ namespace PepperDash.Essentials
 
         public void RegisterForSourceChange(IHasCurrentSourceInfoChange room)
         {
+            _room = room;
             room.CurrentSourceChange -= room_CurrentSourceInfoChange;
             room.CurrentSourceChange += room_CurrentSourceInfoChange;
         }
@@ -44,6 +47,9 @@ namespace PepperDash.Essentials
         {
             Owner.BoolInputSig(Index, 1).UserObject = null;
             Owner.StringInputSig(Index, 1).StringValue = "";
+
+            if(_room != null)
+                _room.CurrentSourceChange -= room_CurrentSourceInfoChange;
         }
 
         /// <summary>

PepperDashEssentials/UIDrivers/Essentials/EssentialsPanelMainInterfaceDriver.cs

@@ -11,7 +11,7 @@ namespace PepperDash.Essentials
 	/// <summary>
 	/// 
 	/// </summary>
-	public class EssentialsPanelMainInterfaceDriver : PanelDriverBase, IHasScreenSaverController
+	public class EssentialsPanelMainInterfaceDriver : PanelDriverBase, IHasScreenSaverController, IDisposable
 	{
         CTimer InactivityTimer;
 
@@ -69,6 +69,35 @@ namespace PepperDash.Essentials
             }
 		}
 
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            var avDriver = AvDriver as PanelDriverBase;
+            if (avDriver != null)
+            {
+                avDriver.Hide();
+            }
+            if (ScreenSaverController != null)
+            {
+                ScreenSaverController.Dispose();
+            }
+            if (HeaderDriver != null)
+            {
+                HeaderDriver.Hide();
+            }
+            if (EnvironmentDriver != null)
+            {
+                EnvironmentDriver.Hide();
+            }
+            if (CurrentChildDriver != null)
+            {
+                CurrentChildDriver.Hide();
+            }
+        }
+
+        #endregion
+
         void ExtenderTouchDetectionReservedSigs_DeviceExtenderSigChange(Crestron.SimplSharpPro.DeviceExtender currentDeviceExtender, Crestron.SimplSharpPro.SigEventArgs args)
         {
 
@@ -130,7 +159,7 @@ namespace PepperDash.Essentials
 			if(CurrentChildDriver != null)
 				CurrentChildDriver.BackButtonPressed();
 		}
-	}
+    }
 
     public interface IHasScreenSaverController
     {

PepperDashEssentials/UIDrivers/EssentialsHuddle/EssentialsHuddlePanelAvFunctionsDriver.cs

@@ -306,7 +306,7 @@ namespace PepperDash.Essentials
 
 			TriList.SetSigFalseAction(UIBoolJoin.DisplayPowerTogglePress, () =>
 				{
-                    if (CurrentRoom != null && CurrentRoom.DefaultDisplay is IHasPowerControl)
+                    if (CurrentRoom != null && CurrentRoom.DefaultDisplay != null && CurrentRoom.DefaultDisplay is IHasPowerControl)
                         (CurrentRoom.DefaultDisplay as IHasPowerControl).PowerToggle();
 				});
 

PepperDashEssentials/UIDrivers/EssentialsHuddleVTC/EssentialsHuddleVtc1PanelAvFunctionsDriver.cs

@@ -354,7 +354,7 @@ namespace PepperDash.Essentials
 
             TriList.SetSigFalseAction(UIBoolJoin.DisplayPowerTogglePress, () =>
             {
-                if (CurrentRoom != null && CurrentRoom.DefaultDisplay is IHasPowerControl)
+                if (CurrentRoom != null && CurrentRoom.DefaultDisplay != null && CurrentRoom.DefaultDisplay is IHasPowerControl)
                     (CurrentRoom.DefaultDisplay as IHasPowerControl).PowerToggle();
             });
 

PepperDashEssentials/UIDrivers/ScreenSaverController.cs

@@ -12,7 +12,7 @@ namespace PepperDash.Essentials
     /// <summary>
     /// Driver responsible for controlling the screenshaver showing the client logo, MC connection information and QR Code.  Moves the elements around to prevent screen burn in
     /// </summary>
-    public class ScreenSaverController : PanelDriverBase
+    public class ScreenSaverController : PanelDriverBase, IDisposable
     {
 
         /// <summary>
@@ -42,7 +42,7 @@ namespace PepperDash.Essentials
 
             PositionInterlock = new JoinedSigInterlock(parent.TriList);
 
-            var cmdName = String.Format("shwscrsvr-{0}", parent.TriList.ID);
+            var cmdName = String.Format("shwscrsvr-{0:X2}", parent.TriList.ID);
 
             CrestronConsole.AddNewConsoleCommand((o) => Show(), cmdName, "Shows Panel Screensaver", ConsoleAccessLevelEnum.AccessOperator);
 
@@ -51,6 +51,8 @@ namespace PepperDash.Essentials
 
         public override void Show()
         {
+            Debug.Console(2, "Showing ScreenSaverController: {0:X2}", TriList.ID);
+
             if (_parent.AvDriver != null)
             {
                 _parent.AvDriver.PopupInterlock.ShowInterlocked(UIBoolJoin.MCScreenSaverVisible);
@@ -65,10 +67,11 @@ namespace PepperDash.Essentials
 
         public override void Hide()
         {
-            Debug.Console(1, "Hiding ScreenSaverController");
+            Debug.Console(2, "Hiding ScreenSaverController: {0:X2}", TriList.ID);
 
             if (PositionTimer != null)
             {
+                Debug.Console(2, "Stopping PositionTimer: {0:X2}", TriList.ID);
                 PositionTimer.Stop();
                 PositionTimer.Dispose();
                 PositionTimer = null;
@@ -86,6 +89,8 @@ namespace PepperDash.Essentials
 
         void StartPositionTimer()
         {
+            Debug.Console(2,  "Starting Position Timer: {0:X2}", TriList.ID);
+
             if (PositionTimer == null)
             {
                 PositionTimer = new CTimer((o) => PositionTimerExpired(), PositionTimeoutMs);
@@ -117,7 +122,7 @@ namespace PepperDash.Essentials
                 CurrentPositionIndex = 0;
             }
 
-            Debug.Console(1, "ScreenSaver Position Timer Expired: Setting new position: {0}", CurrentPositionIndex);
+            Debug.Console(2, "ScreenSaver Position Timer Expired: Setting new position: {0} ID: {1:X2}", CurrentPositionIndex, TriList.ID);
         }
 
         //
@@ -129,9 +134,19 @@ namespace PepperDash.Essentials
 
         void ClearAllPositions()
         {
-            Debug.Console(1, "Hiding all screensaver positions");
+            Debug.Console(2, "Hiding all screensaver positions: {0:X2}", TriList.ID);
+
             PositionInterlock.HideAndClear();
         }
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            Hide();
+        }
+
+        #endregion
     }
  
 }

PepperDashEssentials/UIDrivers/VC/EssentialsVideoCodecUiDriver.cs

@@ -632,7 +632,6 @@ namespace PepperDash.Essentials.UIDrivers.VC
 
                 VCControlsInterlock.StatusChanged += new EventHandler<StatusChangedEventArgs>(VCControlsInterlock_StatusChanged);
 
-
                 var codecOffCameras = Codec as IHasCameraOff;
 
                 var supportsCameraOffMode = Codec.SupportsCameraOff;
@@ -643,6 +642,7 @@ namespace PepperDash.Essentials.UIDrivers.VC
 
                 if (codecAutoCameras != null && supportsAutoCameraMode)
                 {
+
                     CameraModeList.SetItemButtonAction(1,(b) => codecAutoCameras.CameraAutoModeOn());
                     TriList.SmartObjects[UISmartObjectJoin.VCCameraMode].BooleanInput["Item 1 Visible"].BoolValue = true;
                     codecAutoCameras.CameraAutoModeIsOnFeedback.LinkInputSig(CameraModeList.SmartObject.BooleanInput["Item 1 Selected"]);
@@ -672,6 +672,7 @@ namespace PepperDash.Essentials.UIDrivers.VC
                             }
 
                         };
+
                 }
 
                 // Manual button always visible
@@ -683,6 +684,7 @@ namespace PepperDash.Essentials.UIDrivers.VC
 
                 if (codecOffCameras != null && supportsCameraOffMode)
                 {
+
                     TriList.SmartObjects[UISmartObjectJoin.VCCameraMode].BooleanInput["Item 3 Visible"].BoolValue = true;
                     codecOffCameras.CameraIsOffFeedback.LinkInputSig(CameraModeList.SmartObject.BooleanInput["Item 3 Selected"]);
                     CameraModeList.SetItemButtonAction(3, (b) => codecOffCameras.CameraOff());
@@ -710,6 +712,7 @@ namespace PepperDash.Essentials.UIDrivers.VC
                             }
 
                         };
+
                 }
             }
 

devjson commands.json

@@ -42,3 +42,6 @@ devjson:2 {"deviceKey":"display01Comm-com", "methodName":"SendText", "params": [
 
 devjson:10 {"deviceKey":"dmLink-ssh", "methodName":"Connect", "params": []} 
 
+devjson:2 {"deviceKey":"roomCombiner", "methodName":"SetRoomCombinationScenario", "params": ["combined"]} 
+
+devjson:2 {"deviceKey":"roomCombiner", "methodName":"SetRoomCombinationScenario", "params": ["divided"]} 

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

@@ -46,14 +46,6 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete RawOccupancyUsFeedback = new JoinDataComplete(new JoinData { JoinNumber = 7, JoinSpan = 1 },
             new JoinMetadata { Description = "Raw Occupancy Us Feedback", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
 
-        [JoinName("IdentityModeOn")]
-        public JoinDataComplete IdentityMode = new JoinDataComplete(new JoinData { JoinNumber = 8, JoinSpan = 1 },
-            new JoinMetadata { Description = "Enable Identity Mode", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
-
-        [JoinName("IdentityModeFeedback")]
-        public JoinDataComplete IdentityModeFeedback = new JoinDataComplete(new JoinData { JoinNumber = 8, JoinSpan = 1 },
-            new JoinMetadata { Description = "Identity Mode Feedback", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
-
         [JoinName("EnableLedFlash")]
         public JoinDataComplete EnableLedFlash = new JoinDataComplete(new JoinData { JoinNumber = 11, JoinSpan = 1 },
             new JoinMetadata { Description = "Enable Led Flash", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });

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

@@ -5,9 +5,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 {
     public class GlsPartitionSensorJoinMap : JoinMapBaseAdvanced
     {
-
-        #region Digital
-
         [JoinName("IsOnline")]
         public JoinDataComplete IsOnline = new JoinDataComplete(
             new JoinData
@@ -22,7 +19,20 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
                 JoinType = eJoinType.Digital
             });
 
-        
+        [JoinName("Name")]
+        public JoinDataComplete Name = new JoinDataComplete(
+            new JoinData
+            {
+                JoinNumber = 1,
+                JoinSpan = 1
+            },
+            new JoinMetadata
+            {
+                Description = "Sensor Name",
+                JoinCapabilities = eJoinCapabilities.ToSIMPL,
+                JoinType = eJoinType.Serial
+            });
+
         [JoinName("Enable")]
         public JoinDataComplete Enable = new JoinDataComplete(
             new JoinData
@@ -91,11 +101,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
                 Description = "Sensor Decrease Sensitivity",
                 JoinCapabilities = eJoinCapabilities.FromSIMPL,
                 JoinType = eJoinType.Digital
-            });        
-
-        #endregion
-
-        #region Analog
+            });
 
         [JoinName("Sensitivity")]
         public JoinDataComplete Sensitivity = new JoinDataComplete(
@@ -111,28 +117,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
                 JoinType = eJoinType.Analog
             });
 
-        #endregion
-
-
-        #region Serial
-
-        [JoinName("Name")]
-        public JoinDataComplete Name = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 1,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Sensor Name",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        #endregion
-
-
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>

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

@@ -20,21 +20,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("SendDtmfToSpecificCallIndex")]
-        public JoinDataComplete SendDtmfToSpecificCallIndex = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 10,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "If High, will send DTMF tones to the call set by SelectCall analog.  If low sends DTMF tones to last connected call.",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("Dtmf1")]
+		[JoinName("1")]
 		public JoinDataComplete Dtmf1 = new JoinDataComplete(
 			new JoinData
 			{
@@ -48,7 +34,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf2")]
+		[JoinName("2")]
 		public JoinDataComplete Dtmf2 = new JoinDataComplete(
 			new JoinData
 			{
@@ -62,7 +48,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf3")]
+		[JoinName("3")]
 		public JoinDataComplete Dtmf3 = new JoinDataComplete(
 			new JoinData
 			{
@@ -76,7 +62,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf4")]
+		[JoinName("4")]
 		public JoinDataComplete Dtmf4 = new JoinDataComplete(
 			new JoinData
 			{
@@ -90,7 +76,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf5")]
+		[JoinName("5")]
 		public JoinDataComplete Dtmf5 = new JoinDataComplete(
 			new JoinData
 			{
@@ -104,7 +90,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf6")]
+		[JoinName("6")]
 		public JoinDataComplete Dtmf6 = new JoinDataComplete(
 			new JoinData
 			{
@@ -118,7 +104,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf7")]
+		[JoinName("7")]
 		public JoinDataComplete Dtmf7 = new JoinDataComplete(
 			new JoinData
 			{
@@ -132,7 +118,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf8")]
+		[JoinName("8")]
 		public JoinDataComplete Dtmf8 = new JoinDataComplete(
 			new JoinData
 			{
@@ -146,7 +132,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf9")]
+		[JoinName("9")]
 		public JoinDataComplete Dtmf9 = new JoinDataComplete(
 			new JoinData
 			{
@@ -160,7 +146,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("Dtmf0")]
+		[JoinName("0")]
 		public JoinDataComplete Dtmf0 = new JoinDataComplete(
 			new JoinData
 			{
@@ -174,7 +160,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("DtmfStar")]
+		[JoinName("*")]
 		public JoinDataComplete DtmfStar = new JoinDataComplete(
 			new JoinData
 			{
@@ -188,7 +174,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("DtmfPound")]
+		[JoinName("#")]
 		public JoinDataComplete DtmfPound = new JoinDataComplete(
 			new JoinData
 			{
@@ -202,8 +188,8 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("EndAllCalls")]
-		public JoinDataComplete EndAllCalls = new JoinDataComplete(
+		[JoinName("EndCall")]
+		public JoinDataComplete EndCall = new JoinDataComplete(
 			new JoinData
 			{
 				JoinNumber = 24,
@@ -211,7 +197,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "End All Calls",
+				Description = "Hang Up",
 				JoinCapabilities = eJoinCapabilities.FromSIMPL,
 				JoinType = eJoinType.Digital
 			});
@@ -240,7 +226,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			new JoinMetadata
 			{
 				Description = "Speed Dial",
-				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
 				JoinType = eJoinType.Digital
 			});
 
@@ -295,12 +281,12 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Dial manual string specified by CurrentDialString serial join",
+				Description = "Dial manual string",
 				JoinCapabilities = eJoinCapabilities.FromSIMPL,
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("DialPhone")]
+		[JoinName("DialPhoneCall")]
 		public JoinDataComplete DialPhone = new JoinDataComplete(
 			new JoinData
 			{
@@ -328,7 +314,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("HangUpPhone")]
+		[JoinName("EndPhoneCall")]
 		public JoinDataComplete HangUpPhone = new JoinDataComplete(
 			new JoinData
 			{
@@ -337,53 +323,11 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Hang Up Phone",
+				Description = "Hang Up PHone",
 				JoinCapabilities = eJoinCapabilities.FromSIMPL,
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("EndCallStart")]
-        public JoinDataComplete EndCallStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 81,
-                JoinSpan = 8
-            },
-            new JoinMetadata
-            {
-                Description = "End a specific call by call index. ",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("JoinAllCalls")]
-        public JoinDataComplete JoinAllCalls = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 90,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Join all calls",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("JoinCallStart")]
-        public JoinDataComplete JoinCallStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 91,
-                JoinSpan = 8
-            },
-            new JoinMetadata
-            {
-                Description = "Join a specific call by call index. ",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
 		[JoinName("DirectorySearchBusy")]
 		public JoinDataComplete DirectorySearchBusy = new JoinDataComplete(
 			new JoinData
@@ -464,7 +408,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			new JoinMetadata
 			{
 				Description = "Go to Directory Root",
-				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
 				JoinType = eJoinType.Digital
 			});
 
@@ -496,33 +440,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("DirectoryDisableAutoDialSelectedLine")]
-        public JoinDataComplete DirectoryDisableAutoDialSelectedLine = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 107,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Set high to disable automatic dialing of a contact when selected",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("DirectoryDialSelectedContactMethod")]
-        public JoinDataComplete DirectoryDialSelectedContactMethod = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 108,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Pulse to dial the selected contact method",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
 
 		[JoinName("CameraTiltUp")]
 		public JoinDataComplete CameraTiltUp = new JoinDataComplete(
@@ -608,48 +525,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("CameraFocusNear")]
-        public JoinDataComplete CameraFocusNear = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 117,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Camera Focus Near",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("CameraFocusFar")]
-        public JoinDataComplete CameraFocusFar = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 118,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Camera Focus Far",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("CameraFocusAuto")]
-        public JoinDataComplete CameraFocusAuto = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 119,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Camera Auto Focus Trigger",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
 		[JoinName("CameraPresetSave")]
 		public JoinDataComplete CameraPresetSave = new JoinDataComplete(
 			new JoinData
@@ -659,7 +534,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Pulse to save selected preset spcified by CameraPresetSelect analog join.  FB will pulse for 3s when preset saved.",
+				Description = "Save Selected Preset",
 				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Digital
 			});
@@ -673,7 +548,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Camera Mode Auto.  Enables camera auto tracking mode, with feedback",
+				Description = "Camera Mode Auto",
 				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Digital
 			});
@@ -687,7 +562,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Camera Mode Manual.  Disables camera auto tracking mode, with feedback",
+				Description = "Camera Mode Manual",
 				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Digital
 			});
@@ -701,7 +576,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Camera Mode Off.  Disables camera video, with feedback. Works like video mute.",
+				Description = "Camera Mode Off",
 				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Digital
 			});
@@ -930,34 +805,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("RemoveSelectedRecentCallItem")]
-        public JoinDataComplete RemoveSelectedRecentCallItem = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 181,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Pulse to remove the selected recent call item specified by the SelectRecentCallItem analog join",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("DialSelectedRecentCallItem")]
-        public JoinDataComplete DialSelectedRecentCallItem = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 182,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Pulse to dial the selected recent call item specified by the SelectRecentCallItem analog join",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
 		[JoinName("SourceShareStart")]
 		public JoinDataComplete SourceShareStart = new JoinDataComplete(
 			new JoinData
@@ -1023,81 +870,11 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Toggles selfview position",
+				Description = "advance selfview position",
 				JoinCapabilities = eJoinCapabilities.FromSIMPL,
 				JoinType = eJoinType.Digital
 			});
 
-        [JoinName("HoldAllCalls")]
-        public JoinDataComplete HoldAllCalls = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 220,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Holds all calls",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("HoldCallsStart")]
-        public JoinDataComplete HoldCallsStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 221,
-                JoinSpan = 8
-            },
-            new JoinMetadata
-            {
-                Description = "Holds Call at specified index. FB reported on Call Status XSIG",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("ResumeCallsStart")]
-        public JoinDataComplete ResumeCallsStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 231,
-                JoinSpan = 8
-            },
-            new JoinMetadata
-            {
-                Description = "Resume Call at specified index",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("MultiSiteOptionIsEnabled")]
-        public JoinDataComplete MultiSiteOptionIsEnabled = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 301,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Multi site option is enabled FB",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("AutoAnswerEnabled")]
-        public JoinDataComplete AutoAnswerEnabled = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 302,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Auto Answer is enabled FB",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
         [JoinName("ParticipantAudioMuteToggleStart")]
         public JoinDataComplete ParticipantAudioMuteToggleStart = new JoinDataComplete(
 			new JoinData 
@@ -1147,35 +924,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 
 		#region Analog
 
-        [JoinName("SelectCall")]
-        public JoinDataComplete SelectCall = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 24,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Sets the selected Call for DTMF commands. Valid values 1-8",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
-
-        [JoinName("ConnectedCallCount")]
-        public JoinDataComplete ConnectedCallCount = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 25,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the number of currently connected calls",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 		[JoinName("MinutesBeforeMeetingStart")]
 		public JoinDataComplete MinutesBeforeMeetingStart = new JoinDataComplete(
 			new JoinData
@@ -1199,25 +947,11 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Camera Number Select/FB.  1 based index.  Valid range is 1 to the value reported by CameraCount.",
+				Description = "Camera Number Select/FB",
 				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Analog
 			});
 
-        [JoinName("CameraCount")]
-        public JoinDataComplete CameraCount = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 61,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the number of cameras",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 		[JoinName("DirectoryRowCount")]
 		public JoinDataComplete DirectoryRowCount = new JoinDataComplete(
 			new JoinData
@@ -1246,34 +980,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Analog
 			});
 
-        [JoinName("SelectedContactMethodCount")]
-        public JoinDataComplete SelectedContactMethodCount = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 102,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Reports the number of contact methods for the selected contact",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
-        [JoinName("SelectContactMethod")]
-        public JoinDataComplete SelectContactMethod = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 103,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Selects a contact method by index",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 		[JoinName("CameraPresetSelect")]
 		public JoinDataComplete CameraPresetSelect = new JoinDataComplete(
 			new JoinData
@@ -1284,24 +990,10 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			new JoinMetadata
 			{
 				Description = "Camera Preset Select",
-				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Analog
 			});
 
-        [JoinName("FarEndPresetSelect")]
-        public JoinDataComplete FarEndPresetSelect = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 122,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Far End Preset Preset Select",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 		[JoinName("ParticipantCount")]
 		public JoinDataComplete ParticipantCount = new JoinDataComplete(
 			new JoinData
@@ -1344,48 +1036,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Analog
 			});
 
-        [JoinName("SelectRecentCallItem")]
-        public JoinDataComplete SelectRecentCallItem = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 180,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Select/FB for Recent Call Item.  Valid values 1 - 10",
-                JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
-        [JoinName("RecentCallOccurrenceType")]
-        public JoinDataComplete RecentCallOccurrenceType = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 181,
-                JoinSpan = 10
-            },
-            new JoinMetadata
-            {
-                Description = "Recent Call Occurrence Type. [0-3] 0 = Unknown, 1 = Placed, 2 = Received, 3 = NoAnswer",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
-        [JoinName("RecentCallCount")]
-        public JoinDataComplete RecentCallCount = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 191,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Recent Call Count",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 		#endregion
 
 
@@ -1401,12 +1051,12 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 			},
 			new JoinMetadata
 			{
-				Description = "Value to dial when ManualDial digital join is pulsed",
-				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				Description = "Current Dial String",
+				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
 				JoinType = eJoinType.Serial
 			});
 
-        [JoinName("PhoneDialString")]
+		[JoinName("PhoneString")]
 		public JoinDataComplete PhoneDialString = new JoinDataComplete(
 			new JoinData
 			{
@@ -1420,7 +1070,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Serial
 			});
 
-        [JoinName("CurrentCallData")]
+		[JoinName("CurrentCallName")]
 		public JoinDataComplete CurrentCallData = new JoinDataComplete(
 			new JoinData
 			{
@@ -1519,20 +1169,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Serial
 			});
 
-        [JoinName("ContactMethods")]
-        public JoinDataComplete ContactMethods = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 103,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Contact Methods - XSig, 10 entries",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
 		[JoinName("CameraPresetNames")]
 		public JoinDataComplete CameraPresetNames = new JoinDataComplete(
 			new JoinData
@@ -1547,8 +1183,8 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Serial
 			});
 
-        [JoinName("CurrentLayoutStringFb")]
-		public JoinDataComplete CurrentLayoutStringFb = new JoinDataComplete(
+		[JoinName("CameraLayoutStringFb")]
+		public JoinDataComplete CameraLayoutStringFb = new JoinDataComplete(
 			new JoinData
 			{
 				JoinNumber = 141,
@@ -1575,76 +1211,6 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				JoinType = eJoinType.Serial
 			});
 
-        [JoinName("CameraNamesFb")]
-        public JoinDataComplete CameraNamesFb = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 161,
-                JoinSpan = 10
-            },
-            new JoinMetadata
-            {
-                Description = "Camera Name Fb",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("SelectedRecentCallName")]
-        public JoinDataComplete SelectedRecentCallName = new JoinDataComplete(
-         new JoinData
-         {
-             JoinNumber = 171,
-             JoinSpan = 1
-         },
-         new JoinMetadata
-         {
-             Description = "Selected Recent Call Name",
-             JoinCapabilities = eJoinCapabilities.ToSIMPL,
-             JoinType = eJoinType.Serial
-         });
-
-        [JoinName("SelectedRecentCallNumber")]
-        public JoinDataComplete SelectedRecentCallNumber = new JoinDataComplete(
-         new JoinData
-         {
-             JoinNumber = 172,
-             JoinSpan = 1
-         },
-         new JoinMetadata
-         {
-             Description = "Selected Recent Call Number",
-             JoinCapabilities = eJoinCapabilities.ToSIMPL,
-             JoinType = eJoinType.Serial
-         });
-
-        [JoinName("RecentCallNamesStart")]
-        public JoinDataComplete RecentCallNamesStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 181,
-                JoinSpan = 10
-            },
-            new JoinMetadata
-            {
-                Description = "Recent Call Names",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("RecentCallTimesStart")]
-        public JoinDataComplete RecentCallTimesStart = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 191,
-                JoinSpan = 10
-            },
-            new JoinMetadata
-            {
-                Description = "Recent Calls Times",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
 		[JoinName("CurrentSource")]
 		public JoinDataComplete CurrentSource = new JoinDataComplete(
 			new JoinData
@@ -1671,77 +1237,7 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
 				Description = "advance selfview position",
 				JoinCapabilities = eJoinCapabilities.ToSIMPL,
 				JoinType = eJoinType.Serial
-			});
-
-        [JoinName("DeviceIpAddresss")]
-        public JoinDataComplete DeviceIpAddresss = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 301,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "IP Address of device",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("SipPhoneNumber")]
-        public JoinDataComplete SipPhoneNumber = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 302,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "SIP phone number of device",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("E164Alias")]
-        public JoinDataComplete E164Alias = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 303,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "E164 alias of device",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("H323Id")]
-        public JoinDataComplete H323Id = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 304,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "H323 ID of device",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-        [JoinName("SipUri")]
-        public JoinDataComplete SipUri = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 305,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "SIP URI of device",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Serial
-            });
+			});		
 
 		[JoinName("DirectoryEntrySelectedName")]
 		public JoinDataComplete DirectoryEntrySelectedName = new JoinDataComplete(

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

@@ -8,7 +8,7 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// </summary>
     public interface IMobileControl : IKeyed
     {
-        void CreateMobileControlRoomBridge(EssentialsRoomBase room, IMobileControl parent);
+        void CreateMobileControlRoomBridge(IEssentialsRoom room, IMobileControl parent);
 
         void LinkSystemMonitorToAppServer();
     }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Occupancy/CenOdtOccupancySensorBaseController.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Resources;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
@@ -62,8 +61,6 @@ namespace PepperDash.Essentials.Core
 
 		public BoolFeedback RawOccupancyUsFeedback { get; private set; }
 
-        public BoolFeedback IdentityModeFeedback { get; private set; }
-
 		// Debug properties
 		public bool InTestMode { get; private set; }
 
@@ -120,8 +117,6 @@ namespace PepperDash.Essentials.Core
 
 			RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyDetectedByUltrasonicSensorFeedback.BoolValue);
 
-            IdentityModeFeedback = new BoolFeedback(()=>OccSensor.IdentityModeOnFeedback.BoolValue);
-
 			UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => (int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback);
 
 			UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => (int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback);
@@ -204,27 +199,6 @@ namespace PepperDash.Essentials.Core
             {
                 SetAndWhenVacatedState((bool)PropertiesConfig.AndWhenVacatedState);
             }
-
-            // TODO [ ] feature/cenoodtcpoe-sensor-sensitivity-configuration
-            if (PropertiesConfig.UsSensitivityOccupied != null)
-            {
-                SetUsSensitivityOccupied((ushort)PropertiesConfig.UsSensitivityOccupied);
-            }
-
-            if (PropertiesConfig.UsSensitivityVacant != null)
-            {
-                SetUsSensitivityVacant((ushort)PropertiesConfig.UsSensitivityVacant);
-            }
-
-            if (PropertiesConfig.PirSensitivityOccupied != null)
-            {
-                SetPirSensitivityOccupied((ushort)PropertiesConfig.PirSensitivityOccupied);
-            }
-
-            if (PropertiesConfig.PirSensitivityVacant != null)
-            {
-                SetPirSensitivityVacant((ushort)PropertiesConfig.PirSensitivityVacant);
-            }
         }
 
 		/// <summary>
@@ -305,21 +279,7 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 
-        /// <summary>
-        /// Sets the identity mode on or off
-        /// </summary>
-        /// <param name="state"></param>
-	    public void SetIdentityMode(bool state)
-        {
-            if (state)
-                OccSensor.IdentityModeOn();
-            else
-                OccSensor.IdentityModeOff();
-
-            Debug.Console(1, this, "Identity Mode: {0}", OccSensor.IdentityModeOnFeedback.BoolValue ? "On" : "Off");
-        }
-
-	    /// <summary>
+		/// <summary>
 		/// Enables or disables the PIR sensor
 		/// </summary>
 		/// <param name="state"></param>
@@ -546,54 +506,6 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 
-        /// <summary>
-        /// Sets the US sensor sensitivity for occupied state
-        /// </summary>
-        /// <param name="sensitivity"></param>
-	    public void SetUsSensitivityOccupied(ushort sensitivity)
-        {
-            var level = (eSensitivityLevel) sensitivity;
-            if (level == 0) return;
-
-            OccSensor.UltrasonicSensorSensitivityInOccupiedState = level;
-        }
-
-        /// <summary>
-        /// Sets the US sensor sensitivity for vacant state
-        /// </summary>
-        /// <param name="sensitivity"></param>
-        public void SetUsSensitivityVacant(ushort sensitivity)
-        {
-            var level = (eSensitivityLevel)sensitivity;
-            if (level == 0) return;
-
-            OccSensor.UltrasonicSensorSensitivityInVacantState = level;
-        }
-
-        /// <summary>
-        /// Sets the PIR sensor sensitivity for occupied state
-        /// </summary>
-        /// <param name="sensitivity"></param>
-        public void SetPirSensitivityOccupied(ushort sensitivity)
-        {
-            var level = (eSensitivityLevel)sensitivity;
-            if (level == 0) return;
-
-            OccSensor.PassiveInfraredSensorSensitivityInOccupiedState = level;
-        }
-
-        /// <summary>
-        /// Sets the PIR sensor sensitivity for vacant state
-        /// </summary>
-        /// <param name="sensitivity"></param>
-        public void SetPirSensitivityVacant(ushort sensitivity)
-        {
-            var level = (eSensitivityLevel)sensitivity;
-            if (level == 0) return;
-
-            OccSensor.PassiveInfraredSensorSensitivityInVacantState = level;
-        }
-
 		/// <summary>
 		/// Method to print current settings to console
 		/// </summary>
@@ -735,11 +647,8 @@ namespace PepperDash.Essentials.Core
 
 			//Sensor Raw States
 			occController.RawOccupancyPirFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyPirFeedback.JoinNumber]);
-			occController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);  
-         
-            // Identity mode
-		    trilist.SetBoolSigAction(joinMap.IdentityMode.JoinNumber, occController.SetIdentityMode);
-            occController.IdentityModeFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IdentityModeFeedback.JoinNumber]);
+			occController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);
+
 		}
 
 		public class CenOdtOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<CenOdtOccupancySensorBaseController>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Occupancy/GlsOccupancySensorPropertiesConfig.cs

@@ -47,35 +47,5 @@ namespace PepperDash.Essentials.Core
 
         [JsonProperty("andWhenVacatedState")]
         public bool? AndWhenVacatedState { get; set; }
-
-        // PoE Sensors: CenOdtCPoe
-
-        /// <summary>
-        /// Sets the sensitivity level for US while sensor is in occupied state
-        /// 1 = low; 2 = medium; 3 = high; 4 = xlow; 5 = 2xlow; 6 = 3xlow
-        /// </summary>
-        [JsonProperty("usSensitivityOccupied")]
-        public ushort? UsSensitivityOccupied { get; set; }
-
-        /// <summary>
-        /// Sets the sensitivity level for US while sensor is in vacant state
-        /// 1 = low; 2 = medium; 3 = high; 4 = xlow; 5 = 2xlow; 6 = 3xlow
-        /// </summary>
-        [JsonProperty("usSensitivityVacant")]
-        public ushort? UsSensitivityVacant { get; set; }
-
-        /// <summary>
-        /// Sets the sensitivity level for PIR while sensor is in occupied state
-        /// 1 = low; 2 = medium; 3 = high
-        /// </summary>
-        [JsonProperty("pirSensitivityOccupied")]
-        public ushort? PirSensitivityOccupied { get; set; }
-
-        /// <summary>
-        /// Sets the sensitivity level for PIR while sensor is in vacant state
-        /// 1 = low; 2 = medium; 3 = high
-        /// </summary>
-        [JsonProperty("pirSensitivityVacant")]
-        public ushort? PirSensitivityVacant { get; set; }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/PartitionSensor/GlsPartitionSensorController.cs

@@ -1,5 +1,4 @@
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.GeneralIO;
 using Newtonsoft.Json;
@@ -10,18 +9,15 @@ using PepperDash.Essentials.Core.Bridges.JoinMaps;
 using System;
 using System.Collections.Generic;
 using PepperDash.Essentials.Core.Config;
-using PepperDash_Essentials_Core.PartitionSensor;
 
 namespace PepperDash.Essentials.Core
 {
 	[Description("Wrapper class for GLS Cresnet Partition Sensor")]
 	public class GlsPartitionSensorController : CrestronGenericBridgeableBaseDevice, IPartitionStateProvider
 	{
+		private GlsPartCn _partitionSensor;
 
-        public GlsPartitionSensorPropertiesConfig PropertiesConfig { get; private set; }
-        
-        private GlsPartCn _partitionSensor;
-
+		public StringFeedback NameFeedback { get; private set; }
 		public BoolFeedback EnableFeedback { get; private set; }
 		public BoolFeedback PartitionPresentFeedback { get; private set; }
 		public BoolFeedback PartitionNotSensedFeedback { get; private set; }
@@ -36,71 +32,23 @@ namespace PepperDash.Essentials.Core
 		public GlsPartitionSensorController(string key, Func<DeviceConfig, GlsPartCn> preActivationFunc, DeviceConfig config)
 			: base(key, config.Name)
 		{
-
-		    var props = config.Properties.ToObject<GlsPartitionSensorPropertiesConfig>();
-		    if (props != null)
-		    {
-		        PropertiesConfig = props;
-		    }
-		    else
-		    {
-		        Debug.Console(1, this, "props are null.  Unable to deserialize into GlsPartSensorPropertiesConfig");
-		    }
-
             AddPreActivationAction(() =>
             {
                 _partitionSensor = preActivationFunc(config);
-                
+
                 RegisterCrestronGenericBase(_partitionSensor);
-                                
+
+                NameFeedback = new StringFeedback(() => Name);
                 EnableFeedback = new BoolFeedback(() => InTestMode ? TestEnableFeedback : _partitionSensor.EnableFeedback.BoolValue);
                 PartitionPresentFeedback = new BoolFeedback(() => InTestMode ? TestPartitionSensedFeedback : _partitionSensor.PartitionSensedFeedback.BoolValue);
                 PartitionNotSensedFeedback = new BoolFeedback(() => InTestMode ? !TestPartitionSensedFeedback : _partitionSensor.PartitionNotSensedFeedback.BoolValue);
                 SensitivityFeedback = new IntFeedback(() => InTestMode ? TestSensitivityFeedback : _partitionSensor.SensitivityFeedback.UShortValue);
 
-                if (_partitionSensor != null)
-                {
-                    _partitionSensor.BaseEvent += PartitionSensor_BaseEvent;                    
-                }
+                if (_partitionSensor != null) _partitionSensor.BaseEvent += PartitionSensor_BaseEvent;
             });
+		}
 
-            AddPostActivationAction(() =>
-            {
-                _partitionSensor.OnlineStatusChange += (o, a) =>
-                {
-                    if (a.DeviceOnLine)
-                    {
-                        ApplySettingsToSensorFromConfig();
-                    }
-                };
-
-                if (_partitionSensor.IsOnline)
-                {
-                    ApplySettingsToSensorFromConfig();
-                }
-            });
-		}        
-
-	    private void ApplySettingsToSensorFromConfig()
-	    {
-	        if (_partitionSensor.IsOnline == false) return;
-
-	        Debug.Console(1, this, "Attempting to apply settings to sensor from config");            
-
-	        if (PropertiesConfig.Sensitivity != null)
-	        {
-	            Debug.Console(1, this, "Sensitivity found, attempting to set value '{0}' from config",
-	                PropertiesConfig.Sensitivity);
-                _partitionSensor.Sensitivity.UShortValue = (ushort) PropertiesConfig.Sensitivity;
-	        }	        
-	        else
-	        {
-	            Debug.Console(1, this, "Sensitivity null, no value specified in config");
-	        }
-
-	    }
-
-	    private void PartitionSensor_BaseEvent(GenericBase device, BaseEventArgs args)
+		private void PartitionSensor_BaseEvent(GenericBase device, BaseEventArgs args)
 		{
 			Debug.Console(2, this, "EventId: {0}, Index: {1}", args.EventId, args.Index);
 
@@ -113,13 +61,11 @@ namespace PepperDash.Essentials.Core
 					}
 				case (GlsPartCn.PartitionSensedFeedbackEventId):
 					{
-                        Debug.Console(1, this, "Partition Sensed State: {0}", _partitionSensor.PartitionSensedFeedback.BoolValue);
 						PartitionPresentFeedback.FireUpdate();
 						break;
 					}
 				case (GlsPartCn.PartitionNotSensedFeedbackEventId):
 					{
-                        Debug.Console(1, this, "Partition Not Sensed State: {0}", _partitionSensor.PartitionNotSensedFeedback.BoolValue);
 						PartitionNotSensedFeedback.FireUpdate();
 						break;
 					}
@@ -127,7 +73,7 @@ namespace PepperDash.Essentials.Core
 					{
 						SensitivityFeedback.FireUpdate();
 						break;
-					}                    
+					}
 				default:
 					{
 						Debug.Console(2, this, "Unhandled args.EventId: {0}", args.EventId);
@@ -187,22 +133,7 @@ namespace PepperDash.Essentials.Core
 			Debug.Console(1, this, "InTestMode: {0}, unable to set sensitivity value: {1}", InTestMode.ToString(), value);
 		}
 
-	    public void GetSettings()
-	    {
-	        var dash = new string('*', 50);
-	        CrestronConsole.PrintLine(string.Format("{0}\n", dash));
-
-	        Debug.Console(0, this, "Enabled State: {0}", _partitionSensor.EnableFeedback.BoolValue);
-
-	        Debug.Console(0, this, "Partition Sensed State: {0}", _partitionSensor.PartitionSensedFeedback.BoolValue);
-	        Debug.Console(0, this, "Partition Not Sensed State: {0}", _partitionSensor.PartitionNotSensedFeedback.BoolValue);
-
-	        Debug.Console(0, this, "Sensitivity Value: {0}", _partitionSensor.SensitivityFeedback.UShortValue);
-
-	        CrestronConsole.PrintLine(string.Format("{0}\n", dash));
-	    }
-
-	    public void SetEnableState(bool state)
+		public void SetEnableState(bool state)
 		{
             Debug.Console(2, this, "Sensor is {0}, SetEnableState: {1}", _partitionSensor == null ? "null" : "not null", state);
 			if (_partitionSensor == null)
@@ -258,20 +189,18 @@ namespace PepperDash.Essentials.Core
 			Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
 			Debug.Console(0, this, "Linking to Bridge Type {0}", GetType().Name);
 
-            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);            
-		    trilist.StringInput[joinMap.Name.JoinNumber].StringValue = _partitionSensor.Name;
-			
+			// link input from simpl
 		    trilist.SetBoolSigAction(joinMap.Enable.JoinNumber, SetEnableState);
-            EnableFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Enable.JoinNumber]);
-
-            PartitionPresentFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionSensed.JoinNumber]);
-            PartitionNotSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionNotSensed.JoinNumber]);
-
 			trilist.SetSigTrueAction(joinMap.IncreaseSensitivity.JoinNumber, IncreaseSensitivity);
 			trilist.SetSigTrueAction(joinMap.DecreaseSensitivity.JoinNumber, DecreaseSensitivity);
+			trilist.SetUShortSigAction(joinMap.Sensitivity.JoinNumber, SetSensitivity);
 
-            SensitivityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Sensitivity.JoinNumber]);
-            trilist.SetUShortSigAction(joinMap.Sensitivity.JoinNumber, SetSensitivity);
+			// link output to simpl
+			IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+			EnableFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Enable.JoinNumber]);
+			PartitionPresentFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionSensed.JoinNumber]);
+			PartitionNotSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionNotSensed.JoinNumber]);
+			SensitivityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Sensitivity.JoinNumber]);
 
 			FeedbacksFireUpdates();
 
@@ -289,7 +218,6 @@ namespace PepperDash.Essentials.Core
 			{
 				if (a.DeviceOnLine)
 				{
-				    trilist.StringInput[joinMap.Name.JoinNumber].StringValue = _partitionSensor.Name;
 					FeedbacksFireUpdates();
 				}
 			};
@@ -297,7 +225,8 @@ namespace PepperDash.Essentials.Core
 
 		private void FeedbacksFireUpdates()
 		{
-			IsOnline.FireUpdate();			
+			IsOnline.FireUpdate();
+			NameFeedback.FireUpdate();
 			EnableFeedback.FireUpdate();
 			PartitionPresentFeedback.FireUpdate();
 			PartitionNotSensedFeedback.FireUpdate();

essentials-framework/Essentials Core/PepperDashEssentialsBase/PartitionSensor/GlsPartitionSensorPropertiesConfig.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Newtonsoft.Json;
-
-namespace PepperDash_Essentials_Core.PartitionSensor
-{
-    public class GlsPartitionSensorPropertiesConfig
-    {
-        /// <summary>
-        /// Sets the sensor sensitivity        
-        /// </summary>
-        /// <remarks>
-        /// The sensitivity range shall be between 1(lowest) to 10 (highest).
-        /// </remarks>
-        [JsonProperty("sensitivity")]
-        public ushort? Sensitivity { get; set; }
-    }
-}

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

@@ -236,7 +236,6 @@
     <Compile Include="Occupancy\GlsOccupancySensorPropertiesConfig.cs" />
     <Compile Include="Occupancy\GlsOirOccupancySensorController.cs" />
     <Compile Include="PartitionSensor\EssentialsPartitionController.cs" />
-    <Compile Include="PartitionSensor\GlsPartitionSensorPropertiesConfig.cs" />
     <Compile Include="PartitionSensor\IPartitionStateProvider.cs" />
     <Compile Include="Occupancy\OccupancyAggregatorConfig.cs" />
     <Compile Include="Queues\ComsMessage.cs" />

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

@@ -54,13 +54,20 @@ namespace PepperDash.Essentials.Core
                 SetupPartitionStateProviders();
 
                 SetRooms();
+
+                if (isInAutoMode)
+                {
+                    DetermineRoomCombinationScenario();
+                }
+                else
+                {
+                    SetRoomCombinationScenario(_propertiesConfig.defaultScenarioKey);
+                }
             });
         }
 
         void CreateScenarios()
         {
-            RoomCombinationScenarios = new List<IRoomCombinationScenario>();
-
             foreach (var scenarioConfig in _propertiesConfig.Scenarios)
             {
                 var scenario = new RoomCombinationScenario(scenarioConfig);
@@ -160,12 +167,26 @@ namespace PepperDash.Essentials.Core
             {
                 return _currentScenario;
             }
-            set
+            private set
             {
                 if (value != _currentScenario)
                 {
+                    // Deactivate the old scenario first
+                    if (_currentScenario != null)
+                    {
+                        _currentScenario.Deactivate();
+                    }
+
                     _currentScenario = value;
-                    Debug.Console(1, this, "Current Scenario: {0}", _currentScenario.Name);
+
+                    // Activate the new scenario
+                    if (_currentScenario != null)
+                    {
+                        _currentScenario.Activate();
+
+                        Debug.Console(1, this, "Current Scenario: {0}", _currentScenario.Name);
+                    }
+
                     var handler = RoomCombinationScenarioChanged;
                     if (handler != null)
                     {
@@ -220,9 +241,11 @@ namespace PepperDash.Essentials.Core
             // Get the scenario
             var scenario = RoomCombinationScenarios.FirstOrDefault((s) => s.Key.Equals(scenarioKey));
 
+
             // Set the parition states from the scenario manually
             if (scenario != null)
             {
+                Debug.Console(0, this, "Manually setting scenario to '{0}'", scenario.Key);
                 foreach (var partitionState in scenario.PartitionStates)
                 {
                     var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionState.PartitionKey));
@@ -231,15 +254,25 @@ namespace PepperDash.Essentials.Core
                     {
                         if (partitionState.PartitionPresent)
                         {
+                            Debug.Console(0, this, "Manually setting state to Present for: '{0}'", partition.Key);
                             partition.SetPartitionStatePresent();
                         }
                         else
                         {
+                            Debug.Console(0, this, "Manually setting state to Not Present for: '{0}'", partition.Key);
                             partition.SetPartitionStateNotPresent();
                         }
                     }
+                    else
+                    {
+                        Debug.Console(1, this, "Unable to find partition with key: '{0}'", partitionState.PartitionKey);
+                    }
                 }
             }
+            else
+            {
+                Debug.Console(1, this, "Unable to find scenario with key: '{0}'", scenarioKey);
+            }
         }
 
         #endregion

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

@@ -30,7 +30,7 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// The list of rooms keys that can be combined
         /// </summary>
-        [JsonProperty("roomMap")]
+        [JsonProperty("roomKeys")]
         public List<string> RoomKeys {get; set;}
 
         /// <summary>
@@ -87,6 +87,9 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("partitionStates")]
         public List<PartitionState> PartitionStates { get; set; }
 
+        /// <summary>
+        /// Determines which UI devices get mapped to which room in this scenario.  The Key should be the key of the UI device and the Value should be the key of the room to map to
+        /// </summary>
         [JsonProperty("uiMap")]
         public Dictionary<string, string> UiMap { get; set; }
 

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

@@ -78,6 +78,11 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         void Activate();
 
+        /// <summary>
+        /// Deactivates this room combination scenario
+        /// </summary>
+        void Deactivate();
+
         /// <summary>
         /// The state of the partitions that would activate this scenario
         /// </summary>

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

@@ -4,6 +4,8 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 
+using PepperDash.Core;
+
 using Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core
@@ -27,9 +29,9 @@ namespace PepperDash.Essentials.Core
 
         public BoolFeedback IsActiveFeedback { get; private set; }
 
-        List<DeviceActionWrapper> activationActions;
+        private List<DeviceActionWrapper> activationActions;
 
-        List<DeviceActionWrapper> deactivationActions;
+        private List<DeviceActionWrapper> deactivationActions;
 
         public RoomCombinationScenario(RoomCombinationScenarioConfig config)
         {
@@ -52,6 +54,8 @@ namespace PepperDash.Essentials.Core
 
         public void Activate()
         {
+            Debug.Console(1, "Activating Scenario: '{0}' with {1} action(s) defined", Name, activationActions.Count);   
+
             if (activationActions != null)
             {
                 foreach (var action in activationActions)
@@ -66,6 +70,8 @@ namespace PepperDash.Essentials.Core
 
         public void Deactivate()
         {
+            Debug.Console(1, "Deactivating Scenario: '{0}' with {1} action(s) defined", Name, deactivationActions.Count);
+
             if (deactivationActions != null)
             {
                 foreach (var action in deactivationActions)

essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/TriListExtensions.cs

@@ -206,6 +206,27 @@ namespace PepperDash.Essentials.Core
 			return ClearSigAction(tl.StringOutput[sigNum]) as StringOutputSig;
 		}
 
+        /// <summary>
+        /// Clears all actions on all sigs
+        /// </summary>
+        public static void ClearAllSigActions(this BasicTriList t1)
+        {
+            foreach (var sig in t1.BooleanOutput)
+            {
+                ClearSigAction(sig);
+            }
+
+            foreach (var sig in t1.UShortOutput)
+            {
+                ClearSigAction(sig);
+            }
+
+            foreach (var sig in t1.StringOutput)
+            {
+                ClearSigAction(sig);
+            }
+        }
+
         /// <summary>
         /// Helper method to set the value of a bool Sig on TriList
         /// </summary>

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs

@@ -1285,10 +1285,7 @@ namespace PepperDash.Essentials.DM
 
             var output = outputSelector as DMOutput;
 
-            var isUsbInput = (sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput;
-            var isUsbOutput = (sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput;
-
-            if (output == null && !(isUsbOutput || isUsbInput))
+            if (output == null)
             {
                 Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
                     "Unable to execute switch for inputSelector {0} to outputSelector {1}", inputSelector,
@@ -1319,10 +1316,7 @@ namespace PepperDash.Essentials.DM
             if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video)
             {
                 Chassis.VideoEnter.BoolValue = true;
-                if (output != null)
-                {
-                    output.VideoOut = input; //Chassis.Outputs[output].VideoOut = inCard;
-                }
+                output.VideoOut = input; //Chassis.Outputs[output].VideoOut = inCard;
             }
 
             if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
@@ -1332,66 +1326,17 @@ namespace PepperDash.Essentials.DM
                 {
                     dmMdMnxn.AudioEnter.BoolValue = true;
                 }
-                if (output != null)
-                {
-                    output.AudioOut = input;
-                }
+                output.AudioOut = input;
+                //Chassis.Outputs[output].AudioOut = inCard;
             }
 
-            if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
-                
-            {
-               Chassis.USBEnter.BoolValue = true;
-                if (inputSelector == null && output != null)
-                {
-                    //clearing the route is intended
-                    output.USBRoutedTo = null;
-                    return;
-                }
-
-                if (inputSelector != null && input == null)
-                {
-                    //input selector is DMOutput...we're doing a out to out route
-                    var tempInput = inputSelector as DMOutput;
-
-                    if (tempInput == null || output == null)
-                    {
-                        return;
-                    }
-                    output.USBRoutedTo = tempInput;
-                    return;
-                }
-
-                if (input != null & output != null)
-                {
-                    output.USBRoutedTo = input;
-                }
-            }
-
-            if((sigType & eRoutingSignalType.UsbInput) != eRoutingSignalType.UsbInput)
-            {
-                return;
-            }
-
-            Chassis.USBEnter.BoolValue = true;
-            if (output != null)
+            if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput || (sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
             {
+                Chassis.USBEnter.BoolValue = true;
                 output.USBRoutedTo = input;
-                return;
-            }
-            var tempOutput = outputSelector as DMInput;
-
-            if (tempOutput == null)
-            {
-                Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
-                    "Unable to execute switch for inputSelector {0} to outputSelector {1}", inputSelector,
-                    outputSelector);
-                return;
             }
 
-            tempOutput.USBRoutedTo = input;
         }
-
         #endregion
 
         #region IRoutingNumeric Members
@@ -1404,10 +1349,8 @@ namespace PepperDash.Essentials.DM
 
             DMInputOutputBase dmCard;
 
-            //Routing Input to Input or Output to Input
             if ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
             {
-                Debug.Console(2, this, "Executing USB Input switch.\r\n in:{0} output: {1}", inputSelector, outputSelector);
                 if (outputSelector > chassisSize)
                 {
                     uint outputIndex;
@@ -1427,14 +1370,13 @@ namespace PepperDash.Essentials.DM
                     dmCard = Chassis.Inputs[inputSelector];
                 }
 
-                ExecuteSwitch(dmCard, Chassis.Inputs[outputSelector], sigType);
+                ExecuteSwitch(dmCard, Chassis.Outputs[outputSelector], sigType);
                 return;
             }
             if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
             {
                 Debug.Console(2, this, "Executing USB Output switch.\r\n in:{0} output: {1}", inputSelector, outputSelector);
 
-                //routing Output to Output or Input to Output
                 if (inputSelector > chassisSize)
                 {
                     //wanting to route an output to an output. Subtract chassis size and get output, unless it's 8x8

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

@@ -12,40 +12,34 @@ namespace PepperDash.Essentials.Devices.Common.Codec
 {
     public class CodecActiveCallItem
     {
-		[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("name")]
         public string Name { get; set; }
 
-        [JsonProperty("number", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("number")]
         public string Number { get; set; }
 
-        [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("type")]
 		[JsonConverter(typeof(StringEnumConverter))]
         public eCodecCallType Type { get; set; }
 
-        [JsonProperty("status", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("status")]
 		[JsonConverter(typeof(StringEnumConverter))]
         public eCodecCallStatus Status { get; set; }
 
-        [JsonProperty("direction", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("direction")]
 		[JsonConverter(typeof(StringEnumConverter))]
         public eCodecCallDirection Direction { get; set; }
 
-        [JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("id")]
         public string Id { get; set; }
 
-        [JsonProperty("isOnHold", NullValueHandling = NullValueHandling.Ignore)]
-        public bool IsOnHold { get; set; }
-
-        [JsonProperty("duration", NullValueHandling = NullValueHandling.Ignore)]
-        public TimeSpan Duration { get; set; }
-
         //public object CallMetaData { get; set; }
 
         /// <summary>
         /// Returns true when this call is any status other than 
         /// Unknown, Disconnected, Disconnecting
         /// </summary>
-        [JsonProperty("isActiveCall", NullValueHandling = NullValueHandling.Ignore)]
+		[JsonProperty("isActiveCall")]
         public bool IsActiveCall
         {
             get

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

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-namespace PepperDash.Essentials.Devices.Common.Codec
-{
-    public interface IHasCallHold
-    {
-        /// <summary>
-        /// Put the specified call on hold
-        /// </summary>
-        /// <param name="activeCall"></param>
-        void HoldCall(CodecActiveCallItem activeCall);
-
-        /// <summary>
-        /// Resume the specified call
-        /// </summary>
-        /// <param name="activeCall"></param>
-        void ResumeCall(CodecActiveCallItem activeCall);
-    }
-}

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

@@ -23,9 +23,9 @@ namespace PepperDash.Essentials.Devices.Common.Codec
     public enum eCodecOccurrenceType
     {
         Unknown = 0,
-        Placed = 1,
-        Received = 2,
-        NoAnswer = 3,
+        Placed,
+        Received,
+        NoAnswer
     }
 
     /// <summary>

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

@@ -108,7 +108,6 @@
     <Compile Include="Codec\eCodecCallStatus.cs" />
     <Compile Include="Codec\eMeetingPrivacy.cs" />
     <Compile Include="Codec\iCodecAudio.cs" />
-    <Compile Include="Codec\IHasCallHold.cs" />
     <Compile Include="Codec\IHasDoNotDisturb.cs" />
     <Compile Include="Codec\IHasExternalSourceSwitching.cs" />
     <Compile Include="ImageProcessors\TVOneCorio.cs" />
@@ -130,7 +129,6 @@
     <Compile Include="VideoCodec\Interfaces\IHasSelfviewSize.cs" />
     <Compile Include="VideoCodec\Interfaces\IHasStandbyMode.cs" />
     <Compile Include="VideoCodec\Interfaces\IHasStartMeeting.cs" />
-    <Compile Include="VideoCodec\Interfaces\IJoinCalls.cs" />
     <Compile Include="VideoCodec\Interfaces\iVideoCodecInfo.cs" />
     <Compile Include="Codec\iHasCallFavorites.cs" />
     <Compile Include="Codec\iHasCallHistory.cs" />

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

@@ -116,7 +116,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         /// <summary>
         /// The ID of the camera on the codec
         /// </summary>
-        public uint CameraId { get; private set; }
+        protected uint CameraId { get; private set; }
 
         /// <summary>
         /// Valid range 1-15

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

@@ -9,39 +9,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
     {
         #region Digital
 
-        [JoinName("PresentationLocalOnly")]
-        public JoinDataComplete PresentationLocalOnly = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 205,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Presentation Local Only Feedback",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
-        [JoinName("PresentationLocalRemote")]
-        public JoinDataComplete PresentationLocalRemote = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 206,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Presentation Local and Remote Feedback",
-                JoinCapabilities = eJoinCapabilities.ToSIMPL,
-                JoinType = eJoinType.Digital
-            });
-
         [JoinName("ActivateDoNotDisturbMode")]
         public JoinDataComplete ActivateDoNotDisturbMode = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 241,
+                JoinNumber = 221,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -55,7 +27,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete DeactivateDoNotDisturbMode = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 242,
+                JoinNumber = 222,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -69,7 +41,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete ToggleDoNotDisturbMode = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 243,
+                JoinNumber = 223,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -83,7 +55,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete ActivateStandby = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 246,
+                JoinNumber = 226,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -97,7 +69,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete DeactivateStandby = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 247,
+                JoinNumber = 227,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -111,7 +83,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete ActivateHalfWakeMode = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 248,
+                JoinNumber = 228,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -125,7 +97,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
         public JoinDataComplete EnteringStandbyMode = new JoinDataComplete(
             new JoinData
             {
-                JoinNumber = 249,
+                JoinNumber = 229,
                 JoinSpan = 1
             },
             new JoinMetadata
@@ -140,55 +112,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         #region Analog
 
-        [JoinName("RingtoneVolume")]
-        public JoinDataComplete RingtoneVolume = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 21,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Ringtone volume set/FB.  Valid values are 0 - 100 in increments of 5 (5, 10, 15, 20, etc.)",
-                JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
-        [JoinName("PresentationSource")]
-        public JoinDataComplete PresentationSource = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 201,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Presentation set/FB.  Valid values are 0 - 6 depending on the codec model.",
-                JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
-                JoinType = eJoinType.Analog
-            });
-
 
         #endregion
 
 
         #region Serials
 
-        [JoinName("CommandToDevice")]
-        public JoinDataComplete CommandToDevice = new JoinDataComplete(
-            new JoinData
-            {
-                JoinNumber = 5,
-                JoinSpan = 1
-            },
-            new JoinMetadata
-            {
-                Description = "Sends a serial command to the device.  Do not include the delimiter, it will be added automatically.",
-                JoinCapabilities = eJoinCapabilities.FromSIMPL,
-                JoinType = eJoinType.Serial
-            });
-
-
 
         #endregion
 

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

@@ -50,16 +50,8 @@ namespace PepperDash.Essentials.Devices.Common.Codec
         public uint PhonebookResultsLimit { get; set; }
 
         [JsonProperty("UiBranding")]
-        public BrandingLogoProperties UiBranding { get; set; }
+        public BrandingLogoProperties UiBranding { get; set; }       
 
-        [JsonProperty("cameraInfo")]
-        public List<CameraInfo> CameraInfo { get; set; }
-
-
-        public CiscoSparkCodecPropertiesConfig()
-        {
-            CameraInfo = new List<CameraInfo>();
-        }
     }
 
     public class SharingProperties
@@ -76,14 +68,4 @@ namespace PepperDash.Essentials.Devices.Common.Codec
         [JsonProperty("brandingUrl")]
         public string BrandingUrl { get; set; }
     }
-
-    /// <summary>
-    /// Describes configuration information for the near end cameras
-    /// </summary>
-    public class CameraInfo
-    {
-        public int CameraNumber { get; set; }
-        public string Name { get; set; }
-        public int SourceId { get; set; }
-    }
 }

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

@@ -26,8 +26,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
         void CodecRoomPresetSelect(int preset);
 
         void CodecRoomPresetStore(int preset, string description);
-
-        void SelectFarEndPreset(int preset);        
     }
 
     public static class RoomPresets

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

@@ -112,46 +112,16 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public string Value { get; set; }
         }
 
-        public class RingVolume : ValueProperty
+        public class RingVolume
         {
             public string valueSpaceRef { get; set; }
-
-            string _Value;
-
-            /// <summary>
-            /// Sets Value and triggers the action when set
-            /// </summary>
-            public string Value
-            {
-                get
-                {
-                    return _Value;
-                }
-                set
-                {
-                    _Value = value;
-                    OnValueChanged();
-                }
-            }
-
-            public int Volume
-            {
-                get
-                {
-                    return Int32.Parse(_Value);
-                }
-            }
+            public string Value { get; set; }
         }
 
         public class SoundsAndAlerts
         {
             public RingTone RingTone { get; set; }
             public RingVolume RingVolume { get; set; }
-
-            public SoundsAndAlerts()
-            {
-                RingVolume = new RingVolume();
-            }
         }
 
         public class Audio
@@ -161,12 +131,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Microphones Microphones { get; set; }
             public Output Output { get; set; }
             public SoundsAndAlerts SoundsAndAlerts { get; set; }
-
-
-            public Audio()
-            {
-                SoundsAndAlerts = new SoundsAndAlerts();
-            }
         }
 
         public class DefaultMode
@@ -376,13 +340,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Delay Delay { get; set; }
             public Mode9 Mode { get; set; }
             public Mute2 Mute { get; set; }
-
-            public AutoAnswer()
-            {
-               Mode = new Mode9(); 
-               Delay = new Delay();
-               Mute = new Mute2();
-            }
         }
 
         public class Protocol
@@ -483,11 +440,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public MaxTotalTransmitCallRate MaxTotalTransmitCallRate { get; set; }
             public MaxTransmitCallRate MaxTransmitCallRate { get; set; }
             public MultiStream MultiStream { get; set; }
-
-            public Conference()
-            {
-                AutoAnswer = new AutoAnswer();
-            }
         }
 
         public class LoginName
@@ -738,11 +690,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Assignment Assignment { get; set; }
             public Gateway Gateway { get; set; }
             public SubnetMask SubnetMask { get; set; }
-
-            public IPv4()
-            {
-                Address = new Address4();
-            }
         }
 
         public class Address5
@@ -894,11 +841,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public RemoteAccess RemoteAccess { get; set; }
             public Speed Speed { get; set; }
             public VLAN VLAN { get; set; }
-
-            public Network()
-            {
-                IPv4 = new IPv4();
-            }
         }
 
         public class Mode19
@@ -1855,23 +1797,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public UserInterface UserInterface { get; set; }
             public UserManagement UserManagement { get; set; }
             public Video2 Video { get; set; }
-
-            public Configuration()
-            {
-                Audio = new Audio();
-                Conference = new Conference();
-                Network = new List<Network>();
-            }
         }
 
         public class RootObject
         {
             public Configuration Configuration { get; set; }
-
-            public RootObject()
-            {
-                Configuration = new Configuration();
-            }   
         }
     }
 }

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

@@ -12,28 +12,28 @@ using PepperDash.Essentials.Devices.Common.VideoCodec.CiscoCodec;
 
 namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 {
-    // Helper Classes for Proerties
-    public abstract class ValueProperty
-    {
-        /// <summary>
-        /// Triggered when Value is set
-        /// </summary>
-        public Action ValueChangedAction { get; set; }
-
-        protected void OnValueChanged()
-        {
-            var a = ValueChangedAction;
-            if (a != null)
-                a();
-        }
-
-    }
-
 	/// <summary>
 	/// This class exists to capture serialized data sent back by a Cisco codec in JSON output mode
 	/// </summary>
     public class CiscoCodecStatus
     {
+        // Helper Classes for Proerties
+        public abstract class ValueProperty
+        {
+            /// <summary>
+            /// Triggered when Value is set
+            /// </summary>
+            public Action ValueChangedAction { get; set; }
+
+            protected void OnValueChanged()
+            {
+                var a = ValueChangedAction;
+                if (a != null)
+                    a();
+            }
+
+        }
+
 
         public class ConnectionStatus
         {
@@ -262,30 +262,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public string Value { get; set; }
         }
 
-        public class DectectedConnector
-        {
-            public string Value { get; set; }
-
-            public int ConnectorId
-            {
-                get
-                {
-                    if(!string.IsNullOrEmpty(Value))
-                    {
-                        return Convert.ToUInt16(Value);
-                    }
-                    else
-                        return -1;
-                }
-            }
-        }
-
         public class Camera
         {
             public string id { get; set; }
             public Capabilities Capabilities { get; set; }
             public Connected Connected { get; set; }
-            public DectectedConnector DetectedConnector { get; set; }
             public Flip Flip { get; set; }
             public HardwareID HardwareID { get; set; }
             public MacAddress MacAddress { get; set; }
@@ -294,13 +275,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Position Position { get; set; }
             public SerialNumber SerialNumber { get; set; }
             public SoftwareID SoftwareID { get; set; }
-
-            public Camera()
-            {
-                Manufacturer = new Manufacturer();
-                Model = new Model();
-                DetectedConnector = new DectectedConnector();
-            }
         }
 
         public class Availability : ValueProperty
@@ -324,34 +298,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             }
         }
 
-        public class CallStatus : ValueProperty
-        {
-            string _Value;
-            public bool BoolValue { get; private set; }
-
-
-            public string Value
-            {
-                get
-                {
-                    return _Value;
-                }
-                set
-                {
-                    // If the incoming value is "Active" it sets the BoolValue true, otherwise sets it false
-                    _Value = value;
-                    BoolValue = value == "Connected";
-                    OnValueChanged();
-                }
-            }
-        }
-
         public class Status2 : ValueProperty
         {
             string _Value;
             public bool BoolValue { get; private set; }
 
-
             public string Value
             {
                 get
@@ -607,47 +558,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             }
         }
 
-        public class SendingMode : ValueProperty
+        public class SendingMode
         {
-            string _Value;
-
-            /// <summary>
-            /// Sets Value and triggers the action when set
-            /// </summary>
-            public string Value
-            {
-                get
-                {
-                    return _Value;
-                }
-                set
-                {
-                    _Value = value;
-                    OnValueChanged();
-                }
-            }
-
-            public bool LocalOnly
-            {
-                get
-                {
-                    if(string.IsNullOrEmpty(_Value))
-                        return false; 
-
-                    return _Value.ToLower() == "localonly";
-                }
-            }
-
-            public bool LocalRemote
-            {
-                get
-                {
-                    if(string.IsNullOrEmpty(_Value))
-                        return false; 
-
-                    return _Value.ToLower() == "localremote";
-                }
-            }
+            public string Value { get; set; }
         }
 
         public class LocalInstance
@@ -660,7 +573,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public LocalInstance()
             {
                 Source = new Source2();
-                SendingMode = new SendingMode();
             }
         }
 
@@ -969,11 +881,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Address4 Address { get; set; }
             public Gateway Gateway { get; set; }
             public SubnetMask SubnetMask { get; set; }
-
-            public IPv4()
-            {
-                Address = new Address4();
-            }
         }
 
         public class Address5
@@ -1016,11 +923,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public IPv4 IPv4 { get; set; }
             public IPv6 IPv6 { get; set; }
             public VLAN VLAN { get; set; }
-
-            public Network()
-            {
-                IPv4 = new IPv4();
-            }
         }
 
         public class CurrentAddress
@@ -2047,30 +1949,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public string Value { get; set; }
         }
 
-        public class Duration : ValueProperty
+        public class Duration
         {
-            private string _Value;
-
-            public string Value
-            {
-                get
-                {
-                    return _Value;
-                }
-                set
-                {
-                    _Value = value;
-                    OnValueChanged();
-                }
-            }
-
-            public TimeSpan DurationValue
-            {
-                get
-                {
-                    return new TimeSpan(0, 0, Int32.Parse(_Value));
-                }
-            }
+            public string Value { get; set; }
         }
 
         public class FacilityServiceId
@@ -2083,19 +1964,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public string Value { get; set; }
         }
 
-        public class PlacedOnHold : ValueProperty
+        public class PlacedOnHold
         {
-            public bool BoolValue { get; private set; }
-
-            public string Value
-            {
-                set
-                {
-                    // If the incoming value is "True" it sets the BoolValue true, otherwise sets it false
-                    BoolValue = value == "True";
-                    OnValueChanged();
-                }
-            }
+            public string Value { get; set; }
         }
 
         public class Protocol
@@ -2136,14 +2007,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             public Protocol Protocol { get; set; }
             public ReceiveCallRate ReceiveCallRate { get; set; }
             public RemoteNumber RemoteNumber { get; set; }
-            public CallStatus Status { get; set; }
+            public Status2 Status { get; set; }
             public TransmitCallRate TransmitCallRate { get; set; }
 
             public Call()
             {
                 CallType = new CallType();
-                Status = new CallStatus();
-                Duration = new Duration();
+                Status = new Status2();
             }
         }
 
@@ -2244,7 +2114,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
                 SystemUnit = new SystemUnit();
                 Video = new Video();
                 Conference = new Conference2();
-                Network = new List<Network>();
             }
         }
 

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

@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-using PepperDash.Essentials.Devices.Common.Codec;
-
-namespace PepperDash.Essentials.Devices.Common.VideoCodec
-{
-    public interface IJoinCalls
-    {
-        void JoinCall(CodecActiveCallItem activeCall);
-        void JoinAllCalls();
-    }
-}

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

@@ -431,8 +431,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                         m.MinutesBeforeMeeting = 5;
                         m.Id = i.ToString();
                         m.Organizer = "Employee " + 1;
-						m.StartTime = DateTime.Now.AddMinutes(6).AddHours(i);
-						m.EndTime = DateTime.Now.AddHours(i).AddMinutes(16);
+						m.StartTime = DateTime.Now.AddMinutes(5).AddHours(i);
+						m.EndTime = DateTime.Now.AddHours(i).AddMinutes(50);
 						m.Title = "Meeting " + i;
                         m.Calls.Add(new Call() { Number = i + "meeting@fake.com"});
 						_CodecSchedule.Meetings.Add(m);
@@ -602,6 +602,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
             CameraAutoModeIsOnFeedback = new BoolFeedback(() => _CameraAutoModeIsOn);
 
+            SupportsCameraAutoMode = true;
+
             CameraAutoModeIsOnFeedback.FireUpdate();
 
             DeviceManager.AddDevice(internalCamera);
@@ -609,7 +611,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
             NearEndPresets = new List<CodecRoomPreset>(15); // Fix the capacity to emulate Cisco
 
-            NearEndPresets = PropertiesConfig.Presets;
+            if (PropertiesConfig.Presets != null && PropertiesConfig.Presets.Count > 0)
+            {
+                NearEndPresets = PropertiesConfig.Presets;
+            }
+            else
+            {
+                for (int i = 1; i <= NearEndPresets.Capacity; i++)
+                {
+                    var label = string.Format("Near End Preset {0}", i);
+                    NearEndPresets.Add(new CodecRoomPreset(i, label, true, false));
+                }
+            }
 
             FarEndRoomPresets = new List<CodecRoomPreset>(15); // Fix the capacity to emulate Cisco
 
@@ -751,11 +764,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
             SetConfig(Config);
         }
 
-        public void SelectFarEndPreset(int i)
-        {
-            Debug.Console(1, this, "Selecting Far End Preset: {0}", i);
-        }
-
         #endregion
 
         protected override void CustomSetConfig(DeviceConfig config)

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/MockVC/MockVcPropertiesConfig.cs

@@ -18,5 +18,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
         [JsonProperty("presets")]
         public List<CodecRoomPreset> Presets { get; set; }
+
+        public MockVcPropertiesConfig()
+        {
+            Favorites = new List<CodecActiveCallItem>();
+            Presets = new List<CodecRoomPreset>();
+        }
     }
 }

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

@@ -149,7 +149,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 		public abstract void AcceptCall(CodecActiveCallItem call);
 		public abstract void RejectCall(CodecActiveCallItem call);
 		public abstract void SendDtmf(string s);
-        public virtual void SendDtmf(string s, CodecActiveCallItem call) { }
 
 		#endregion
 
@@ -257,12 +256,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 		/// </summary>
 		public virtual void ListCalls()
 		{
-            Debug.Console(1, this, "Active Calls:");
-
 			var sb = new StringBuilder();
 			foreach (var c in ActiveCalls)
 			{
-				sb.AppendFormat("id: {0} number: {1} -- name: {2} status: {3} onHold: {4}\r\n", c.Id, c.Number, c.Name, c.Status, c.IsOnHold);
+				sb.AppendFormat("{0} {1} -- {2} {3}\n", c.Id, c.Number, c.Name, c.Status);
 			}
 			Debug.Console(1, this, "\n{0}\n", sb.ToString());
 		}
@@ -301,13 +298,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			}
 
 			LinkVideoCodecToApi(codec, trilist, joinMap);
-
-		    trilist.OnlineStatusChange += (device, args) =>
-		    {
-		        if (!args.DeviceOnLine) return;
-
-		        trilist.SetString(joinMap.Schedule.JoinNumber, "\xFC");
-		    };
 		}
 
 		/// <summary>
@@ -330,22 +320,15 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 			LinkVideoCodecVolumeToApi(trilist, joinMap);
 
-            LinkVideoCodecInfoToApi(trilist, joinMap);
-
-            // Register for this event to link any functions that require the codec to be ready first
-            codec.IsReadyChange += (o, a) =>
-                {
-                    if (codec is IHasCodecCameras)
-                    {
-                        LinkVideoCodecCameraToApi(codec as IHasCodecCameras, trilist, joinMap);
-                    }
-                };
-
 			if (codec is ICommunicationMonitor)
 			{
 				LinkVideoCodecCommMonitorToApi(codec as ICommunicationMonitor, trilist, joinMap);
 			}
 
+			if (codec is IHasCodecCameras)
+			{
+				LinkVideoCodecCameraToApi(codec as IHasCodecCameras, trilist, joinMap);
+			}
 
 			if (codec is IHasCodecSelfView)
 			{
@@ -399,11 +382,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				LinkVideoCodecPhoneToApi(codec as IHasPhoneDialing, trilist, joinMap);
 			}
 
-            if (codec is IHasCallHistory)
-            {
-                LinkVideoCodecCallHistoryToApi(codec as IHasCallHistory, trilist, joinMap);
-            }
-
 			trilist.OnlineStatusChange += (device, args) =>
 			{
 				if (!args.DeviceOnLine) return;
@@ -450,11 +428,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 					(codec as IHasPhoneDialing).PhoneOffHookFeedback.FireUpdate();
 				}
 
-                if (codec is IHasCallHistory)
-                {
-                    UpdateCallHistory((codec as IHasCallHistory), trilist, joinMap);
-                }
-
 				SharingContentIsOnFeedback.FireUpdate();
 
 				trilist.SetBool(joinMap.HookState.JoinNumber, IsInCall);
@@ -463,31 +436,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			};
 		}
 
-        private void LinkVideoCodecInfoToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
-        {
-            trilist.SetBool(joinMap.MultiSiteOptionIsEnabled.JoinNumber, this.CodecInfo.MultiSiteOptionIsEnabled);
-            trilist.SetBool(joinMap.AutoAnswerEnabled.JoinNumber, this.CodecInfo.AutoAnswerEnabled);
-            trilist.SetString(joinMap.DeviceIpAddresss.JoinNumber, this.CodecInfo.IpAddress);
-            trilist.SetString(joinMap.SipPhoneNumber.JoinNumber, this.CodecInfo.SipPhoneNumber);
-            trilist.SetString(joinMap.E164Alias.JoinNumber, this.CodecInfo.E164Alias);
-            trilist.SetString(joinMap.H323Id.JoinNumber, this.CodecInfo.H323Id);
-            trilist.SetString(joinMap.SipUri.JoinNumber, this.CodecInfo.SipUri);
-
-            trilist.OnlineStatusChange += (o, a) =>
-            {
-                if (a.DeviceOnLine)
-                {
-                    trilist.SetBool(joinMap.MultiSiteOptionIsEnabled.JoinNumber, this.CodecInfo.MultiSiteOptionIsEnabled);
-                    trilist.SetBool(joinMap.AutoAnswerEnabled.JoinNumber, this.CodecInfo.AutoAnswerEnabled);
-                    trilist.SetString(joinMap.DeviceIpAddresss.JoinNumber, this.CodecInfo.IpAddress);
-                    trilist.SetString(joinMap.SipPhoneNumber.JoinNumber, this.CodecInfo.SipPhoneNumber);
-                    trilist.SetString(joinMap.E164Alias.JoinNumber, this.CodecInfo.E164Alias);
-                    trilist.SetString(joinMap.H323Id.JoinNumber, this.CodecInfo.H323Id);
-                    trilist.SetString(joinMap.SipUri.JoinNumber, this.CodecInfo.SipUri);
-                }
-            };
-        }
-
 		private void LinkVideoCodecPhoneToApi(IHasPhoneDialing codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
 			codec.PhoneOffHookFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PhoneHookState.JoinNumber]);
@@ -680,37 +628,37 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			{
 				if (meetingIndex >= maxParticipants * offset) break;
 
-//                Debug.Console(2, this,
-//@"Updating Participant on xsig:
-//Name: {0} (s{9})
-//AudioMute: {1} (d{10})
-//VideoMute: {2} (d{11})
-//CanMuteVideo: {3} (d{12})
-//CanUMuteVideo: {4} (d{13})
-//IsHost: {5} (d{14})
-//HandIsRaised: {6} (d{15})
-//IsPinned: {7} (d{16})
-//ScreenIndexIsPinnedTo: {8} (a{17})
-//",
-// participant.Name,
-// participant.AudioMuteFb,
-// participant.VideoMuteFb,
-// participant.CanMuteVideo,
-// participant.CanUnmuteVideo,
-// participant.IsHost,
-// participant.HandIsRaisedFb,
-// participant.IsPinnedFb,
-// participant.ScreenIndexIsPinnedToFb,
-// stringIndex + 1,
-// digitalIndex + 1,
-// digitalIndex + 2,
-// digitalIndex + 3,
-// digitalIndex + 4,
-// digitalIndex + 5,
-// digitalIndex + 6,
-// digitalIndex + 7,
-// analogIndex + 1
-// );
+                Debug.Console(2, this,
+@"Updating Participant on xsig:
+Name: {0} (s{9})
+AudioMute: {1} (d{10})
+VideoMute: {2} (d{11})
+CanMuteVideo: {3} (d{12})
+CanUMuteVideo: {4} (d{13})
+IsHost: {5} (d{14})
+HandIsRaised: {6} (d{15})
+IsPinned: {7} (d{16})
+ScreenIndexIsPinnedTo: {8} (a{17})
+",
+ participant.Name,
+ participant.AudioMuteFb,
+ participant.VideoMuteFb,
+ participant.CanMuteVideo,
+ participant.CanUnmuteVideo,
+ participant.IsHost,
+ participant.HandIsRaisedFb,
+ participant.IsPinnedFb,
+ participant.ScreenIndexIsPinnedToFb,
+ stringIndex + 1,
+ digitalIndex + 1,
+ digitalIndex + 2,
+ digitalIndex + 3,
+ digitalIndex + 4,
+ digitalIndex + 5,
+ digitalIndex + 6,
+ digitalIndex + 7,
+ analogIndex + 1
+ );
 
 
 				//digitals
@@ -837,16 +785,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 			_currentMeetings = codec.CodecSchedule.Meetings.Where(m => m.StartTime >= currentTime || m.EndTime >= currentTime).ToList();
 
-            if (_currentMeetings.Count == 0)
-            {
-                var emptyXSigByteArray = XSigHelpers.ClearOutputs();
-                var emptyXSigString = Encoding.GetEncoding(XSigEncoding)
-                    .GetString(emptyXSigByteArray, 0, emptyXSigByteArray.Length);
-
-                trilist.SetString(joinMap.Schedule.JoinNumber, emptyXSigString);
-                return;
-            }
-
 			var meetingsData = UpdateMeetingsListXSig(_currentMeetings);
 			trilist.SetString(joinMap.Schedule.JoinNumber, meetingsData);
 			trilist.SetUshort(joinMap.MeetingCount.JoinNumber, (ushort)_currentMeetings.Count);
@@ -939,33 +877,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 		private void LinkVideoCodecDirectoryToApi(IHasDirectory codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
 			codec.CurrentDirectoryResultIsNotDirectoryRoot.LinkComplementInputSig(
-				trilist.BooleanInput[joinMap.DirectoryIsRoot.JoinNumber]);			
+				trilist.BooleanInput[joinMap.DirectoryIsRoot.JoinNumber]);
+
+			trilist.SetSigFalseAction(joinMap.DirectoryRoot.JoinNumber, codec.SetCurrentDirectoryToRoot);
 
 			trilist.SetStringSigAction(joinMap.DirectorySearchString.JoinNumber, codec.SearchDirectory);
 
-			trilist.SetUShortSigAction(joinMap.DirectorySelectRow.JoinNumber, (i) => SelectDirectoryEntry(codec, i, trilist, joinMap));
-
-            // Report feedback for number of contact methods for selected contact
+			trilist.SetUShortSigAction(joinMap.DirectorySelectRow.JoinNumber, (i) => SelectDirectoryEntry(codec, i));
 
 			trilist.SetSigFalseAction(joinMap.DirectoryRoot.JoinNumber, codec.SetCurrentDirectoryToRoot);
 
 			trilist.SetSigFalseAction(joinMap.DirectoryFolderBack.JoinNumber, codec.GetDirectoryParentFolderContents);
 
-		    if (codec.DirectoryRoot != null)
-		    {
-                trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)codec.DirectoryRoot.CurrentDirectoryResults.Count);
-
-                var clearBytes = XSigHelpers.ClearOutputs();
-
-                trilist.SetString(joinMap.DirectoryEntries.JoinNumber,
-                    Encoding.GetEncoding(XSigEncoding).GetString(clearBytes, 0, clearBytes.Length));
-                var directoryXSig = UpdateDirectoryXSig(codec.DirectoryRoot, !codec.CurrentDirectoryResultIsNotDirectoryRoot.BoolValue);
-
-                Debug.Console(2, this, "Directory XSig Length: {0}", directoryXSig.Length);
-
-                trilist.SetString(joinMap.DirectoryEntries.JoinNumber, directoryXSig);
-		    }
-
 			codec.DirectoryResultReturned += (sender, args) =>
 			{
 				trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)args.Directory.CurrentDirectoryResults.Count);
@@ -976,160 +899,44 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 					Encoding.GetEncoding(XSigEncoding).GetString(clearBytes, 0, clearBytes.Length));
 				var directoryXSig = UpdateDirectoryXSig(args.Directory, !codec.CurrentDirectoryResultIsNotDirectoryRoot.BoolValue);
 
-                Debug.Console(2, this, "Directory XSig Length: {0}", directoryXSig.Length);
-
 				trilist.SetString(joinMap.DirectoryEntries.JoinNumber, directoryXSig);
 			};
 		}
 
-
-
-		private void SelectDirectoryEntry(IHasDirectory codec, ushort i, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
+		private void SelectDirectoryEntry(IHasDirectory codec, ushort i)
 		{
-            if (i < 1 || i > codec.CurrentDirectoryResult.CurrentDirectoryResults.Count) return;
+			var entry = codec.CurrentDirectoryResult.CurrentDirectoryResults[i - 1];
 
-			_selectedDirectoryItem = codec.CurrentDirectoryResult.CurrentDirectoryResults[i - 1];
-
-
-			if (_selectedDirectoryItem is DirectoryFolder)
+			if (entry is DirectoryFolder)
 			{
-				codec.GetDirectoryFolderContents(_selectedDirectoryItem.FolderId);
-                trilist.SetUshort(joinMap.SelectedContactMethodCount.JoinNumber, 0);
-                trilist.SetString(joinMap.DirectorySelectedFolderName.JoinNumber, _selectedDirectoryItem.Name);
-                trilist.SetString(joinMap.DirectoryEntrySelectedName.JoinNumber, string.Empty);
-                trilist.ClearUShortSigAction(joinMap.SelectContactMethod.JoinNumber);
-                trilist.ClearBoolSigAction(joinMap.DirectoryDialSelectedLine.JoinNumber);
-                trilist.ClearBoolSigAction(joinMap.DirectoryDialSelectedContactMethod.JoinNumber);
-                return;
+				codec.GetDirectoryFolderContents(entry.FolderId);
+				return;
 			}
 
-            // not a folder.  Clear this value
-            trilist.SetString(joinMap.DirectorySelectedFolderName.JoinNumber, string.Empty);
+			var dialableEntry = entry as IInvitableContact;
 
-            var selectedContact = _selectedDirectoryItem as DirectoryContact;
-            if (selectedContact != null)
-            {
-                trilist.SetString(joinMap.DirectoryEntrySelectedName.JoinNumber, selectedContact.Name);
-            
-            }
+			if (dialableEntry != null)
+			{
+				Dial(dialableEntry);
+				return;
+			}
 
-            // Allow auto dial of selected line.  Always dials first contact method
-            if (!trilist.GetBool(joinMap.DirectoryDisableAutoDialSelectedLine.JoinNumber))
-            {
-                var invitableEntry = _selectedDirectoryItem as IInvitableContact;
+			var entryToDial = entry as DirectoryContact;
 
-                if (invitableEntry != null)
-                {
-                    Dial(invitableEntry);
-                    return;
-                }
+			if (entryToDial == null) return;
 
-                var entryToDial = _selectedDirectoryItem as DirectoryContact;
-
-                trilist.SetString(joinMap.DirectoryEntrySelectedNumber.JoinNumber, selectedContact.ContactMethods[0].Number);
-
-                if (entryToDial == null) return;
-
-                Dial(entryToDial.ContactMethods[0].Number);
-                return;
-            }
-            else
-            {
-                // If auto dial is disabled...
-                var entryToDial = _selectedDirectoryItem as DirectoryContact;
-
-                if (entryToDial == null)
-                {
-                    // Clear out values and actions from last selected item
-                    trilist.SetUshort(joinMap.SelectedContactMethodCount.JoinNumber, 0);
-                    trilist.SetString(joinMap.DirectoryEntrySelectedName.JoinNumber, string.Empty);
-                    trilist.ClearUShortSigAction(joinMap.SelectContactMethod.JoinNumber);
-                    trilist.ClearBoolSigAction(joinMap.DirectoryDialSelectedLine.JoinNumber);
-                    trilist.ClearBoolSigAction(joinMap.DirectoryDialSelectedContactMethod.JoinNumber);
-                    return;
-                }
-
-                trilist.SetUshort(joinMap.SelectedContactMethodCount.JoinNumber, (ushort)entryToDial.ContactMethods.Count);
-
-                // Update the action to dial the selected contact method
-                trilist.SetUShortSigAction(joinMap.SelectContactMethod.JoinNumber, (u) =>
-                {
-                    if (u < 1 || u > entryToDial.ContactMethods.Count) return;
-
-                    trilist.SetSigFalseAction(joinMap.DirectoryDialSelectedContactMethod.JoinNumber, () => Dial(entryToDial.ContactMethods[u - 1].Number));
-                });
-
-                // Sets DirectoryDialSelectedLine join action to dial first contact method
-                trilist.SetSigFalseAction(joinMap.DirectoryDialSelectedLine.JoinNumber, () => Dial(entryToDial.ContactMethods[0].Number));
-
-                var clearBytes = XSigHelpers.ClearOutputs();
-
-                trilist.SetString(joinMap.ContactMethods.JoinNumber,
-                    Encoding.GetEncoding(XSigEncoding).GetString(clearBytes, 0, clearBytes.Length));
-                var contactMethodsXSig = UpdateContactMethodsXSig(entryToDial);
-
-                trilist.SetString(joinMap.ContactMethods.JoinNumber, contactMethodsXSig);
-            }
+			Dial(entryToDial.ContactMethods[0].Number);
 		}
 
-        /// <summary>
-        /// Generates the XSig data representing the available contact methods for the selected DirectoryContact
-        /// </summary>
-        /// <param name="contact"></param>
-        /// <returns></returns>
-        private string UpdateContactMethodsXSig(DirectoryContact contact)
-        {
-            const int maxMethods = 10;
-            const int maxStrings = 3;
-            const int offset = maxStrings;
-            var stringIndex = 0;
-            var arrayIndex = 0;
-            // Create a new token array and set the size to the number of methods times the total number of signals
-            var tokenArray = new XSigToken[maxMethods * offset];
-
-            Debug.Console(2, this, "Creating XSIG token array with size {0}", maxMethods * offset);
-
-            // TODO: Add code to generate XSig data
-            foreach (var method in contact.ContactMethods)
-            {
-                if (arrayIndex >= maxMethods * offset)
-                    break;
-
-                //serials
-                tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 1, method.Number);
-                tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 2, method.ContactMethodId.ToString());
-                tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 3, method.Device.ToString());
-
-				arrayIndex += offset;
-				stringIndex += maxStrings;
-            }
-
-            while (arrayIndex < maxMethods)
-            {
-                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);
-
-				arrayIndex += offset;
-				stringIndex += maxStrings;
-            }
-
-            return GetXSigString(tokenArray);
-        }
-
 		private string UpdateDirectoryXSig(CodecDirectory directory, bool isRoot)
 		{
 			var contactIndex = 1;
 			var tokenArray = new XSigToken[directory.CurrentDirectoryResults.Count];
 
-            Debug.Console(2, this, "Is root {0} Directory Count: {1}", isRoot, directory.CurrentDirectoryResults.Count);
-
 			foreach (var entry in directory.CurrentDirectoryResults)
 			{
 				var arrayIndex = contactIndex - 1;
 
-                Debug.Console(2, this, "Entry Name: {0}, Folder ID: {1}", entry.Name, entry.FolderId);
-
 				if (entry is DirectoryFolder && entry.ParentFolderId == "root")
 				{
 					tokenArray[arrayIndex] = new XSigSerialToken(contactIndex, String.Format("[+] {0}", entry.Name));
@@ -1139,6 +946,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 					continue;
 				}
 
+				if (isRoot && String.IsNullOrEmpty(entry.FolderId)) continue;
+
 				tokenArray[arrayIndex] = new XSigSerialToken(contactIndex, entry.Name);
 
 				contactIndex++;
@@ -1152,34 +961,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			trilist.SetSigFalseAction(joinMap.ManualDial.JoinNumber,
 				() => Dial(trilist.StringOutput[joinMap.CurrentDialString.JoinNumber].StringValue));
 
-			//End All calls
-			trilist.SetSigFalseAction(joinMap.EndAllCalls.JoinNumber, EndAllCalls);
-
-            //End a specific call, specified by index. Maximum 8 calls supported
-            for (int i = 0; i < joinMap.EndCallStart.JoinSpan; i++)
-            {
-                var callIndex = i;
-
-                trilist.SetSigFalseAction((uint)(joinMap.EndCallStart.JoinNumber + i), () =>
-                    {
-
-                        if (callIndex < 0 || callIndex >= ActiveCalls.Count)
-                        {
-                            Debug.Console(2, this, "Cannot end call. No call found at index: {0}", callIndex);
-                            return;
-                        }
-
-                        var call = ActiveCalls[callIndex];
-                        if (call != null)
-                        {
-                            EndCall(call);
-                        }
-                        else
-                        {
-                            Debug.Console(0, this, "[End Call] Unable to find call at index '{0}'", i);
-                        }
-                    });
-            }
+			//End All calls for now
+			trilist.SetSigFalseAction(joinMap.EndCall.JoinNumber, EndAllCalls);
 
 			trilist.SetBool(joinMap.HookState.JoinNumber, IsInCall);
 
@@ -1191,104 +974,21 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				Debug.Console(1, this, "Call is incoming: {0}", args.CallItem.Direction == eCodecCallDirection.Incoming);
 				trilist.SetBool(joinMap.IncomingCall.JoinNumber, args.CallItem.Direction == eCodecCallDirection.Incoming && args.CallItem.Status == eCodecCallStatus.Ringing);
 
-                if (args.CallItem.Direction == eCodecCallDirection.Incoming)
-                {
-                    trilist.SetSigFalseAction(joinMap.IncomingAnswer.JoinNumber, () => AcceptCall(args.CallItem));
-                    trilist.SetSigFalseAction(joinMap.IncomingReject.JoinNumber, () => RejectCall(args.CallItem));
-                    trilist.SetString(joinMap.IncomingCallName.JoinNumber, args.CallItem.Name);
-                    trilist.SetString(joinMap.IncomingCallNumber.JoinNumber, args.CallItem.Number);
-                }
-                else
-                {
-                    trilist.SetString(joinMap.IncomingCallName.JoinNumber, string.Empty);
-                    trilist.SetString(joinMap.IncomingCallNumber.JoinNumber, string.Empty);
-                }
-
+				if (args.CallItem.Direction == eCodecCallDirection.Incoming)
+				{
+					trilist.SetSigFalseAction(joinMap.IncomingAnswer.JoinNumber, () => AcceptCall(args.CallItem));
+					trilist.SetSigFalseAction(joinMap.IncomingReject.JoinNumber, () => RejectCall(args.CallItem));
+				}
 
 				trilist.SetString(joinMap.CurrentCallData.JoinNumber, UpdateCallStatusXSig());
-
-                trilist.SetUshort(joinMap.ConnectedCallCount.JoinNumber, (ushort)ActiveCalls.Count);
 			};
-
-            var joinCodec = this as IJoinCalls;
-            if (joinCodec != null)
-            {
-                trilist.SetSigFalseAction(joinMap.JoinAllCalls.JoinNumber, () => joinCodec.JoinAllCalls());
-
-                for (int i = 0; i < joinMap.JoinCallStart.JoinSpan; i++)
-                {
-                    trilist.SetSigFalseAction((uint)(joinMap.JoinCallStart.JoinNumber + i), () =>
-                        {
-                            var call = ActiveCalls[i];
-                            if (call != null)
-                            {
-                                joinCodec.JoinCall(call);
-                            } 
-                            else
-                            {
-                                Debug.Console(0, this, "[Join Call] Unable to find call at index '{0}'", i);
-                            }
-                        });
-                }
-            }
-
-            var holdCodec = this as IHasCallHold;
-            if (holdCodec != null)
-            {
-                trilist.SetSigFalseAction(joinMap.HoldAllCalls.JoinNumber, () =>
-                {
-                    foreach (var call in ActiveCalls)
-                    {
-                        holdCodec.HoldCall(call);
-                    }
-                });
-
-                for (int i = 0; i < joinMap.HoldCallsStart.JoinSpan; i++)
-                {
-                    var index = i;
-
-                    trilist.SetSigFalseAction((uint)(joinMap.HoldCallsStart.JoinNumber + index), () =>
-                        {
-                            if (index < 0 || index >= ActiveCalls.Count) return;
-
-                            var call = ActiveCalls[index];
-                            if (call != null)
-                            {
-                                holdCodec.HoldCall(call);
-                            } 
-                            else
-                            {
-                                Debug.Console(0, this, "[Hold Call] Unable to find call at index '{0}'", i);
-                            }
-                        });
-
-                    trilist.SetSigFalseAction((uint)(joinMap.ResumeCallsStart.JoinNumber + index), () =>
-                        {
-                            if (index < 0 || index >= ActiveCalls.Count) return;
-
-                            var call = ActiveCalls[index];
-                            if (call != null)
-                            {
-                                holdCodec.ResumeCall(call);
-                            } 
-                            else
-                            {
-                                Debug.Console(0, this, "[Resume Call] Unable to find call at index '{0}'", i);
-                            }
-                        });
-                }
-            }
-
-
-
 		}
 
 		private string UpdateCallStatusXSig()
 		{
 			const int maxCalls = 8;
-			const int maxStrings = 6;
-            const int maxDigitals = 2;
-			const int offset = maxStrings + maxDigitals;
+			const int maxStrings = 5;
+			const int offset = 6;
 			var stringIndex = 0;
 			var digitalIndex = maxStrings * maxCalls;
 			var arrayIndex = 0;
@@ -1300,8 +1000,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				if (arrayIndex >= maxCalls * offset)
 					break;
 				//digitals
-                tokenArray[digitalIndex] = new XSigDigitalToken(digitalIndex + 1, call.IsActiveCall);
-                tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, call.IsOnHold);
+				tokenArray[arrayIndex] = new XSigDigitalToken(digitalIndex + 1, call.IsActiveCall);
 
 				//serials
 				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
@@ -1309,12 +1008,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				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
-                    var dur = string.Format("{0:c}", call.Duration);
-                    tokenArray[arrayIndex + 6] = new XSigSerialToken(stringIndex + 6, dur);
-                }
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;
@@ -1323,17 +1016,14 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			while (digitalIndex < maxCalls)
 			{
 				//digitals
-                tokenArray[digitalIndex] = new XSigDigitalToken(digitalIndex + 1, false);
-                tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, false);
+				tokenArray[arrayIndex] = new XSigDigitalToken(digitalIndex + 1, false);
 
-
-                //serials
+				//serials
 				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;
@@ -1345,61 +1035,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 		private void LinkVideoCodecDtmfToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
-            trilist.SetSigFalseAction(joinMap.Dtmf0.JoinNumber, () => SendDtmfAction("0", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf1.JoinNumber, () => SendDtmfAction("1", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf2.JoinNumber, () => SendDtmfAction("2", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf3.JoinNumber, () => SendDtmfAction("3", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf4.JoinNumber, () => SendDtmfAction("4", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf5.JoinNumber, () => SendDtmfAction("5", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf6.JoinNumber, () => SendDtmfAction("6", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf7.JoinNumber, () => SendDtmfAction("7", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf8.JoinNumber, () => SendDtmfAction("8", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.Dtmf9.JoinNumber, () => SendDtmfAction("9", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.DtmfStar.JoinNumber, () => SendDtmfAction("*", trilist, joinMap));
-            trilist.SetSigFalseAction(joinMap.DtmfPound.JoinNumber, () => SendDtmfAction("#", trilist, joinMap));       
+			trilist.SetSigFalseAction(joinMap.Dtmf0.JoinNumber, () => SendDtmf("0"));
+			trilist.SetSigFalseAction(joinMap.Dtmf1.JoinNumber, () => SendDtmf("1"));
+			trilist.SetSigFalseAction(joinMap.Dtmf2.JoinNumber, () => SendDtmf("2"));
+			trilist.SetSigFalseAction(joinMap.Dtmf3.JoinNumber, () => SendDtmf("3"));
+			trilist.SetSigFalseAction(joinMap.Dtmf4.JoinNumber, () => SendDtmf("4"));
+			trilist.SetSigFalseAction(joinMap.Dtmf5.JoinNumber, () => SendDtmf("5"));
+			trilist.SetSigFalseAction(joinMap.Dtmf6.JoinNumber, () => SendDtmf("6"));
+			trilist.SetSigFalseAction(joinMap.Dtmf7.JoinNumber, () => SendDtmf("7"));
+			trilist.SetSigFalseAction(joinMap.Dtmf8.JoinNumber, () => SendDtmf("8"));
+			trilist.SetSigFalseAction(joinMap.Dtmf9.JoinNumber, () => SendDtmf("9"));
+			trilist.SetSigFalseAction(joinMap.DtmfStar.JoinNumber, () => SendDtmf("*"));
+			trilist.SetSigFalseAction(joinMap.DtmfPound.JoinNumber, () => SendDtmf("#"));
 		}
 
-        /// <summary>
-        /// Sends the specified string as a DTMF command.
-        /// Reads the value of the SendDtmfToSpecificCallInstance digital join and SelectCall analog join to determine
-        /// Whther to send to a specific call index or to the last connected call
-        /// </summary>
-        /// <param name="s"></param>
-        /// <param name="trilist"></param>
-        /// <param name="joinMap"></param>
-        private void SendDtmfAction(string s, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
-        {
-            if (!trilist.GetBool(joinMap.SendDtmfToSpecificCallIndex.JoinNumber))
-            {
-                SendDtmf(s);
-            }
-            else
-            {
-                var callIndex = trilist.GetUshort(joinMap.SelectCall.JoinNumber);
-                if (callIndex > 0 && callIndex <= 8)
-                {
-                    var call = ActiveCalls[callIndex - 1];
-                    if (call != null && call.IsActiveCall)
-                    {
-                        SendDtmf(s, call);
-                    }
-                    else
-                    {
-                        Debug.Console(0, this, "Warning: No call found at index {0} or call is not active.", callIndex);
-                    }
-                }
-                else
-                {
-                    Debug.Console(0, this, "Warning: Invalid call index specified.  Please use a value of 1-8.");
-                }
-            }
-        }
-
 		private void LinkVideoCodecCameraLayoutsToApi(IHasCodecLayouts codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
 		{
 			trilist.SetSigFalseAction(joinMap.CameraLayout.JoinNumber, codec.LocalLayoutToggle);
 
-			codec.LocalLayoutFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentLayoutStringFb.JoinNumber]);
+			codec.LocalLayoutFeedback.LinkInputSig(trilist.StringInput[joinMap.CameraLayoutStringFb.JoinNumber]);
 		}
 
 		private void LinkVideoCodecCameraModeToApi(IHasCameraAutoMode codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
@@ -1530,81 +1184,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 				else camera.ZoomStop();
 			});
 
-
-            trilist.SetBoolSigAction(joinMap.CameraFocusNear.JoinNumber, (b) =>
-            {
-                if (codec.SelectedCamera == null) return;
-                var camera = codec.SelectedCamera as IHasCameraFocusControl;
-
-                if (camera == null) return;
-
-                if (b) camera.FocusNear();
-                else camera.FocusStop();
-            });
-
-            trilist.SetBoolSigAction(joinMap.CameraFocusFar.JoinNumber, (b) =>
-            {
-                if (codec.SelectedCamera == null) return;
-                var camera = codec.SelectedCamera as IHasCameraFocusControl;
-
-                if (camera == null) return;
-
-                if (b) camera.FocusFar();
-                else camera.FocusStop();
-            });
-
-            trilist.SetSigFalseAction(joinMap.CameraFocusAuto.JoinNumber, () =>
-            {
-                if (codec.SelectedCamera == null) return;
-                var camera = codec.SelectedCamera as IHasCameraFocusControl;
-
-                if (camera == null) return;
-
-                camera.TriggerAutoFocus();
-            });
-
-            // Camera count
-            trilist.SetUshort(joinMap.CameraCount.JoinNumber, (ushort)codec.Cameras.Count);
-
-            // Camera names
-            for (uint i = 0; i < joinMap.CameraNamesFb.JoinSpan; i++)
-            {
-                //Check the count first
-                if (i < codec.Cameras.Count && codec.Cameras[(int)i] != null)
-                {
-                    trilist.SetString(joinMap.CameraNamesFb.JoinNumber + i, codec.Cameras[(int)i].Name);
-                }
-                else
-                {
-                    trilist.SetString(joinMap.CameraNamesFb.JoinNumber + i, "");
-                }
-            }
-
 			//Camera Select
 			trilist.SetUShortSigAction(joinMap.CameraNumberSelect.JoinNumber, (i) =>
 			{
-                if (i > 0 && i <= codec.Cameras.Count)
-                {
-                    codec.SelectCamera(codec.Cameras[i - 1].Key);
-                }
-                else
-                {
-                    Debug.Console(0, this, "Unable to select.  No camera found at index {0}", i);
-                }
-			});
+				if (codec.SelectedCamera == null) return;
 
-            // Set initial selected camera feedback
-            if (codec.SelectedCamera != null)
-            {
-                trilist.SetUshort(joinMap.CameraNumberSelect.JoinNumber, (ushort)codec.Cameras.FindIndex((c) => c.Key == codec.SelectedCamera.Key));
-            }
+				codec.SelectCamera(codec.Cameras[i].Key);
+			});
 
 			codec.CameraSelected += (sender, args) =>
 			{
 				var i = (ushort)codec.Cameras.FindIndex((c) => c.Key == args.SelectedCamera.Key);
 
-                trilist.SetUshort(joinMap.CameraNumberSelect.JoinNumber, (ushort)(i + 1));
-
 				if (codec is IHasCodecRoomPresets)
 				{
 					return;
@@ -1647,16 +1238,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 			trilist.SetUShortSigAction(joinMap.CameraPresetSelect.JoinNumber, (i) =>
 			{
 				presetCodec.CodecRoomPresetSelect(i);
+
+				trilist.SetUshort(joinMap.CameraPresetSelect.JoinNumber, i);
 			});
 
-
-            // Far End Presets
-            trilist.SetUShortSigAction(joinMap.FarEndPresetSelect.JoinNumber, (i) =>
-            {
-                presetCodec.SelectFarEndPreset(i);
-            });
-
-
 			trilist.SetSigFalseAction(joinMap.CameraPresetSave.JoinNumber,
 					() =>
 					{
@@ -1666,96 +1251,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 					});
 		}
 
-        // Following fields only used for Bridging
-        private int _selectedRecentCallItemIndex;
-        private CodecCallHistory.CallHistoryEntry _selectedRecentCallItem;
-        private DirectoryItem _selectedDirectoryItem;
-
-        private void LinkVideoCodecCallHistoryToApi(IHasCallHistory codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
-        {
-            codec.CallHistory.RecentCallsListHasChanged += (o, a) =>
-                {
-                    UpdateCallHistory(codec, trilist, joinMap);  
-                };
-
-            // Selected item action and feedback
-            trilist.SetUShortSigAction(joinMap.SelectRecentCallItem.JoinNumber, (u) =>
-                {
-                    if (u == 0 || u > codec.CallHistory.RecentCalls.Count) 
-                    {
-                        Debug.Console(2, this, "Recent Call History index out of range");
-                        return;
-                    }
-
-                    _selectedRecentCallItemIndex = (int)(u - 1);
-                    trilist.SetUshort(joinMap.SelectRecentCallItem.JoinNumber, u);     
-
-                    var _selectedRecentCallItem = codec.CallHistory.RecentCalls[_selectedRecentCallItemIndex];
-                    
-                    if (_selectedRecentCallItem != null)
-                    {
-                        trilist.SetString(joinMap.SelectedRecentCallName.JoinNumber, _selectedRecentCallItem.Name);
-                        trilist.SetString(joinMap.SelectedRecentCallNumber.JoinNumber, _selectedRecentCallItem.Number);
-                        trilist.SetSigFalseAction(joinMap.RemoveSelectedRecentCallItem.JoinNumber, () => codec.RemoveCallHistoryEntry(_selectedRecentCallItem));
-                        trilist.SetSigFalseAction(joinMap.DialSelectedRecentCallItem.JoinNumber, () => this.Dial(_selectedRecentCallItem.Number));
-                    }
-                    else
-                    {
-                        trilist.SetString(joinMap.SelectedRecentCallName.JoinNumber, string.Empty);
-                        trilist.SetString(joinMap.SelectedRecentCallNumber.JoinNumber, string.Empty);
-                        trilist.ClearBoolSigAction(joinMap.RemoveSelectedRecentCallItem.JoinNumber);
-                        trilist.ClearBoolSigAction(joinMap.DialSelectedRecentCallItem.JoinNumber);
-                    }
-                });
-        }
-
-
-
-        private void UpdateCallHistory(IHasCallHistory codec, BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
-        {
-            // Clear out selected item
-            _selectedRecentCallItemIndex = 0;
-            _selectedRecentCallItem = null;
-            trilist.SetUshort(joinMap.SelectRecentCallItem.JoinNumber, 0);
-            trilist.SetString(joinMap.SelectedRecentCallName.JoinNumber, string.Empty);
-            trilist.SetString(joinMap.SelectedRecentCallNumber.JoinNumber, string.Empty);
-            trilist.ClearBoolSigAction(joinMap.RemoveSelectedRecentCallItem.JoinNumber);
-            //
-
-            trilist.SetUshort(joinMap.RecentCallCount.JoinNumber, (ushort)codec.CallHistory.RecentCalls.Count);
-
-            // Update the call history joins
-            var maxItems = joinMap.RecentCallNamesStart.JoinSpan;
-
-            // Create history
-            uint index = 0;          
-            for (uint i = 0; i < maxItems && i < codec.CallHistory.RecentCalls.Count; i++)
-            {
-                trilist.SetString(joinMap.RecentCallNamesStart.JoinNumber + i, codec.CallHistory.RecentCalls[(int)i].Name);
-                trilist.SetString(joinMap.RecentCallTimesStart.JoinNumber + i, codec.CallHistory.RecentCalls[(int)i].StartTime.ToShortTimeString());
-                trilist.SetUshort(joinMap.RecentCallOccurrenceType.JoinNumber + i, (ushort)codec.CallHistory.RecentCalls[(int)i].OccurrenceType);
-                //i++;
-                index = i;
-            }
-            
-            //foreach(var item in codec.CallHistory.RecentCalls)
-            //{
-            //    trilist.SetString(joinMap.RecentCallNamesStart.JoinNumber + i, item.Name);
-            //    trilist.SetString(joinMap.RecentCallTimesStart.JoinNumber + i, item.StartTime.ToShortTimeString());
-            //    trilist.SetUshort(joinMap.RecentCallOccurrenceType.JoinNumber + i, (ushort)item.OccurrenceType);
-            //    i++;
-            //}
-
-            // Clears existing items 
-            for (uint j = index; j < maxItems; j++)
-            {
-                trilist.SetString(joinMap.RecentCallNamesStart.JoinNumber + j, string.Empty);
-                trilist.SetString(joinMap.RecentCallTimesStart.JoinNumber + j, string.Empty);
-                trilist.SetUshort(joinMap.RecentCallOccurrenceType.JoinNumber + j, 0);
-            }
-        }
-
-        private string SetCameraPresetNames(IEnumerable<CodecRoomPreset> presets)
+		private string SetCameraPresetNames(IEnumerable<CodecRoomPreset> presets)
 		{
 			return SetCameraPresetNames(presets.Select(p => p.Description).ToList());
 		}

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

@@ -1306,16 +1306,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 								var codecBookings = JsonConvert.DeserializeObject<List<zCommand.BookingsListResult>>(
 									responseObj.ToString());
 
-							    if (codecBookings != null && codecBookings.Count > 0)
-							    {
-							        CodecSchedule.Meetings = zCommand.GetGenericMeetingsFromBookingResult(
-							            codecBookings, CodecSchedule.MeetingWarningMinutes);
-							    }
-							    else
-							    {
-							        //need to clear the list if it's empty
-							        CodecSchedule.Meetings = new List<Meeting>();
-							    }
+								if (codecBookings != null && codecBookings.Count > 0)
+								{
+									CodecSchedule.Meetings = zCommand.GetGenericMeetingsFromBookingResult(
+										codecBookings, CodecSchedule.MeetingWarningMinutes);
+								}
 
 								break;
 							}