File indexing completed on 2024-06-09 05:26:03

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2017 Roman Gilg <subdiff@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "nightcolormanager.h"
 #include "clockskewnotifier.h"
 #include "colors/colordevice.h"
 #include "colors/colormanager.h"
 #include "nightcolordbusinterface.h"
 #include "nightcolorlogging.h"
 #include "nightcolorsettings.h"
 #include "suncalc.h"
 
 #include <core/outputbackend.h>
 #include <core/session.h>
 #include <input.h>
 #include <main.h>
 #include <workspace.h>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 
 #include <QAction>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingReply>
 #include <QDBusReply>
 #include <QTimer>
 
 namespace KWin
 {
 
 static const int QUICK_ADJUST_DURATION = 2000;
 static const int TEMPERATURE_STEP = 50;
 static NightColorManager *s_instance = nullptr;
 
 static bool checkLocation(double lat, double lng)
 {
     return -90 <= lat && lat <= 90 && -180 <= lng && lng <= 180;
 }
 
 NightColorManager *NightColorManager::self()
 {
     return s_instance;
 }
 
 NightColorManager::NightColorManager()
 {
     NightColorSettings::instance(kwinApp()->config());
     s_instance = this;
 
     m_iface = new NightColorDBusInterface(this);
     m_skewNotifier = new ClockSkewNotifier(this);
 
     // Display a message when Night Color is (un)inhibited.
     connect(this, &NightColorManager::inhibitedChanged, this, [this] {
         const QString iconName = isInhibited()
             ? QStringLiteral("redshift-status-off")
             : m_daylight && m_targetTemperature != DEFAULT_DAY_TEMPERATURE ? QStringLiteral("redshift-status-day")
                                                                            : QStringLiteral("redshift-status-on");
 
         const QString text = isInhibited()
             ? i18nc("Night Light was disabled", "Night Light Off")
             : i18nc("Night Light was enabled", "Night Light On");
 
         QDBusMessage message = QDBusMessage::createMethodCall(
             QStringLiteral("org.kde.plasmashell"),
             QStringLiteral("/org/kde/osdService"),
             QStringLiteral("org.kde.osdService"),
             QStringLiteral("showText"));
         message.setArguments({iconName, text});
 
         QDBusConnection::sessionBus().asyncCall(message);
     });
 
     m_configWatcher = KConfigWatcher::create(kwinApp()->config());
     connect(m_configWatcher.data(), &KConfigWatcher::configChanged, this, &NightColorManager::reconfigure);
 
     // we may always read in the current config
     readConfig();
 
     QAction *toggleAction = new QAction(this);
     toggleAction->setProperty("componentName", QStringLiteral("kwin"));
     toggleAction->setObjectName(QStringLiteral("Toggle Night Color"));
     toggleAction->setText(i18n("Toggle Night Light"));
     KGlobalAccel::setGlobalShortcut(toggleAction, QList<QKeySequence>());
     connect(toggleAction, &QAction::triggered, this, &NightColorManager::toggle);
 
     connect(kwinApp()->colorManager(), &ColorManager::deviceAdded, this, &NightColorManager::hardReset);
 
     connect(kwinApp()->session(), &Session::activeChanged, this, [this](bool active) {
         if (active) {
             hardReset();
         } else {
             cancelAllTimers();
         }
     });
 
     connect(m_skewNotifier, &ClockSkewNotifier::clockSkewed, this, [this]() {
         // check if we're resuming from suspend - in this case do a hard reset
         // Note: We're using the time clock to detect a suspend phase instead of connecting to the
         //       provided logind dbus signal, because this signal would be received way too late.
         QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.login1",
                                                               "/org/freedesktop/login1",
                                                               "org.freedesktop.DBus.Properties",
                                                               QStringLiteral("Get"));
         message.setArguments(QVariantList({"org.freedesktop.login1.Manager", QStringLiteral("PreparingForSleep")}));
         QDBusReply<QVariant> reply = QDBusConnection::systemBus().call(message);
         bool comingFromSuspend;
         if (reply.isValid()) {
             comingFromSuspend = reply.value().toBool();
         } else {
             qCDebug(KWIN_NIGHTCOLOR) << "Failed to get PreparingForSleep Property of logind session:" << reply.error().message();
             // Always do a hard reset in case we have no further information.
             comingFromSuspend = true;
         }
 
         if (comingFromSuspend) {
             hardReset();
         } else {
             resetAllTimers();
         }
     });
 
     hardReset();
 }
 
 NightColorManager::~NightColorManager()
 {
     s_instance = nullptr;
 }
 
 void NightColorManager::hardReset()
 {
     cancelAllTimers();
 
     updateTransitionTimings(true);
     updateTargetTemperature();
 
     if (isEnabled() && !isInhibited()) {
         setRunning(true);
         commitGammaRamps(currentTargetTemp());
     }
     resetAllTimers();
 }
 
 void NightColorManager::reconfigure()
 {
     cancelAllTimers();
     readConfig();
     resetAllTimers();
 }
 
 void NightColorManager::toggle()
 {
     m_isGloballyInhibited = !m_isGloballyInhibited;
     m_isGloballyInhibited ? inhibit() : uninhibit();
 }
 
 bool NightColorManager::isInhibited() const
 {
     return m_inhibitReferenceCount;
 }
 
 void NightColorManager::inhibit()
 {
     m_inhibitReferenceCount++;
 
     if (m_inhibitReferenceCount == 1) {
         resetAllTimers();
         Q_EMIT inhibitedChanged();
     }
 }
 
 void NightColorManager::uninhibit()
 {
     m_inhibitReferenceCount--;
 
     if (!m_inhibitReferenceCount) {
         resetAllTimers();
         Q_EMIT inhibitedChanged();
     }
 }
 
 bool NightColorManager::isEnabled() const
 {
     return m_active;
 }
 
 bool NightColorManager::isRunning() const
 {
     return m_running;
 }
 
 int NightColorManager::currentTemperature() const
 {
     return m_currentTemp;
 }
 
 int NightColorManager::targetTemperature() const
 {
     return m_targetTemperature;
 }
 
 NightColorMode NightColorManager::mode() const
 {
     return m_mode;
 }
 
 QDateTime NightColorManager::previousTransitionDateTime() const
 {
     return m_prev.first;
 }
 
 qint64 NightColorManager::previousTransitionDuration() const
 {
     return m_prev.first.msecsTo(m_prev.second);
 }
 
 QDateTime NightColorManager::scheduledTransitionDateTime() const
 {
     return m_next.first;
 }
 
 qint64 NightColorManager::scheduledTransitionDuration() const
 {
     return m_next.first.msecsTo(m_next.second);
 }
 
 void NightColorManager::readConfig()
 {
     NightColorSettings *s = NightColorSettings::self();
     s->load();
 
     setEnabled(s->active());
 
     const NightColorMode mode = s->mode();
     switch (s->mode()) {
     case NightColorMode::Automatic:
     case NightColorMode::Location:
     case NightColorMode::Timings:
     case NightColorMode::Constant:
         setMode(mode);
         break;
     default:
         // Fallback for invalid setting values.
         setMode(NightColorMode::Automatic);
         break;
     }
 
     m_dayTargetTemp = std::clamp(s->dayTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE);
     m_nightTargetTemp = std::clamp(s->nightTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE);
 
     double lat, lng;
     auto correctReadin = [&lat, &lng]() {
         if (!checkLocation(lat, lng)) {
             // out of domain
             lat = 0;
             lng = 0;
         }
     };
     // automatic
     lat = s->latitudeAuto();
     lng = s->longitudeAuto();
     correctReadin();
     m_latAuto = lat;
     m_lngAuto = lng;
     // fixed location
     lat = s->latitudeFixed();
     lng = s->longitudeFixed();
     correctReadin();
     m_latFixed = lat;
     m_lngFixed = lng;
 
     // fixed timings
     QTime mrB = QTime::fromString(s->morningBeginFixed(), "hhmm");
     QTime evB = QTime::fromString(s->eveningBeginFixed(), "hhmm");
 
     int diffME = evB > mrB ? mrB.msecsTo(evB) : evB.msecsTo(mrB);
     int diffMin = std::min(diffME, MSC_DAY - diffME);
 
     int trTime = s->transitionTime() * 1000 * 60;
     if (trTime < 0 || diffMin <= trTime) {
         // transition time too long - use defaults
         mrB = QTime(6, 0);
         evB = QTime(18, 0);
         trTime = FALLBACK_SLOW_UPDATE_TIME;
     }
     m_morning = mrB;
     m_evening = evB;
     m_trTime = std::max(trTime / 1000 / 60, 1);
 }
 
 void NightColorManager::resetAllTimers()
 {
     cancelAllTimers();
     setRunning(isEnabled() && !isInhibited());
     // we do this also for active being false in order to reset the temperature back to the day value
     updateTransitionTimings(false);
     updateTargetTemperature();
     resetQuickAdjustTimer(currentTargetTemp());
 }
 
 void NightColorManager::cancelAllTimers()
 {
     m_slowUpdateStartTimer.reset();
     m_slowUpdateTimer.reset();
     m_quickAdjustTimer.reset();
 }
 
 void NightColorManager::resetQuickAdjustTimer(int targetTemp)
 {
     int tempDiff = std::abs(targetTemp - m_currentTemp);
     // allow tolerance of one TEMPERATURE_STEP to compensate if a slow update is coincidental
     if (tempDiff > TEMPERATURE_STEP) {
         cancelAllTimers();
         m_quickAdjustTimer = std::make_unique<QTimer>();
         m_quickAdjustTimer->setSingleShot(false);
         connect(m_quickAdjustTimer.get(), &QTimer::timeout, this, [this, targetTemp]() {
             quickAdjust(targetTemp);
         });
 
         int interval = (QUICK_ADJUST_DURATION / (m_previewTimer && m_previewTimer->isActive() ? 8 : 1)) / (tempDiff / TEMPERATURE_STEP);
         if (interval == 0) {
             interval = 1;
         }
         m_quickAdjustTimer->start(interval);
     } else {
         resetSlowUpdateStartTimer();
     }
 }
 
 void NightColorManager::quickAdjust(int targetTemp)
 {
     if (!m_quickAdjustTimer) {
         return;
     }
 
     int nextTemp;
 
     if (m_currentTemp < targetTemp) {
         nextTemp = std::min(m_currentTemp + TEMPERATURE_STEP, targetTemp);
     } else {
         nextTemp = std::max(m_currentTemp - TEMPERATURE_STEP, targetTemp);
     }
     commitGammaRamps(nextTemp);
 
     if (nextTemp == targetTemp) {
         // stop timer, we reached the target temp
         m_quickAdjustTimer.reset();
         resetSlowUpdateStartTimer();
     }
 }
 
 void NightColorManager::resetSlowUpdateStartTimer()
 {
     m_slowUpdateStartTimer.reset();
 
     if (!m_running || m_quickAdjustTimer) {
         // only reenable the slow update start timer when quick adjust is not active anymore
         return;
     }
 
     // There is no need for starting the slow update timer. Screen color temperature
     // will be constant all the time now.
     if (m_mode == NightColorMode::Constant) {
         return;
     }
 
     // set up the next slow update
     m_slowUpdateStartTimer = std::make_unique<QTimer>();
     m_slowUpdateStartTimer->setSingleShot(true);
     connect(m_slowUpdateStartTimer.get(), &QTimer::timeout, this, &NightColorManager::resetSlowUpdateStartTimer);
 
     updateTransitionTimings(false);
     updateTargetTemperature();
 
     const int diff = QDateTime::currentDateTime().msecsTo(m_next.first);
     if (diff <= 0) {
         qCCritical(KWIN_NIGHTCOLOR) << "Error in time calculation. Deactivating Night Color.";
         return;
     }
     m_slowUpdateStartTimer->start(diff);
 
     // start the current slow update
     resetSlowUpdateTimer();
 }
 
 void NightColorManager::resetSlowUpdateTimer()
 {
     m_slowUpdateTimer.reset();
 
     const QDateTime now = QDateTime::currentDateTime();
     const bool isDay = daylight();
     const int targetTemp = isDay ? m_dayTargetTemp : m_nightTargetTemp;
 
     // We've reached the target color temperature or the transition time is zero.
     if (m_prev.first == m_prev.second || m_currentTemp == targetTemp) {
         commitGammaRamps(targetTemp);
         return;
     }
 
     if (m_prev.first <= now && now <= m_prev.second) {
         int availTime = now.msecsTo(m_prev.second);
         m_slowUpdateTimer = std::make_unique<QTimer>();
         m_slowUpdateTimer->setSingleShot(false);
         if (isDay) {
             connect(m_slowUpdateTimer.get(), &QTimer::timeout, this, [this]() {
                 slowUpdate(m_dayTargetTemp);
             });
         } else {
             connect(m_slowUpdateTimer.get(), &QTimer::timeout, this, [this]() {
                 slowUpdate(m_nightTargetTemp);
             });
         }
 
         // calculate interval such as temperature is changed by TEMPERATURE_STEP K per timer timeout
         int interval = availTime * TEMPERATURE_STEP / std::abs(targetTemp - m_currentTemp);
         if (interval == 0) {
             interval = 1;
         }
         m_slowUpdateTimer->start(interval);
     }
 }
 
 void NightColorManager::slowUpdate(int targetTemp)
 {
     if (!m_slowUpdateTimer) {
         return;
     }
     int nextTemp;
     if (m_currentTemp < targetTemp) {
         nextTemp = std::min(m_currentTemp + TEMPERATURE_STEP, targetTemp);
     } else {
         nextTemp = std::max(m_currentTemp - TEMPERATURE_STEP, targetTemp);
     }
     commitGammaRamps(nextTemp);
     if (nextTemp == targetTemp) {
         // stop timer, we reached the target temp
         m_slowUpdateTimer.reset();
     }
 }
 
 void NightColorManager::preview(uint previewTemp)
 {
     previewTemp = std::clamp<uint>(previewTemp, MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE);
     resetQuickAdjustTimer((int)previewTemp);
     if (m_previewTimer) {
         m_previewTimer.reset();
     }
     m_previewTimer = std::make_unique<QTimer>();
     m_previewTimer->setSingleShot(true);
     connect(m_previewTimer.get(), &QTimer::timeout, this, &NightColorManager::stopPreview);
     m_previewTimer->start(15000);
 
     QDBusMessage message = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.plasmashell"),
         QStringLiteral("/org/kde/osdService"),
         QStringLiteral("org.kde.osdService"),
         QStringLiteral("showText"));
     message.setArguments(
         {QStringLiteral("redshift-status-on"),
          i18n("Color Temperature Preview")});
     QDBusConnection::sessionBus().asyncCall(message);
 }
 
 void NightColorManager::stopPreview()
 {
     if (m_previewTimer && m_previewTimer->isActive()) {
         updateTransitionTimings(false);
         updateTargetTemperature();
         resetQuickAdjustTimer(currentTargetTemp());
     }
 }
 
 void NightColorManager::updateTargetTemperature()
 {
     const int targetTemperature = mode() != NightColorMode::Constant && daylight() ? m_dayTargetTemp : m_nightTargetTemp;
 
     if (m_targetTemperature == targetTemperature) {
         return;
     }
 
     m_targetTemperature = targetTemperature;
 
     Q_EMIT targetTemperatureChanged();
 }
 
 void NightColorManager::updateTransitionTimings(bool force)
 {
     const auto oldPrev = m_prev;
     const auto oldNext = m_next;
 
     if (m_mode == NightColorMode::Constant) {
         setDaylight(false);
         m_next = DateTimes();
         m_prev = DateTimes();
     } else if (m_mode == NightColorMode::Timings) {
         const QDateTime todayNow = QDateTime::currentDateTime();
 
         const QDateTime nextMorB = QDateTime(todayNow.date().addDays(m_morning < todayNow.time()), m_morning);
         const QDateTime nextMorE = nextMorB.addSecs(m_trTime * 60);
         const QDateTime nextEveB = QDateTime(todayNow.date().addDays(m_evening < todayNow.time()), m_evening);
         const QDateTime nextEveE = nextEveB.addSecs(m_trTime * 60);
 
         if (nextEveB < nextMorB) {
             setDaylight(true);
             m_next = DateTimes(nextEveB, nextEveE);
             m_prev = DateTimes(nextMorB.addDays(-1), nextMorE.addDays(-1));
         } else {
             setDaylight(false);
             m_next = DateTimes(nextMorB, nextMorE);
             m_prev = DateTimes(nextEveB.addDays(-1), nextEveE.addDays(-1));
         }
     } else {
         const QDateTime todayNow = QDateTime::currentDateTime();
 
         double lat, lng;
         if (m_mode == NightColorMode::Automatic) {
             lat = m_latAuto;
             lng = m_lngAuto;
         } else {
             lat = m_latFixed;
             lng = m_lngFixed;
         }
 
         if (!force) {
             // first try by only switching the timings
             if (m_prev.first.date() == m_next.first.date()) {
                 // next is evening
                 setDaylight(true);
                 m_prev = m_next;
                 m_next = getSunTimings(todayNow, lat, lng, false);
             } else {
                 // next is morning
                 setDaylight(false);
                 m_prev = m_next;
                 m_next = getSunTimings(todayNow.addDays(1), lat, lng, true);
             }
         }
 
         if (force || !checkAutomaticSunTimings()) {
             // in case this fails, reset them
             DateTimes morning = getSunTimings(todayNow, lat, lng, true);
             if (todayNow < morning.first) {
                 setDaylight(false);
                 m_prev = getSunTimings(todayNow.addDays(-1), lat, lng, false);
                 m_next = morning;
             } else {
                 DateTimes evening = getSunTimings(todayNow, lat, lng, false);
                 if (todayNow < evening.first) {
                     setDaylight(true);
                     m_prev = morning;
                     m_next = evening;
                 } else {
                     setDaylight(false);
                     m_prev = evening;
                     m_next = getSunTimings(todayNow.addDays(1), lat, lng, true);
                 }
             }
         }
     }
 
     if (oldPrev != m_prev) {
         Q_EMIT previousTransitionTimingsChanged();
     }
     if (oldNext != m_next) {
         Q_EMIT scheduledTransitionTimingsChanged();
     }
 }
 
 DateTimes NightColorManager::getSunTimings(const QDateTime &dateTime, double latitude, double longitude, bool morning) const
 {
     DateTimes dateTimes = calculateSunTimings(dateTime, latitude, longitude, morning);
     // At locations near the poles it is possible, that we can't
     // calculate some or all sun timings (midnight sun).
     // In this case try to fallback to sensible default values.
     const bool beginDefined = !dateTimes.first.isNull();
     const bool endDefined = !dateTimes.second.isNull();
     if (!beginDefined || !endDefined) {
         if (beginDefined) {
             dateTimes.second = dateTimes.first.addMSecs(FALLBACK_SLOW_UPDATE_TIME);
         } else if (endDefined) {
             dateTimes.first = dateTimes.second.addMSecs(-FALLBACK_SLOW_UPDATE_TIME);
         } else {
             // Just use default values for morning and evening, but the user
             // will probably deactivate Night Color anyway if he is living
             // in a region without clear sun rise and set.
             const QTime referenceTime = morning ? QTime(6, 0) : QTime(18, 0);
             dateTimes.first = QDateTime(dateTime.date(), referenceTime);
             dateTimes.second = dateTimes.first.addMSecs(FALLBACK_SLOW_UPDATE_TIME);
         }
     }
     return dateTimes;
 }
 
 bool NightColorManager::checkAutomaticSunTimings() const
 {
     if (m_prev.first.isValid() && m_prev.second.isValid() && m_next.first.isValid() && m_next.second.isValid()) {
         const QDateTime todayNow = QDateTime::currentDateTime();
         return m_prev.first <= todayNow && todayNow < m_next.first && m_prev.first.msecsTo(m_next.first) < MSC_DAY * 23. / 24;
     }
     return false;
 }
 
 bool NightColorManager::daylight() const
 {
     return m_daylight;
 }
 
 int NightColorManager::currentTargetTemp() const
 {
     if (!m_running) {
         return DEFAULT_DAY_TEMPERATURE;
     }
 
     if (m_mode == NightColorMode::Constant) {
         return m_nightTargetTemp;
     }
 
     const QDateTime todayNow = QDateTime::currentDateTime();
 
     auto f = [this, todayNow](int target1, int target2) {
         if (todayNow <= m_prev.second) {
             double residueQuota = todayNow.msecsTo(m_prev.second) / (double)m_prev.first.msecsTo(m_prev.second);
 
             double ret = (int)((1. - residueQuota) * (double)target2 + residueQuota * (double)target1);
             // remove single digits
             ret = ((int)(0.1 * ret)) * 10;
             return (int)ret;
         } else {
             return target2;
         }
     };
 
     if (daylight()) {
         return f(m_nightTargetTemp, m_dayTargetTemp);
     } else {
         return f(m_dayTargetTemp, m_nightTargetTemp);
     }
 }
 
 void NightColorManager::commitGammaRamps(int temperature)
 {
     const QList<ColorDevice *> devices = kwinApp()->colorManager()->devices();
     for (ColorDevice *device : devices) {
         device->setTemperature(temperature);
     }
 
     setCurrentTemperature(temperature);
 }
 
 void NightColorManager::autoLocationUpdate(double latitude, double longitude)
 {
     qCDebug(KWIN_NIGHTCOLOR, "Received new location (lat: %f, lng: %f)", latitude, longitude);
 
     if (!checkLocation(latitude, longitude)) {
         return;
     }
 
     // we tolerate small deviations with minimal impact on sun timings
     if (std::abs(m_latAuto - latitude) < 2 && std::abs(m_lngAuto - longitude) < 1) {
         return;
     }
     cancelAllTimers();
     m_latAuto = latitude;
     m_lngAuto = longitude;
 
     NightColorSettings *s = NightColorSettings::self();
     s->setLatitudeAuto(latitude);
     s->setLongitudeAuto(longitude);
     s->save();
 
     resetAllTimers();
 }
 
 void NightColorManager::setEnabled(bool enabled)
 {
     if (m_active == enabled) {
         return;
     }
     m_active = enabled;
     m_skewNotifier->setActive(enabled);
     Q_EMIT enabledChanged();
 }
 
 void NightColorManager::setRunning(bool running)
 {
     if (m_running == running) {
         return;
     }
     m_running = running;
     Q_EMIT runningChanged();
 }
 
 void NightColorManager::setCurrentTemperature(int temperature)
 {
     if (m_currentTemp == temperature) {
         return;
     }
     m_currentTemp = temperature;
     Q_EMIT currentTemperatureChanged();
 }
 
 void NightColorManager::setMode(NightColorMode mode)
 {
     if (m_mode == mode) {
         return;
     }
     m_mode = mode;
     Q_EMIT modeChanged();
 }
 
 void NightColorManager::setDaylight(bool daylight)
 {
     if (m_daylight == daylight) {
         return;
     }
     m_daylight = daylight;
     Q_EMIT daylightChanged();
 }
 
 } // namespace KWin
 
 #include "moc_nightcolormanager.cpp"