refactor: follow orginal wallpapers/image implementation

* switch now happens after the sunrise/sunset transition

Author: luisbocanegra

package/contents/config/main.xml

@@ -172,5 +172,9 @@
     <entry name="AlternativePlaybackRate" type="Double">
       <default>0.5</default>
     </entry>
+    <entry name="DarkLightScheduleState" type="String">
+      <label>Saved dark light schedule state</label>
+      <default></default>
+    </entry>
   </group>
 </kcfg>

package/contents/ui/DayNightCycleController.qml

@@ -10,7 +10,6 @@ Item {
     required property int sunsetTime
 
     property var dayNightPlugin: null
-    property Item dayNightPluginDay: null
     property int currentTime
 
     property bool isDay: {
@@ -40,8 +39,6 @@ Item {
         return day;
     }
 
-    onIsDayChanged: console.log("isDayChanged", isDay)
-
     Timer {
         id: timer
         interval: 1000
@@ -60,6 +57,13 @@ Item {
         component = Qt.createComponent("NighttimeHelper.qml");
         if (component.status === Component.Ready) {
             dayNightPlugin = component.createObject(root);
+            dayNightPlugin.initialState = configuration.DarkLightScheduleState;
+            dayNightPlugin.stateChanged.connect(() => {
+                if (configuration.DarkLightScheduleState != dayNightPlugin.state) {
+                    configuration.DarkLightScheduleState = dayNightPlugin.state;
+                    configuration.writeConfig();
+                }
+            });
         } else {
             console.warn(component.errorString());
         }

package/contents/ui/NighttimeHelper.qml

@@ -3,6 +3,8 @@ import com.github.luisbocanegra.svwr.nighttime 1.0
 
 Item {
     property alias isDay: dayNight.isDay
+    property alias initialState: dayNight.initialState
+    property alias state: dayNight.state
     DayNight {
         id: dayNight
     }

plugin/nighttime.cpp

@@ -73,39 +73,96 @@ DayNight::DayNight(QObject *parent)
     : QObject(parent)
     , m_systemClockMonitor(new KSystemClockSkewNotifier(this))
     , m_rescheduleTimer(new QTimer(this))
+    , m_transitionUpdateTimer(new QTimer(this))
 {
-    provider = new KDarkLightScheduleProvider();
-    QObject::connect(provider, &KDarkLightScheduleProvider::scheduleChanged, this, &DayNight::schedule);
+    m_transitionUpdateTimer->setSingleShot(true);
+    connect(m_transitionUpdateTimer, &QTimer::timeout, this, &DayNight::update);
+
     m_systemClockMonitor->setActive(true);
     connect(m_systemClockMonitor, &KSystemClockSkewNotifier::skewed, this, &DayNight::schedule);
+
     m_rescheduleTimer->setSingleShot(true);
     connect(m_rescheduleTimer, &QTimer::timeout, this, &DayNight::schedule);
-    schedule();
 }
 
-DayNight::~DayNight() = default;
+void DayNight::classBegin()
+{
+}
 
-bool DayNight::isDay() const
+void DayNight::componentComplete()
 {
-    return m_isDay;
+    m_darkLightScheduleProvider = new KDarkLightScheduleProvider(m_initialState, this);
+    connect(m_darkLightScheduleProvider, &KDarkLightScheduleProvider::scheduleChanged, this, [this]() {
+        setState(m_darkLightScheduleProvider->state());
+        schedule();
+    });
 }
 
 void DayNight::schedule()
 {
-    qDebug() << "Updating day/night status...";
     const QDateTime now = QDateTime::currentDateTime();
-    const KDarkLightSchedule schedule = provider->schedule();
-    const KDarkLightTransition previousTransition = *schedule.previousTransition(now);
-    const KDarkLightTransition nextTransition = *schedule.nextTransition(now);
-    qDebug() << "Previous transition:" << previousTransition.type() << previousTransition.endDateTime();
-    qDebug() << "Next transition:" << nextTransition.type() << nextTransition.startDateTime();
-    const DayNightPhase phase = DayNightPhase::from(now, previousTransition, nextTransition);
-    qDebug() << "Current phase:" << int(phase);
-    const bool isDay = phase == DayNightPhase::Day || phase == DayNightPhase::Sunrise;
-    qDebug() << "Is it day?" << isDay;
+    const KDarkLightSchedule schedule = m_darkLightScheduleProvider->schedule();
+
+    m_previousTransition = *schedule.previousTransition(now);
+    m_nextTransition = *schedule.nextTransition(now);
+
+    m_rescheduleTimer->start(now.msecsTo(m_nextTransition.startDateTime()));
+    update();
+}
+
+void DayNight::update()
+{
+    const QDateTime now = QDateTime::currentDateTime();
+
+    DayNightPhase phase = DayNightPhase::from(now, m_previousTransition, m_nextTransition);
+
+    const bool isDay = phase == DayNightPhase::Day || phase == DayNightPhase::Sunset;
+
     if (m_isDay != isDay) {
         m_isDay = isDay;
         emit isDayChanged(isDay);
     }
-    m_rescheduleTimer->start(now.msecsTo(nextTransition.startDateTime()));
+
+    const int blendInterval = 60000;
+    switch (phase) {
+    case DayNightPhase::Night:
+    case DayNightPhase::Day:
+        m_transitionUpdateTimer->stop();
+        break;
+    case DayNightPhase::Sunrise:
+    case DayNightPhase::Sunset:
+        m_transitionUpdateTimer->start(blendInterval);
+        break;
+    }
+}
+
+void DayNight::setInitialState(const QString &state)
+{
+    if (m_initialState != state) {
+        m_initialState = state;
+        Q_EMIT initialStateChanged();
+    }
+}
+
+void DayNight::setState(const QString &state)
+{
+    if (m_state != state) {
+        m_state = state;
+        Q_EMIT stateChanged();
+    }
+}
+
+bool DayNight::isDay() const
+{
+    return m_isDay;
+}
+
+QString DayNight::initialState() const
+{
+    return m_initialState;
+}
+
+QString DayNight::state() const
+{
+    return m_state;
 }

plugin/nighttime.h

@@ -12,7 +12,9 @@
 #include <KDarkLightScheduleProvider>
 #include <KSystemClockSkewNotifier>
 #include <QObject>
+#include <QQmlParserStatus>
 #include <QTimer>
+#include <qqmlintegration.h>
 
 class DayNightPhase
 {
@@ -44,28 +46,49 @@ inline DayNightPhase::operator DayNightPhase::Kind() const
     return m_kind;
 }
 
-class DayNight : public QObject
+class DayNight : public QObject, public QQmlParserStatus
 {
     Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+    QML_ELEMENT
+
     Q_PROPERTY(bool isDay READ isDay NOTIFY isDayChanged)
+    Q_PROPERTY(QString initialState READ initialState WRITE setInitialState NOTIFY initialStateChanged)
+    Q_PROPERTY(QString state READ state NOTIFY stateChanged)
 
 public:
     explicit DayNight(QObject *parent = nullptr);
 
+    void classBegin() override;
+    void componentComplete() override;
+
     bool isDay() const;
 
-    ~DayNight() override;
+    QString initialState() const;
+    void setInitialState(const QString &state);
+
+    QString state() const;
+    void setState(const QString &state);
 
 signals:
 
     void isDayChanged(bool isDay);
+    void initialStateChanged();
+    void stateChanged();
 
 private:
     void schedule();
+    void update();
 
-    KDarkLightScheduleProvider *provider = nullptr;
+    KDarkLightScheduleProvider *m_darkLightScheduleProvider = nullptr;
     KSystemClockSkewNotifier *m_systemClockMonitor;
+    KDarkLightTransition m_previousTransition;
+    KDarkLightTransition m_nextTransition;
     QTimer *m_rescheduleTimer;
+    QTimer *m_transitionUpdateTimer;
+    QString m_initialState;
+    QString m_state;
+
     bool m_isDay = false;
 };