Absolute time scheduling logic updated

Author: HaseenaSainul

Launcher.cpp

@@ -1,7 +1,16 @@
 #include "Launcher.h"
+#include <inttypes.h>
 
 namespace WPEFramework {
 
+ENUM_CONVERSION_BEGIN(Plugin::Launcher::mode)
+
+    { Plugin::Launcher::mode::RELATIVE, _TXT("relative") },
+    { Plugin::Launcher::mode::ABSOLUTE, _TXT("absolute") },
+    { Plugin::Launcher::mode::ABSOLUTE_WITH_INTERVAL, _TXT("absolute_with_interval") },
+
+    ENUM_CONVERSION_END(Plugin::Launcher::mode)
+;
 namespace Plugin {
 
 SERVICE_REGISTRATION(Launcher, 1, 0);
@@ -70,7 +79,7 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 {
     Time time;
     Time interval;
-    bool absolute = false;
+    mode timeMode = RELATIVE;
     string message;
     Config config;
 
@@ -84,7 +93,7 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
     if (config.ScheduleTime.IsSet() == true) {
 
-        absolute = config.ScheduleTime.Absolute.Value();
+        timeMode = config.ScheduleTime.Mode.Value();
 
         time = Time(config.ScheduleTime.Time.Value());
         if (time.IsValid() != true) {
@@ -102,20 +111,26 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
         if (_activity->IsOperational() == false) {
             // Well if we where able to parse the parameters (if needed) we are ready to start it..
             _observer.Register(&_notification);
+            Core::Time scheduledTime;
             if (time.IsValid() == true) {
-                if (absolute == true) {
-                    //Schedule Job at absolute timing
-                    Core::Time scheduledTime = FindAbsoluteTimeForSchedule(time, interval);
-                    PluginHost::WorkerPool::Instance().Schedule(scheduledTime, _activity);
-                }
-                else { //Schedule Job at relative timing
-                    Core::Time scheduledTime(Core::Time::Now();
-                    uint64_t timeValueToTrigger = ((((time.Hour() != (uint8_t)(~0)) ? time.Hour(): 0) * MinutesPerHour +
-                                                    ((time.Minute() != (uint8_t)(~0)) ? time.Minute(): 0)) * SecondsPerMinute + time.Second()) * MilliSecondsPerSecond;
+                if (timeMode == RELATIVE) { //Schedule Job at relative timing
+                    scheduledTime = Core::Time::Now();
+
+                    uint64_t timeValueToTrigger = ((((time.Hours() != (uint8_t)(~0)) ? time.Hours(): 0) * MinutesPerHour +
+                                                    ((time.Minutes() != (uint8_t)(~0)) ? time.Minutes(): 0)) * SecondsPerMinute + time.Seconds()) * MilliSecondsPerSecond;
                     scheduledTime.Add(timeValueToTrigger);
 
-                    PluginHost::WorkerPool::Instance().Schedule(scheduledTime, _activity);
                 }
+                else {
+                    //Schedule Job at absolute timing
+                    if (timeMode == ABSOLUTE_WITH_INTERVAL) {
+                        scheduledTime = FindAbsoluteTimeForSchedule(time, interval);
+                    }
+                    else {
+                        scheduledTime = FindAbsoluteTimeForSchedule(time, Time());
+                    }
+                }
+                PluginHost::WorkerPool::Instance().Schedule(scheduledTime, _activity);
             }
             else {
                 PluginHost::WorkerPool::Instance().Submit(_activity);
@@ -189,63 +204,40 @@ void Launcher::Update(const ProcessObserver::Info& info)
     }
 }
 
-Core::Time Launcher::FindAbsoluteTimeForSchedule(const Time absoluteTime, const Time interval) {
+Core::Time Launcher::FindAbsoluteTimeForSchedule(const Time& absoluteTime, const Time& interval) {
+    Core::Time startTime = Core::Time::Now();
+    // Go to a first viable start time (compared to the current time, in seconds)
+    Core::Time slotTime = Core::Time(startTime.Year(), startTime.Month(), startTime.Day(),
+                                   (absoluteTime.HasHours()   ? absoluteTime.Hours() : startTime.Hours()),
+                                   (absoluteTime.HasMinutes() ? absoluteTime.Minutes() : startTime.Minutes()),
+                                   absoluteTime.Seconds(), 0, false);
 
-    Core::Time scheduledTime;
-    Core::Time currentTime(Core::Time::Now());
-
-    uint64_t absoluteTimeInMilliSeconds = 0;
-    uint64_t currentTimeInMilliSeconds = 0;
-
-    if (!absoluteTime.HasHours()) { //Hour is don't care condition, so schedule based on the MM.SS
-        uint64_t nextScheduleTimeInMilliSeconds = 0;
-        uint64_t timeLimitInMilliSeconds = 0;
-        if (!absoluteTime.HasMinutes()) { //Minute is don't care condition, so schedule based on the SS
-            absoluteTimeInMilliSeconds = (absoluteTime.Second() * MilliSecondsPerSecond);
-            currentTimeInMilliSeconds =  (currentTime.Seconds() * MilliSecondsPerSecond);
-            timeLimitInMilliSeconds = (SecondsPerMinute * MilliSecondsPerSecond);
-        }
-        else {
-            absoluteTimeInMilliSeconds = ((absoluteTime.Minute() * SecondsPerMinute) + absoluteTime.Second()) * MilliSecondsPerSecond;
-            currentTimeInMilliSeconds = ((currentTime.Minutes() * SecondsPerMinute) + currentTime.Seconds()) * MilliSecondsPerSecond;
-            timeLimitInMilliSeconds = MinutesPerHour * SecondsPerMinute * MilliSecondsPerSecond;
-        }
-        if (currentTimeInMilliSeconds < absoluteTimeInMilliSeconds) { //Time is not reached
-            nextScheduleTimeInMilliSeconds = absoluteTimeInMilliSeconds - currentTimeInMilliSeconds;
-        }
-        else {
-            nextScheduleTimeInMilliSeconds = (timeLimitInMilliSeconds - currentTimeInMilliSeconds) + absoluteTimeInMilliSeconds;
+    if (interval.IsValid() == false) {
+        if (slotTime < startTime) {
+            uint32_t jump (absoluteTime.HasHours() ? HoursPerDay * MinutesPerHour * SecondsPerMinute : (absoluteTime.HasMinutes() ? MinutesPerHour * SecondsPerMinute : SecondsPerMinute));
+            slotTime.Add(jump * 100);
         }
-        scheduledTime = currentTime.Add(nextScheduleTimeInMilliSeconds);
     }
     else {
-        absoluteTimeInMilliSeconds = ((absoluteTime.Hour() * MinutesPerHour + absoluteTime.Minute()) * SecondsPerMinute + absoluteTime.Second()) * MilliSecondsPerSecond;
-        currentTimeInMilliSeconds = ((currentTime.Hours() * MinutesPerHour + currentTime.Minutes()) * SecondsPerMinute + currentTime.Seconds()) * MilliSecondsPerSecond;
-        if (currentTimeInMilliSeconds < absoluteTimeInMilliSeconds) { //Time is not reached
-            scheduledTime = currentTime.Add(absoluteTimeInMilliSeconds - currentTimeInMilliSeconds);
-        }
-        else { //Time is already hit, find next suitable time
-            uint64_t nextScheduleTimeInMilliSeconds = 0;
-            if (interval.IsValid() == true) {
-                uint64_t intervalTimeInMilliSeconds = ((((interval.Hour() != ~0) ? interval.Hour(): 0) * MinutesPerHour +
-                                                        ((interval.Minute() != ~0) ? interval.Minute(): 0)) * SecondsPerMinute + interval.Second()) * MilliSecondsPerSecond;
-                nextScheduleTimeInMilliSeconds = absoluteTimeInMilliSeconds + intervalTimeInMilliSeconds;
-                do {
-                    if (currentTimeInMilliSeconds < nextScheduleTimeInMilliSeconds) {
-                        break;
-                    }
-                    nextScheduleTimeInMilliSeconds += intervalTimeInMilliSeconds;
-                } while(1);
-                scheduledTime = currentTime.Add(nextScheduleTimeInMilliSeconds - currentTimeInMilliSeconds);
-            }
-            else {
-                uint64_t timeLimitInMilliSeconds = (((HoursPerDay * MinutesPerHour) * SecondsPerMinute) * MilliSecondsPerSecond);
-                nextScheduleTimeInMilliSeconds = (timeLimitInMilliSeconds - currentTimeInMilliSeconds) + absoluteTimeInMilliSeconds;
-                scheduledTime = currentTime.Add(nextScheduleTimeInMilliSeconds);
-            }
+        if (slotTime >= startTime) {
+            uint32_t jump (absoluteTime.HasHours() ? HoursPerDay * MinutesPerHour * SecondsPerMinute : (absoluteTime.HasMinutes() ? MinutesPerHour * SecondsPerMinute : SecondsPerMinute));
+
+            // Go back the biggest chunk of the absoluteTime
+            slotTime.Sub(jump * 100);
+        }
+        uint32_t intervalJump = ( (interval.HasHours()   ? interval.Hours() * MinutesPerHour * SecondsPerMinute : 0) +
+                                  (interval.HasMinutes() ? interval.Minutes() * SecondsPerMinute : 0) +
+                                   interval.Seconds() ) * 100;
+
+        ASSERT (intervalJump != 0);
+
+        // Now increment with the intervall till we reach a valid point
+        while (slotTime < startTime) {
+            slotTime.Add(intervalJump);
         }
     }
-    return scheduledTime;
+
+    return slotTime;
 }
 
 } //namespace Plugin

Launcher.h

@@ -12,6 +12,13 @@ class Launcher : public PluginHost::IPlugin {
     Launcher(const Launcher&) = delete;
     Launcher& operator=(const Launcher&) = delete;
 
+public:
+    enum mode {
+        RELATIVE,
+        ABSOLUTE,
+        ABSOLUTE_WITH_INTERVAL
+    };
+
     class ProcessObserver {
     private:
         ProcessObserver(const ProcessObserver&) = delete;
@@ -300,26 +307,26 @@ class Launcher : public PluginHost::IPlugin {
         public:
             Schedule()
                 : Core::JSON::Container()
-                , Absolute(false)
+                , Mode(RELATIVE)
                 , Time()
                 , Interval() {
-                Add(_T("absolute"), &Absolute);
+                Add(_T("mode"), &Mode);
                 Add(_T("time"), &Time);
                 Add(_T("interval"), &Interval);
             }
             Schedule(const Schedule& copy)
                 : Core::JSON::Container()
-                , Absolute(copy.Absolute)
+                , Mode(copy.Mode)
                 , Time(copy.Time)
                 , Interval(copy.Interval) {
-                Add(_T("absolute"), &Absolute);
+                Add(_T("mode"), &Mode);
                 Add(_T("time"), &Time);
                 Add(_T("interval"), &Interval);
             }
             ~Schedule() {
             }
         public:
-            Core::JSON::Boolean Absolute;
+            Core::JSON::EnumType<mode> Mode;
             Core::JSON::String Time;
             Core::JSON::String Interval;
         };
@@ -348,7 +355,7 @@ class Launcher : public PluginHost::IPlugin {
         Schedule ScheduleTime;
     };
 
-private:
+    private:
     static constexpr uint32_t MilliSecondsPerSecond = 1000;
     static constexpr uint32_t SecondsPerMinute = 60;
     static constexpr uint32_t MinutesPerHour = 60;
@@ -384,9 +391,9 @@ class Launcher : public PluginHost::IPlugin {
         bool HasHours() const { return (_hour < HoursPerDay); }
         bool HasMinutes() const { return (_minute < MinutesPerHour); }
         bool HasSeconds() const { return (_second < SecondsPerMinute); }
-        uint8_t Hour() const { return _hour; }
-        uint8_t Minute() const { return _minute; }
-        uint8_t Second() const { return _second; }
+        uint8_t Hours() const { return _hour; }
+        uint8_t Minutes() const { return _minute; }
+        uint8_t Seconds() const { return _second; }
 
     private:
         bool Parse(const string& time) {
@@ -522,14 +529,16 @@ class Launcher : public PluginHost::IPlugin {
             _hasRun = true;
              // Check if the process is not active, no need to reschedule the same job again.
             if (_process.IsActive() == false) {
+
+                Core::Time currentTime(Core::Time::Now());
                 _process.Launch(_options, &_pid);
             }
 
             if (_interval.IsValid() == true) {
                 // Reschedule our next launch point...
                 Core::Time scheduledTime(Core::Time::Now());
-                uint64_t intervalTime = ((((_interval.Hour() != (uint8_t)(~0)) ? _interval.Hour(): 0) * MinutesPerHour +
-                                          ((_interval.Minute() != (uint8_t)(~0)) ? _interval.Minute():0)) * SecondsPerMinute + _interval.Second()) * MilliSecondsPerSecond;
+                uint64_t intervalTime = ((((_interval.Hours() != (uint8_t)(~0)) ? _interval.Hours(): 0) * MinutesPerHour +
+                                          ((_interval.Minutes() != (uint8_t)(~0)) ? _interval.Minutes():0)) * SecondsPerMinute + _interval.Seconds()) * MilliSecondsPerSecond;
                 scheduledTime.Add(intervalTime);
                 PluginHost::WorkerPool::Instance().Schedule(scheduledTime,Core::ProxyType<Core::IDispatch>(*this));
             }
@@ -595,7 +604,7 @@ class Launcher : public PluginHost::IPlugin {
 private:
     void Update(const ProcessObserver::Info& info);
     bool Execute();
-    Core::Time FindAbsoluteTimeForSchedule(const Time absoluteTime, const Time interval);
+    Core::Time FindAbsoluteTimeForSchedule(const Time& absoluteTime, const Time& interval);
 
 private:
     PluginHost::IShell* _service;

README.md

@@ -69,14 +69,14 @@ Plugin to "Launch" linux applications and scripts
        { "option": "-h"}
       ],
      "schedule": {
-       "absolute": false,
+       "mode": 0,
        "time": "06:04.10"
      }
    }
    ```
 
 Note:
-1. If field "absolute" is false or not set, it will treat the time as relative
+1. If field "mode" is zero or not set, it will treat the time as relative
 2. If relative time value is "00:00.00"/invalid format/not set, the launcher will ignore the given time and launch the application at the launcher activation time itself.
 3. If time format given is
   a. "XX", treat it as SS
@@ -93,7 +93,7 @@ Note:
        { "option": "-h"}
       ],
      "schedule": {
-       "absolute": true,
+       "mode": 1,
        "time": "06:04.10"
      }
    }
@@ -121,7 +121,7 @@ Note:
        { "option": "-h"}
       ],
       "schedule": {
-        "absolute": false,
+        "mode": 2,
         "time": "06:04.10",
         "interval": "00:40.10"
       }
@@ -130,8 +130,9 @@ Note:
 
 Note:
 1. If interval value is "00:00.00"/invalid format/not set, the launcher will treat it as invalid value and ignore the interval time settings.
-2. If absolute time given is less than the current time and interval is set, it will identify next matching time and schedule application launch to that time.
+2. If mode is 2 (absolute with interval) and interval is set, it will identify next matching time and schedule application launch to that time.
    i.e, if the absolute time given is 04:00:00, current time is 05:10:00 and interval is 00:30:00, then next scheduling time will be 05:30:00 (will be identified from the next intervals - 04:30:00, 05:00:00, 05:30:00)
+3. If mode is 0(relative) or 1(absolute), the interval time will be taken only for the subsequent scheduling
 
 # How to launch multiple scripts/applcations