Pause sync when on a metered Internet connection

Add an advanced configuration setting to pause synchronization when a
metered internet connection is detected.

Fixes: #4808

src/gui/accountsettings.cpp

@@ -814,6 +814,9 @@ void AccountSettings::slotAccountStateChanged()
     case AccountState::Disconnected:
         showConnectionLabel(tr("Disconnected from: %1.").arg(server));
         break;
+    case AccountState::PausedDueToMetered:
+        showConnectionLabel(tr("Sync to %1 is paused due to metered internet connection.").arg(server));
+        break;
     }
 
     // Disabling expansion of folders might require hiding the selective

src/gui/accountstate.cpp

@@ -136,6 +136,18 @@ AccountState::AccountState(AccountPtr account)
                 break;
             }
         });
+
+        connect(qNetInfo, &QNetworkInformation::isMeteredChanged, this, [this](bool isMetered) {
+            if (ConfigFile().pauseSyncWhenMetered()) {
+                if (state() == State::Connected && isMetered) {
+                    qCInfo(lcAccountState) << "Network switched to a metered connection, setting account state to PausedDueToMetered";
+                    setState(State::PausedDueToMetered);
+                } else if (state() == State::PausedDueToMetered && !isMetered) {
+                    qCInfo(lcAccountState) << "Network switched to a NON-metered connection, setting account state to Connected";
+                    setState(State::Connected);
+                }
+            }
+        });
     }
 #endif
     // as a fallback and to recover after server issues we also poll

src/gui/accountstate.h

@@ -78,6 +78,11 @@ class AccountState : public QObject
         /// We are currently asking the user for credentials
         AskingCredentials,
 
+        /// We are on a metered internet connection, and the user preference
+        /// is to pause syncing in this case. This state is entered from and
+        /// left to a `Connected` state.
+        PausedDueToMetered,
+
         Connecting
     };
     Q_ENUM(State)

src/gui/folder.h

@@ -275,6 +275,9 @@ class Folder : public QObject
     {
         return *_engine;
     }
+
+    void abort(const QString &reason);
+
     Vfs &vfs()
     {
         OC_ENFORCE(_vfs);
@@ -363,7 +366,7 @@ public slots:
     /**
        * terminate the current sync run
        */
-    void slotTerminateSync();
+    void slotTerminateSync(const QString &reason);
 
     // connected to the corresponding signals in the SyncEngine
     void slotAboutToRemoveAllFiles(SyncFileItem::Direction);

src/gui/networksettings.cpp

@@ -22,6 +22,7 @@
 #include "theme.h"
 
 #include <QList>
+#include <QNetworkInformation>
 #include <QNetworkProxy>
 #include <QString>
 #include <QtGui/QtEvents>
@@ -69,6 +70,7 @@ NetworkSettings::NetworkSettings(QWidget *parent)
 
     loadProxySettings();
     loadBWLimitSettings();
+    loadMeteredSettings();
 
     // proxy
     connect(_ui->typeComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &NetworkSettings::saveProxySettings);
@@ -92,6 +94,8 @@ NetworkSettings::NetworkSettings(QWidget *parent)
     connect(_ui->hostLineEdit, &QLineEdit::textChanged, this, &NetworkSettings::checkEmptyProxyHost);
     checkEmptyProxyHost();
     checkAccountLocalhost();
+
+    connect(_ui->pauseSyncWhenMeteredCheckbox, &QAbstractButton::clicked, this, &NetworkSettings::saveMeteredSettings);
 }
 
 NetworkSettings::~NetworkSettings()
@@ -177,6 +181,19 @@ void NetworkSettings::loadBWLimitSettings()
     _ui->uploadSpinBox->setValue(cfgFile.uploadLimit());
 }
 
+void NetworkSettings::loadMeteredSettings()
+{
+    if (QNetworkInformation *qNetInfo = QNetworkInformation::instance()) {
+        if (qNetInfo->supports(QNetworkInformation::Feature::Metered)) {
+            _ui->pauseSyncWhenMeteredCheckbox->setChecked(ConfigFile().pauseSyncWhenMetered());
+            return;
+        }
+    }
+
+    _ui->pauseSyncWhenMeteredCheckbox->setEnabled(false);
+    _ui->pauseSyncWhenMeteredCheckbox->setToolTip(tr("Querying metered connection status is not supported on this platform"));
+}
+
 void NetworkSettings::saveProxySettings()
 {
     ConfigFile cfgFile;
@@ -231,6 +248,13 @@ void NetworkSettings::saveBWLimitSettings()
     FolderMan::instance()->setDirtyNetworkLimits();
 }
 
