Pause sync when on a metered Internet connection

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

When the internet connection is metered, and the user chooses to
force-sync a folder, they will now be asked if they are sure that they
want to do this.

Fixes: #4808

changelog/unreleased/4808

@@ -0,0 +1,6 @@
+Enhancement: Add option to pause synchronization on metered connections
+
+On platforms that support metered-connection detection, an option is now
+available to pause folder synchronization when the network connection
+switches to metered. When synchronization is paused, force-syncing can
+still be done.

src/gui/accountsettings.cpp

@@ -43,6 +43,7 @@
 #include <QIcon>
 #include <QKeySequence>
 #include <QMessageBox>
+#include <QNetworkInformation>
 #include <QPropertyAnimation>
 #include <QSortFilterProxyModel>
 #include <QToolTip>
@@ -642,19 +643,42 @@ void AccountSettings::slotScheduleCurrentFolderForceFullDiscovery()
 void AccountSettings::slotForceSyncCurrentFolder()
 {
     if (auto selectedFolder = this->selectedFolder()) {
-        // Terminate and reschedule any running sync
-        for (auto *folder : FolderMan::instance()->folders()) {
-            if (folder->isSyncRunning()) {
-                folder->slotTerminateSync(tr("User triggered force sync"));
-                FolderMan::instance()->scheduler()->enqueueFolder(folder);
-            }
+        if (Utility::internetConnectionIsMetered() && ConfigFile().pauseSyncWhenMetered()) {
+            auto messageBox = new QMessageBox(QMessageBox::Question, tr("Internet connection is metered"),
+                tr("Synchronization is paused because the Internet connection is a metered connection"
+                   "<p>Do you really want to force a Synchronization now?"),
+                QMessageBox::Yes | QMessageBox::No, ocApp()->gui()->settingsDialog());
+            messageBox->setAttribute(Qt::WA_DeleteOnClose);
+            connect(messageBox, &QMessageBox::accepted, this, [this, selectedFolder] { doForceSyncCurrentFolder(selectedFolder); });
+            messageBox->open();
+            ownCloudGui::raiseDialog(messageBox);
+        } else {
+            doForceSyncCurrentFolder(selectedFolder);
         }
+    }
+}
 
-        selectedFolder->slotWipeErrorBlacklist(); // issue #6757
-        selectedFolder->slotNextSyncFullLocalDiscovery(); // ensure we don't forget about local errors
-        // Insert the selected folder at the front of the queue
-        FolderMan::instance()->scheduler()->enqueueFolder(selectedFolder, SyncScheduler::Priority::High);
+void AccountSettings::doForceSyncCurrentFolder(Folder *selectedFolder)
+{
+    // Prevent new sync starts
+    FolderMan::instance()->scheduler()->stop();
+
+    // Terminate and reschedule any running sync
+    for (auto *folder : FolderMan::instance()->folders()) {
+        if (folder->isSyncRunning()) {
+            folder->slotTerminateSync(tr("User triggered force sync"));
+            FolderMan::instance()->scheduler()->enqueueFolder(folder);
+        }
     }
+
+    selectedFolder->slotWipeErrorBlacklist(); // issue #6757
+    selectedFolder->slotNextSyncFullLocalDiscovery(); // ensure we don't forget about local errors
+
+    // Insert the selected folder at the front of the queue
+    FolderMan::instance()->scheduler()->enqueueFolder(selectedFolder, SyncScheduler::Priority::High);
+
+    // Restart scheduler
+    FolderMan::instance()->scheduler()->start();
 }
 
 void AccountSettings::slotAccountStateChanged()
@@ -670,19 +694,27 @@ void AccountSettings::slotAccountStateChanged()
         _model->slotUpdateFolderState(folder);
     }
 
+    auto acceptOAuthLogin = [this]() {
+        if (_askForOAuthLoginDialog != nullptr) {
+            _askForOAuthLoginDialog->accept();
+        }
+    };
+
     const QString server = QStringLiteral("<a href=\"%1\">%1</a>")
                                .arg(Utility::escape(safeUrl.toString()));
 
     switch (state) {
+    case AccountState::PausedDueToMetered:
+        showConnectionLabel(tr("Sync to %1 is paused due to metered internet connection.").arg(server));
+        acceptOAuthLogin();
+        break;
     case AccountState::Connected: {
         QStringList errors;
         if (account->serverSupportLevel() != Account::ServerSupportLevel::Supported) {
             errors << tr("The server version %1 is unsupported! Proceed at your own risk.").arg(account->capabilities().status().versionString());
         }
         showConnectionLabel(tr("Connected to %1.").arg(server), errors);
-        if (_askForOAuthLoginDialog != nullptr) {
-            _askForOAuthLoginDialog->accept();
-        }
+        acceptOAuthLogin();
         break;
     }
     case AccountState::ServiceUnavailable:

src/gui/accountsettings.h

@@ -89,6 +89,7 @@ protected slots:
         QStringList errors = QStringList());
     bool event(QEvent *) override;
     void createAccountToolbox();
+    void doForceSyncCurrentFolder(Folder *selectedFolder);
 
     /// Returns the alias of the selected folder, empty string if none
     Folder *selectedFolder() const;

src/gui/accountstate.cpp

@@ -18,6 +18,7 @@
 #include "application.h"
 #include "configfile.h"
 #include "fetchserversettings.h"
