refactor: rearrange and add solution for 4-series

src/PepperDash.Essentials.Core/Timers/CountdownTimer.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    public class SecondsCountdownTimer: IKeyed
+    {
+        public event EventHandler<EventArgs> HasStarted;
+        public event EventHandler<EventArgs> HasFinished;
+        public event EventHandler<EventArgs> WasCancelled;
+
+        public string Key { get; private set; }
+
+        public BoolFeedback IsRunningFeedback { get; private set; }
+        bool _isRunning;
+
+        public IntFeedback PercentFeedback { get; private set; }
+        public StringFeedback TimeRemainingFeedback { get; private set; }
+
+        public bool CountsDown { get; set; }
+
+        /// <summary>
+        /// The number of seconds to countdown
+        /// </summary>
+        public int SecondsToCount { get; set; }
+        
+        public DateTime StartTime { get; private set; }
+        public DateTime FinishTime { get; private set; }
+ 
+        private CTimer _secondTimer;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="key"></param>
+        public SecondsCountdownTimer(string key)
+        {
+            Key = key;
+            IsRunningFeedback = new BoolFeedback(() => _isRunning);
+
+            TimeRemainingFeedback = new StringFeedback(() =>
+                {
+                    // Need to handle up and down here.
+
+                    var timeSpan = FinishTime - DateTime.Now;
+
+                    Debug.Console(2, this,
+                        "timeSpan.Minutes == {0}, timeSpan.Seconds == {1}, timeSpan.TotalSeconds == {2}",
+                        timeSpan.Minutes, timeSpan.Seconds, timeSpan.TotalSeconds);
+
+                    if (Math.Floor(timeSpan.TotalSeconds) < 60 && Math.Floor(timeSpan.TotalSeconds) >= 0) //ignore milliseconds
+                    {
+                        return String.Format("{0:00}", timeSpan.Seconds);
+                    }
+
+                    return Math.Floor(timeSpan.TotalSeconds) < 0
+                        ? "00"
+                        : String.Format("{0:00}:{1:00}", timeSpan.Minutes, timeSpan.Seconds);
+                });
+
+            PercentFeedback =
+                new IntFeedback(
+                    () =>
+                        (int)
+                            (Math.Floor((FinishTime - DateTime.Now).TotalSeconds)/
+                             Math.Floor((FinishTime - StartTime).TotalSeconds)*100));
+        }
+
+        /// <summary>
+        /// Starts the Timer
+        /// </summary>
+        public void Start()
+        {
+            if (_isRunning)
+                return;
+            StartTime = DateTime.Now;
+            FinishTime = StartTime + TimeSpan.FromSeconds(SecondsToCount);
+
+            if (_secondTimer != null)
+                _secondTimer.Stop();
+            _secondTimer = new CTimer(SecondElapsedTimerCallback, null, 0, 1000);
+            _isRunning = true;
+            IsRunningFeedback.FireUpdate();
+
+            var handler = HasStarted;
+            if (handler != null)
+                handler(this, new EventArgs());
+        }
+
+        /// <summary>
+        /// Restarts the timer
+        /// </summary>
+        public void Reset()
+        {
+            _isRunning = false;
+            Start();
+        }
+
+        /// <summary>
+        /// Cancels the timer (without triggering it to finish)
+        /// </summary>
+        public void Cancel()
+        {
+            StopHelper();
+            
+            var handler = WasCancelled;
+            if (handler != null)
+                handler(this, new EventArgs());
+        }
+
+        /// <summary>
+        /// Called upon expiration, or calling this will force timer to finish.
+        /// </summary>
+        public void Finish()
+        {
+            StopHelper();
+
+            var handler = HasFinished;
+            if (handler != null)
+                handler(this, new EventArgs());
+        }
+
+        void StopHelper()
+        {
+            if (_secondTimer != null)
+                _secondTimer.Stop();
+            _isRunning = false;
+            IsRunningFeedback.FireUpdate(); 
+        }
+
+        void SecondElapsedTimerCallback(object o)
+        {
+            if (DateTime.Now >= FinishTime)
+            {
+                Finish();
+                return;
+            }
+
+            PercentFeedback.FireUpdate();
+            TimeRemainingFeedback.FireUpdate();
+        }
+    }
+}

src/PepperDash.Essentials.Core/Timers/RetriggerableTimer.cs