+void NetworkSettings::saveMeteredSettings()
+{
+    bool pauseSyncWhenMetered = _ui->pauseSyncWhenMeteredCheckbox->isChecked();
+    ConfigFile().setPauseSyncWhenMetered(pauseSyncWhenMetered);
+    FolderMan::instance()->scheduler()->setPauseSyncWhenMetered(pauseSyncWhenMetered);
+}
+
 void NetworkSettings::checkEmptyProxyHost()
 {
     if (_ui->hostLineEdit->isEnabled() && _ui->hostLineEdit->text().isEmpty()) {

src/gui/networksettings.h

@@ -41,6 +41,7 @@ class NetworkSettings : public QWidget
 private slots:
     void saveProxySettings();
     void saveBWLimitSettings();
+    void saveMeteredSettings();
 
     /// Red marking of host field if empty and enabled
     void checkEmptyProxyHost();
@@ -53,6 +54,7 @@ private slots:
 private:
     void loadProxySettings();
     void loadBWLimitSettings();
+    void loadMeteredSettings();
     CredentialManager *_credentialManager;
 
 

src/gui/networksettings.ui

@@ -339,6 +339,13 @@
      </item>
     </layout>
    </item>
+   <item>
+    <widget class="QCheckBox" name="pauseSyncWhenMeteredCheckbox">
+     <property name="text">
+      <string>Pause synchronization when the Internet connection is metered</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">

src/gui/scheduling/syncscheduler.cpp

@@ -19,6 +19,8 @@
 #include "libsync/configfile.h"
 #include "libsync/syncengine.h"
 
+#include <QNetworkInformation>
+
 using namespace std::chrono_literals;
 
 using namespace OCC;
@@ -98,6 +100,7 @@ class FolderPriorityQueue
 
 SyncScheduler::SyncScheduler(FolderMan *parent)
     : QObject(parent)
+    , _pauseSyncWhenMetered(ConfigFile().pauseSyncWhenMetered())
     , _queue(new FolderPriorityQueue)
 {
     new ETagWatcher(parent, this);
@@ -134,15 +137,38 @@ void SyncScheduler::enqueueFolder(Folder *folder, Priority priority)
     }
 }
 
-void SyncScheduler::startNext()
+bool SyncScheduler::canRun() const
 {
     if (!_running) {
         qCInfo(lcSyncScheduler) << "Scheduler is paused, next sync is not started";
-        return;
+        return false;
+    }
+
+    if (_pauseSyncWhenMetered && isMetered()) {
+        qCInfo(lcSyncScheduler) << "Scheduler is paused due to metered internet connection, next sync is not started";
+        return false;
     }
 
     if (!_currentSync.isNull()) {
         qCInfo(lcSyncScheduler) << "Another sync is already running, waiting for that to finish before starting a new sync";
+        return false;
+    }
+
+    return true;
+}
+
+bool SyncScheduler::isMetered() const
+{
+    if (auto *qNetInfo = QNetworkInformation::instance()) {
+        return qNetInfo->isMetered();
+    }
+
+    return false;
+}
+
+void SyncScheduler::startNext()
+{
+    if (!canRun()) {
         return;
     }
 
@@ -205,3 +231,11 @@ bool SyncScheduler::hasCurrentRunningSyncRunning() const
 {
     return _currentSync;
 }
+
+void SyncScheduler::setPauseSyncWhenMetered(bool pauseSyncWhenMetered)
+{
+    _pauseSyncWhenMetered = pauseSyncWhenMetered;
+    if (!pauseSyncWhenMetered) {
+        startNext();
+    }
+}

src/gui/scheduling/syncscheduler.h

@@ -56,11 +56,16 @@ class SyncScheduler : public QObject
 
     bool hasCurrentRunningSyncRunning() const;
 
+    void setPauseSyncWhenMetered(bool pauseSyncWhenMetered);
+
 
 private:
     void startNext();
+    bool canRun() const;
+    bool isMetered() const;
 
     bool _running = false;
+    bool _pauseSyncWhenMetered;
     QPointer<Folder> _currentSync;
     FolderPriorityQueue *_queue;
 };

src/libsync/configfile.cpp

@@ -95,6 +95,10 @@ const QString downloadLimitC() { return QStringLiteral("BWLimit/downloadLimit");
 const QString newBigFolderSizeLimitC() { return QStringLiteral("newBigFolderSizeLimit"); }
 const QString useNewBigFolderSizeLimitC() { return QStringLiteral("useNewBigFolderSizeLimit"); }
 const QString confirmExternalStorageC() { return QStringLiteral("confirmExternalStorage"); }
+const QString pauseSyncWhenMeteredC()
+{
+    return QStringLiteral("pauseWhenMetered");
+}
 const QString moveToTrashC() { return QStringLiteral("moveToTrash"); }
 
 const QString issuesWidgetFilterC()
@@ -719,6 +723,16 @@ void ConfigFile::setConfirmExternalStorage(bool isChecked)
     setValue(confirmExternalStorageC(), isChecked);
 }
 
+bool ConfigFile::pauseSyncWhenMetered() const
+{
+    return getValue(pauseSyncWhenMeteredC(), {}, false).toBool();
+}
+
+void ConfigFile::setPauseSyncWhenMetered(bool isChecked)
+{
+    setValue(pauseSyncWhenMeteredC(), isChecked);
+}
+
 bool ConfigFile::moveToTrash() const
 {
     return getValue(moveToTrashC(), QString(), false).toBool();

src/libsync/configfile.h

@@ -146,6 +146,9 @@ class OWNCLOUDSYNC_EXPORT ConfigFile
     bool confirmExternalStorage() const;
     void setConfirmExternalStorage(bool);
 
+    bool pauseSyncWhenMetered() const;
+    void setPauseSyncWhenMetered(bool isChecked);
+
     /** If we should move the files deleted on the server in the trash  */
     bool moveToTrash() const;
     void setMoveToTrash(bool);