Started to implement this class

src/app/TaskSchedulerManager.cpp

@@ -1 +1,176 @@
 #include "TaskSchedulerManager.h"
+
+//Schedule part
+
+TaskSchedulerManagerHelper::Schedule::Schedule() :
+  _days(0xFE),
+  _months(0xFFF0),
+  _triggered(false),
+  _triggerRightAway(true),
+  _hasBeenTriggeredRightAway(false),
+  _triggerType(TRIGGER_REPEAT),
+  _mode(EVERY),
+  _enabled(true),
+  _millis(0),
+  _everyMillis(1000),
+  _dateTime(NULL)
+{
+
+}
+
+TaskSchedulerManagerHelper::Schedule::Schedule(const TaskSchedulerManagerHelper::Schedule &Object)
+{
+  if(Object._dateTime != NULL)
+    _dateTime = new DateTime(*(Object._dateTime));
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::scheduleBuilder()
+{
+  return new TaskSchedulerManagerHelper::Schedule();
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setMillis(uint64_t millis)
+{
+  if(millis == 0)return this;
+  
+  _everyMillis = millis;
+  delete _dateTime;_dateTime = NULL;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setDateTime(DateTime &dateTime)
+{
+  _everyMillis = 0;
+  delete _dateTime;_dateTime = NULL;
+  _dateTime = new DateTime(dateTime);
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setDays(uint8_t days)
+{
+  _days = days;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setMonths(uint16_t months)
+{
+  _months = months;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::triggerRightAway(boolean enabled)
+{
+  _triggerRightAway = enabled;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::triggerType(TriggerType triggerType)
+{
+  _triggerType = triggerType;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setMode(Mode mode)
+{
+  _mode = mode;
+  return this;
+}
+
+TaskSchedulerManagerHelper::Schedule *TaskSchedulerManagerHelper::Schedule::setEnabled(boolean enabled)
+{
+  _enabled = enabled;
+  return this;
+}
+
+// TaskScheduleManager part
+TaskSchedulerManager::TaskSchedulerManager() : _nextTaskIndexToBeRun(0), _rtcManager(NULL)
+{
+  
+}
+
+TaskSchedulerManager::TaskSchedulerManager(RtcManager &rtcManager) : _nextTaskIndexToBeRun(0), _rtcManager(&rtcManager)
+{
+  
+}
+
+boolean TaskSchedulerManager::addTask(const char *name, TaskSchedulerManagerHelper::Schedule *schedule, boolean (*taskRoutine)(void*), void *pData)
+{
+  return _taskDataDictio.add(name, new TaskData({*schedule, taskRoutine, pData}));
+}
+
+
+boolean TaskSchedulerManager::addTask(uint8_t id, TaskSchedulerManagerHelper::Schedule *schedule, boolean (*taskRoutine)(void*), void *pData)
+{
+  return _taskDataDictio.add(id, new TaskData({*schedule, taskRoutine, pData}));
+}
+
+boolean TaskSchedulerManager::removeTask(const char *name)
+{
+  return _taskDataDictio.remove(name);
+}
+
+boolean TaskSchedulerManager::removeTask(uint8_t id)
+{
+  return _taskDataDictio.remove(id);
+}
+
+boolean TaskSchedulerManager::enableTask(const char *name)
+{
+  _taskDataDictio(name)->schedule.setEnabled(true);
+}
+
+boolean TaskSchedulerManager::enableTask(uint8_t id)
+{
+  char indiceToStr[10];
+  sprintf(indiceToStr,"%d", id);
+  _taskDataDictio(indiceToStr)->schedule.setEnabled(true);
+}
+
+boolean TaskSchedulerManager::disableTask(const char *name)
+{
+  _taskDataDictio(name)->schedule.setEnabled(false);
+}
+
+boolean TaskSchedulerManager::disableTask(uint8_t id)
+{
+  char indiceToStr[10];
+  sprintf(indiceToStr,"%d", id);
+  _taskDataDictio(indiceToStr)->schedule.setEnabled(false);
+}
+
+boolean TaskSchedulerManager::clearTask()
+{
+  _taskDataDictio.clear();
+}
+
+void TaskSchedulerManager::runTaskScheduler()
+{
+  if(_taskDataDictio.count() == 0)return;
+
+  if(_taskDataDictio.count() >= _nextTaskIndexToBeRun)_nextTaskIndexToBeRun = 0;
+  
+  TaskData *p = _taskDataDictio(_nextTaskIndexToBeRun);
+  
+  if(p == NULL)//Shouldn't happen
+    return;
+
+  if(p->schedule._everyMillis != 0)
+  {
+    if(p->schedule._triggerRightAway || p->schedule._millis != 0)
+    {
+      if(millis() - p->schedule._millis >= p->schedule._everyMillis) //We execute the task
+      {
+        
+      }
+    }
+    else 
+    {
+      p->schedule._millis = millis();
+    }
+  }
+  else
+  {
+    
+  }
+  
+}

src/app/TaskSchedulerManager.h

@@ -2,14 +2,52 @@
 #define TASKSCHEDULERMANAGER_H
 #include <Arduino.h>
 #include "RtcManager.h"
+#include "Dictionary.h"
+
+//Forward declaration
+class TaskSchedulerManager;
 
 namespace TaskSchedulerManagerHelper
 {
   class Schedule
   {
+    friend class ::TaskSchedulerManager;
+    
     public:
+      enum DaysOfWeek {MONDAY = 1, TUESDAY = 2, WEDNESDAY = 4, THURSDAY = 8, FRIDAY = 16, SATURDAY = 32, SUNDAY = 64, EVERY_DAY = 127};
+      enum MonthsOfYear {JANUARY = 1, FEBRUARY = 2, MARCH = 4, APRIL = 8, MAY = 16, JUNE = 32, JULY = 64, AUGUST = 128, SEPTEMBER = 256, OCTOBER = 512, NOVEMBER = 1024, DECEMBER = 2048, EVERY_MONTH = 4095};
+      enum TriggerType {TRIGGER_REPEAT/*Default*/, TRIGGER_ONCE, TRIGGER_ONCE_AND_DELETE};
+      enum Mode {EVERY, AT}; //Indicates if it is every 10:30:00 or if it is AT 10:30:00
+      
+      ~Schedule()
+      {
+        delete _dateTime;
+      }
+      
+      static Schedule *scheduleBuilder();
+      Schedule *setMillis(uint64_t millis);
+      Schedule *setDateTime(DateTime &dateTime);
+      Schedule *setDays(uint8_t days);
+      Schedule *setMonths(uint16_t months);
+      Schedule *triggerRightAway(boolean enabled);
+      Schedule *triggerType(TriggerType triggerType);
+      Schedule *setMode(Mode mode);
+      Schedule *setEnabled(boolean enabled);
     protected:
+      Schedule();//By default, the schedule is the following : every second, every day, every month, trigger is repeated...
+      Schedule(const Schedule &Object);
     private:
+      uint8_t _days;
+      uint16_t _months;
+      boolean _triggered; //To know internally if it has been triggered
+      boolean _triggerRightAway; //Should it be triggered the first time ? only for the "every" mode
+      boolean _hasBeenTriggeredRightAway;
+      TriggerType _triggerType;
+      Mode _mode;
+      boolean _enabled;
+      uint64_t _millis;
+      uint64_t _everyMillis; //We can use millis or DateTime, but not both e.g every 00h 10m 00s 000ms
+      DateTime *_dateTime;
   };
 }
 
@@ -17,16 +55,34 @@ class TaskSchedulerManager
 {
   friend class SAB;
   public:
-    boolean addTask(const char *name, TaskSchedulerManagerHelper::Schedule schedule, boolean (*taskRoutine)(void*), void *pData = NULL);
+    ~TaskSchedulerManager()
-    boolean addTask(uint8_t id, TaskSchedulerManagerHelper::Schedule schedule, boolean (*taskRoutine)(void*), void *pData = NULL);
+    {
+      _taskDataDictio.dispose();
+    }
+    boolean addTask(const char *name, TaskSchedulerManagerHelper::Schedule *schedule, boolean (*taskRoutine)(void*), void *pData = NULL);
+    boolean addTask(uint8_t id, TaskSchedulerManagerHelper::Schedule *schedule, boolean (*taskRoutine)(void*), void *pData = NULL);
     boolean removeTask(const char *name);
     boolean removeTask(uint8_t id);
+    boolean enableTask(const char *name);
+    boolean enableTask(uint8_t id);
+    boolean disableTask(const char *name);
+    boolean disableTask(uint8_t id);
+    boolean clearTask();
     void runTaskScheduler();
   protected:
     TaskSchedulerManager();
     TaskSchedulerManager(RtcManager &rtcManager);
   private:
+    struct TaskData
+    {
+      TaskSchedulerManagerHelper::Schedule schedule;
+      boolean (*taskRoutine)(void*);
+      void *pData;
+    };
+
+    uint8_t _nextTaskIndexToBeRun;
     RtcManager *_rtcManager;
+    Dictionary<TaskData> _taskDataDictio;
 };
 
 #endif //TASKSCHEDULERMANAGER_H