@@ -0,0 +1,179 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+using Full.Newtonsoft.Json;
+
+
+namespace PepperDash.Essentials.Core.Timers
+{
+    /// <summary>
+    /// A device that runs a retriggerable timer and can execute actions specified in config 
+    /// </summary>
+    [Description("A retriggerable timer device")]
+    public class RetriggerableTimer : EssentialsDevice
+    {
+        private RetriggerableTimerPropertiesConfig _propertiesConfig;
+
+        private CTimer _timer;
+        private long _timerIntervalMs;
+
+        public RetriggerableTimer(string key, DeviceConfig config)
+            : base(key, config.Name)
+        {
+            var props = config.Properties.ToObject<RetriggerableTimerPropertiesConfig>();
+            _propertiesConfig = props;
+
+            if (_propertiesConfig != null)
+            {
+                _timerIntervalMs = _propertiesConfig.TimerIntervalMs;
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            if (_propertiesConfig.StartTimerOnActivation)
+            {
+                StartTimer();
+            }
+
+            return base.CustomActivate();
+        }
+
+        private void CleanUpTimer()
+        {
+            if (_timer != null)
+            {
+                _timer.Stop();
+                _timer.Dispose();
+            }
+
+            _timer = null;
+        }
+
+        public void StartTimer()
+        {
+             CleanUpTimer();
+             Debug.Console(0, this, "Starting Timer");
+
+             _timer = new CTimer(TimerElapsedCallback, GetActionFromConfig(eRetriggerableTimerEvents.Elapsed), _timerIntervalMs, _timerIntervalMs);
+        }
+
+        public void StopTimer()
+        {
+            Debug.Console(0, this, "Stopping Timer");
+            _timer.Stop();
+
+            ExecuteAction(GetActionFromConfig(eRetriggerableTimerEvents.Stopped));
+        }
+
+        private DeviceActionWrapper GetActionFromConfig(eRetriggerableTimerEvents eventType)
+        {
+            var action = _propertiesConfig.Events[eRetriggerableTimerEvents.Elapsed];
+
+            if (action != null)
+                return action;
+            else return null;
+        }
+
+        /// <summary>
+        /// Executes the Elapsed action from confing when the timer elapses
+        /// </summary>
+        /// <param name="o"></param>
+        private void TimerElapsedCallback(object action)
+        {
+            Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Timer Elapsed. Executing Action");
+
+            if (action == null)
+            {
+                Debug.Console(1, this, "Timer elapsed but unable to execute action. Action is null.");
+                return;
+            }
+
+            var devAction = action as DeviceActionWrapper;
+            if (devAction != null)
+                ExecuteAction(devAction);
+            else
+            {
+                Debug.Console(2, this, "Unable to cast action as DeviceActionWrapper. Cannot Execute");
+            }
+
+        }
+
+        private void ExecuteAction(DeviceActionWrapper action)
+        {
+            if (action == null)
+                return;
+
+            try
+            {
+                DeviceJsonApi.DoDeviceAction(action);
+            }
+            catch (Exception e)
+            {
+                Debug.Console(2, this, "Error Executing Action: {0}", e);
+            }
+            //finally  // Not sure this is needed
+            //{
+            //    _Timer.Reset(0, _TimerIntervalMs);
+            //}
+        }
+    }
+
+    /// <summary>
+    /// Configuration Properties for RetriggerableTimer
+    /// </summary>
+    public class RetriggerableTimerPropertiesConfig
+    {
+        [JsonProperty("startTimerOnActivation")]
+        public bool StartTimerOnActivation { get; set; }
+
+        [JsonProperty("timerIntervalMs")]
+        public long TimerIntervalMs { get; set; }
+
+        [JsonProperty("events")]
+        public Dictionary<eRetriggerableTimerEvents, DeviceActionWrapper> Events { get; set; }
+
+        public RetriggerableTimerPropertiesConfig()
+        {
+            Events = new Dictionary<eRetriggerableTimerEvents, DeviceActionWrapper>();
+        }
+    }
+
+    /// <summary>
+    /// The set of values describing events on the timer
+    /// </summary>
+    public enum eRetriggerableTimerEvents
+    {
+        Elapsed,
+        Stopped,
+    }
+
+    /// <summary>
+    /// Factory class
+    /// </summary>
+    public class RetriggerableTimerFactory : EssentialsDeviceFactory<RetriggerableTimer>
+    {
+        public RetriggerableTimerFactory()
+        {
+            TypeNames = new List<string>() { "retriggerabletimer" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new RetriggerableTimer Device");
+
+            return new RetriggerableTimer(dc.Key, dc);
+        }
+    }
+
+
+}