+#include "guiutility.h"
 
 #include "libsync/creds/abstractcredentials.h"
 #include "libsync/creds/httpcredentials.h"
@@ -136,6 +137,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
@@ -231,6 +244,8 @@ void AccountState::setState(State state)
             _connectionValidator->deleteLater();
             _connectionValidator.clear();
             checkConnectivity();
+        } else if (_state == Connected && Utility::internetConnectionIsMetered() && ConfigFile().pauseSyncWhenMetered()) {
+            _state = PausedDueToMetered;
         }
     }
 
@@ -290,7 +305,7 @@ void AccountState::signIn()
 
 bool AccountState::isConnected() const
 {
-    return _state == Connected;
+    return _state == Connected || _state == PausedDueToMetered;
 }
 
 void AccountState::tagLastSuccessfullETagRequest(const QDateTime &tp)

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.cpp

@@ -806,7 +806,6 @@ void Folder::setVirtualFilesEnabled(bool enabled)
         };
         if (isSyncRunning()) {
             connect(this, &Folder::syncFinished, this, finalizeVfsSwitch, Qt::SingleShotConnection);
-            QString reason;
             slotTerminateSync(tr("Switching VFS mode on folder '%1'").arg(displayName()));
         } else {
             finalizeVfsSwitch();

src/gui/folder.h

@@ -277,6 +277,7 @@ class Folder : public QObject
     {
         return *_engine;
     }
+
     Vfs &vfs()
     {
         OC_ENFORCE(_vfs);

src/gui/folderman.cpp

@@ -71,7 +71,7 @@ void TrayOverallStatusResult::addResult(Folder *f)
         lastSyncDone = time;
     }
 
-    auto status = f->syncPaused() ? SyncResult::Paused : f->syncResult().status();
+    auto status = f->syncPaused() || f->accountState()->state() == AccountState::PausedDueToMetered ? SyncResult::Paused : f->syncResult().status();
     if (status == SyncResult::Undefined) {
         status = SyncResult::Problem;
     }

src/gui/folderstatusmodel.cpp

@@ -303,7 +303,7 @@ QVariant FolderStatusModel::data(const QModelIndex &index, int role) const
             auto status = f->syncResult();
             if (!accountConnected) {
                 status.setStatus(SyncResult::Status::Offline);
-            } else if (f->syncPaused()) {
+            } else if (f->syncPaused() || f->accountState()->state() == AccountState::PausedDueToMetered) {
                 status.setStatus(SyncResult::Status::Paused);
             }
             return Theme::instance()->syncStateIconName(status);

src/gui/guiutility.cpp

@@ -16,13 +16,14 @@
 #include "application.h"
 #include "settingsdialog.h"
 
-#include <QClipboard>
 #include <QApplication>
+#include <QClipboard>
 #include <QDesktopServices>
+#include <QIcon>
 #include <QLoggingCategory>
 #include <QMessageBox>
+#include <QNetworkInformation>
 #include <QUrlQuery>
-#include <QIcon>
 
 #include "theme.h"
 
@@ -85,3 +86,12 @@ QString Utility::vfsFreeSpaceActionText()
 {
     return QCoreApplication::translate("utility", "Free up local space");
 }
+
+bool Utility::internetConnectionIsMetered()
+{
+    if (auto *qNetInfo = QNetworkInformation::instance()) {
+        return qNetInfo->isMetered();
+    }
+
+    return false;
+}

src/gui/guiutility.h

@@ -51,6 +51,7 @@ namespace Utility {
 
     QString socketApiSocketPath();
 
+    bool internetConnectionIsMetered();
 } // namespace Utility
 } // namespace OCC
 

src/gui/main.cpp

@@ -449,16 +449,20 @@ int main(int argc, char **argv)
         return -1;
     }
 
+    setupLogging(options);
+
 #if QT_VERSION >= QT_VERSION_CHECK(6, 3, 0)
+    qCDebug(lcMain) << QNetworkInformation::availableBackends().join(QStringLiteral(", "));
     if (!QNetworkInformation::loadDefaultBackend()) {
         qCWarning(lcMain) << "Failed to load QNetworkInformation";
+    } else {
+        qCDebug(lcMain) << "Loaded network information backend:" << QNetworkInformation::instance()->backendName()
+                        << "supported features:" << QNetworkInformation::instance()->supportedFeatures();
     }
 #else
     qCWarning(lcMain) << "QNetworkInformation is not available";
 #endif
 
-    setupLogging(options);
-
     platform->setApplication(&app);
 
     auto folderManager = FolderMan::createInstance();

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,21 @@ void NetworkSettings::loadBWLimitSettings()
     _ui->uploadSpinBox->setValue(cfgFile.uploadLimit());
 }
 
+void NetworkSettings::loadMeteredSettings()
+{
+    if (QNetworkInformation *qNetInfo = QNetworkInformation::instance()) {
+        if (Utility::isWindows() // The backend implements the metered feature, but does not report it as supported.
+                                 // See https://bugreports.qt.io/browse/QTBUG-118741
+            || 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 +250,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

@@ -14,6 +14,13 @@
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_5">
+   <item>
+    <widget class="QCheckBox" name="pauseSyncWhenMeteredCheckbox">
+     <property name="text">
+      <string>Pause synchronization when the Internet connection is metered</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <widget class="QGroupBox" name="proxyGroupBox">
      <property name="enabled">