dan9i10/amnezia-client
1
0
Fork 0
mirror of https://github.com/amnezia-vpn/amnezia-client.git synced 2026-05-08 14:33:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactoring: separete settings controller

Browse Source
This commit is contained in:
vladimir.kuznetsov
2025-07-31 13:00:01 +08:00
parent 5012cd90e2
commit abb9ffe1b7
10 changed files with 410 additions and 410 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
client/cmake/sources.cmake
View File

@@ -20,7 +20,7 @@ set(HEADERS ${HEADERS}
${CLIENT_ROOT_DIR}/core/controllers/configController.h
${CLIENT_ROOT_DIR}/core/controllers/dnsController.h
${CLIENT_ROOT_DIR}/core/controllers/splitTunnelingController.h
${CLIENT_ROOT_DIR}/core/controllers/settingsConfigController.h
${CLIENT_ROOT_DIR}/core/controllers/settingsController.h
${CLIENT_ROOT_DIR}/core/controllers/vpnConnectionController.h
${CLIENT_ROOT_DIR}/core/controllers/vpnConfigurationController.h
${CLIENT_ROOT_DIR}/protocols/protocols_defs.h
@@ -76,7 +76,7 @@ set(SOURCES ${SOURCES}
${CLIENT_ROOT_DIR}/core/controllers/configController.cpp
${CLIENT_ROOT_DIR}/core/controllers/dnsController.cpp
${CLIENT_ROOT_DIR}/core/controllers/splitTunnelingController.cpp
${CLIENT_ROOT_DIR}/core/controllers/settingsConfigController.cpp
${CLIENT_ROOT_DIR}/core/controllers/settingsController.cpp
${CLIENT_ROOT_DIR}/core/controllers/vpnConnectionController.cpp
${CLIENT_ROOT_DIR}/core/controllers/vpnConfigurationController.cpp
${CLIENT_ROOT_DIR}/protocols/protocols_defs.cpp

16
client/core/controllers/coreController.cpp
View File

@@ -140,10 +140,10 @@ void CoreController::initControllers()
m_importController.reset(new ImportController(m_serversModel, m_containersModel, m_settings));
m_engine->rootContext()->setContextProperty("ImportController", m_importController.get());
m_settingsConfigController = QSharedPointer<SettingsConfigController>::create(m_settings, this);
m_settingsController.reset(
new SettingsController(m_serversModel, m_containersModel, m_languageModel, m_sitesModel, m_appSplitTunnelingModel, m_settingsConfigController));
m_engine->rootContext()->setContextProperty("SettingsController", m_settingsController.get());
m_settingsController = QSharedPointer<SettingsController>::create(m_settings, this);
m_settingsUIController.reset(
new SettingsUIController(m_serversModel, m_containersModel, m_languageModel, m_sitesModel, m_appSplitTunnelingModel, m_settingsController));
m_engine->rootContext()->setContextProperty("SettingsController", m_settingsUIController.get());
m_sitesController.reset(new SitesController(m_settings, m_vpnConnection, m_sitesModel));
m_engine->rootContext()->setContextProperty("SitesController", m_sitesController.get());
@@ -262,7 +262,7 @@ void CoreController::initAppleController()
connect(IosController::Instance(), &IosController::importBackupFromOutside, this, [this](QString filePath) {
emit m_pageController->goToPageHome();
m_pageController->goToPageSettingsBackup();
emit m_settingsController->importBackupFromOutside(filePath);
emit m_settingsUIController->importBackupFromOutside(filePath);
});
QTimer::singleShot(0, this, [this]() { AmneziaVPN::toggleScreenshots(m_settings->isScreenshotsEnabled()); });
@@ -396,14 +396,14 @@ void CoreController::initTranslationsUpdatedHandler()
void CoreController::initAutoConnectHandler()
{
if (m_settingsController->isAutoConnectEnabled() && m_serversModel->getDefaultServerIndex() >= 0) {
if (m_settingsUIController->isAutoConnectEnabled() && m_serversModel->getDefaultServerIndex() >= 0) {
QTimer::singleShot(1000, this, [this]() { m_connectionController->openConnection(); });
}
}
void CoreController::initAmneziaDnsToggledHandler()
{
connect(m_settingsController.get(), &SettingsController::amneziaDnsToggled, m_serversModel.get(), &ServersModel::toggleAmneziaDns);
connect(m_settingsUIController.get(), &SettingsUIController::amneziaDnsToggled, m_serversModel.get(), &ServersModel::toggleAmneziaDns);
}
void CoreController::initPrepareConfigHandler()
@@ -446,7 +446,7 @@ void CoreController::initShowMigrationDrawerHandler()
void CoreController::initStrictKillSwitchHandler()
{
connect(m_settingsController.get(), &SettingsController::strictKillSwitchEnabledChanged, m_vpnConnection.get(),
connect(m_settingsUIController.get(), &SettingsUIController::strictKillSwitchEnabledChanged, m_vpnConnection.get(),
&VpnConnection::onKillSwitchModeChanged);
}

8
client/core/controllers/coreController.h
View File

@@ -19,10 +19,10 @@
#include "ui/controllers/importController.h"
#include "ui/controllers/selfhosted/installUIController.h"
#include "ui/controllers/pageController.h"
#include "ui/controllers/settingsController.h"
#include "ui/controllers/settingsUIController.h"
#include "ui/controllers/sitesController.h"
#include "ui/controllers/systemController.h"
#include "core/controllers/settingsConfigController.h"
#include "core/controllers/settingsController.h"
#include "ui/models/allowed_dns_model.h"
#include "ui/models/containers_model.h"
@@ -112,7 +112,7 @@ private:
QScopedPointer<ExportUIController> m_exportUIController;
QScopedPointer<InstallUIController> m_installUIController;
QScopedPointer<ImportController> m_importController;
QScopedPointer<SettingsController> m_settingsController;
QScopedPointer<SettingsUIController> m_settingsUIController;
QScopedPointer<SitesController> m_sitesController;
QScopedPointer<SystemController> m_systemController;
QScopedPointer<AppSplitTunnelingController> m_appSplitTunnelingController;
@@ -122,7 +122,7 @@ private:
QScopedPointer<ApiConfigsController> m_apiConfigsController;
QScopedPointer<ApiPremV1MigrationController> m_apiPremV1MigrationController;
QSharedPointer<SettingsConfigController> m_settingsConfigController;
QSharedPointer<SettingsController> m_settingsController;
QSharedPointer<ContainersModel> m_containersModel;
QSharedPointer<ContainersModel> m_defaultServerContainersModel;

72
client/core/controllers/settingsConfigController.cpp → client/core/controllers/settingsController.cpp
View File

@@ -1,4 +1,4 @@
#include "settingsConfigController.h"
#include "settingsController.h"
#include <QDateTime>
@@ -11,35 +11,35 @@
namespace
{
Logger logger("SettingsConfigController");
Logger logger("SettingsController");
}
SettingsConfigController::SettingsConfigController(std::shared_ptr<Settings> settings, QObject *parent)
SettingsController::SettingsController(std::shared_ptr<Settings> settings, QObject *parent)
: QObject(parent), m_settings(settings)
{
}
void SettingsConfigController::resetAllSettings()
void SettingsController::resetAllSettings()
{
logger.info() << "Resetting all settings to defaults";
m_settings->clearSettings();
emit settingsReset();
}
void SettingsConfigController::configureDns(const QString &primaryDns, const QString &secondaryDns)
void SettingsController::configureDns(const QString &primaryDns, const QString &secondaryDns)
{
m_settings->setPrimaryDns(primaryDns);
m_settings->setSecondaryDns(secondaryDns);
emit dnsConfigChanged();
}
void SettingsConfigController::toggleAmneziaDns(bool enable)
void SettingsController::toggleAmneziaDns(bool enable)
{
m_settings->setUseAmneziaDns(enable);
emit dnsConfigChanged();
}
void SettingsConfigController::configureLogging(bool enable)
void SettingsController::configureLogging(bool enable)
{
m_settings->setSaveLogs(enable);
if (enable) {
@@ -48,7 +48,7 @@ void SettingsConfigController::configureLogging(bool enable)
emit loggingConfigChanged();
}
void SettingsConfigController::checkLoggingExpiration()
void SettingsController::checkLoggingExpiration()
{
if (m_settings->isSaveLogs()) {
QDateTime loggingDisableDate = m_settings->getLogEnableDate().addDays(14);
@@ -60,7 +60,7 @@ void SettingsConfigController::checkLoggingExpiration()
}
}
void SettingsConfigController::clearLogs()
void SettingsController::clearLogs()
{
logger.info() << "Clearing application logs";
@@ -74,7 +74,7 @@ void SettingsConfigController::clearLogs()
logger.info() << "Logs cleared successfully";
}
void SettingsConfigController::configureKillSwitch(bool enable, bool strict)
void SettingsController::configureKillSwitch(bool enable, bool strict)
{
m_settings->setKillSwitchEnabled(enable);
if (enable) {
@@ -85,103 +85,103 @@ void SettingsConfigController::configureKillSwitch(bool enable, bool strict)
emit killSwitchConfigChanged();
}
void SettingsConfigController::configureAutoStart(bool enable)
void SettingsController::configureAutoStart(bool enable)
{
Autostart::setAutostart(enable);
emit autoStartConfigChanged();
}
void SettingsConfigController::configureAutoConnect(bool enable)
void SettingsController::configureAutoConnect(bool enable)
{
m_settings->setAutoConnect(enable);
}
void SettingsConfigController::configureStartMinimized(bool enable)
void SettingsController::configureStartMinimized(bool enable)
{
m_settings->setStartMinimized(enable);
}
void SettingsConfigController::configureScreenshots(bool enable)
void SettingsController::configureScreenshots(bool enable)
{
m_settings->setScreenshotsEnabled(enable);
}
QString SettingsConfigController::getPrimaryDns() const
QString SettingsController::getPrimaryDns() const
{
return m_settings->primaryDns();
}
QString SettingsConfigController::getSecondaryDns() const
QString SettingsController::getSecondaryDns() const
{
return m_settings->secondaryDns();
}
bool SettingsConfigController::isAmneziaDnsEnabled() const
bool SettingsController::isAmneziaDnsEnabled() const
{
return m_settings->isUseAmneziaDns();
}
bool SettingsConfigController::isLoggingEnabled() const
bool SettingsController::isLoggingEnabled() const
{
return m_settings->isSaveLogs();
}
bool SettingsConfigController::isKillSwitchEnabled() const
bool SettingsController::isKillSwitchEnabled() const
{
return m_settings->isKillSwitchEnabled();
}
bool SettingsConfigController::isStrictKillSwitchEnabled() const
bool SettingsController::isStrictKillSwitchEnabled() const
{
return m_settings->isStrictKillSwitchEnabled();
}
bool SettingsConfigController::isAutoStartEnabled() const
bool SettingsController::isAutoStartEnabled() const
{
return m_settings->isAutoStart();
}
bool SettingsConfigController::isAutoConnectEnabled() const
bool SettingsController::isAutoConnectEnabled() const
{
return m_settings->isAutoConnect();
}
bool SettingsConfigController::isStartMinimizedEnabled() const
bool SettingsController::isStartMinimizedEnabled() const
{
return m_settings->isStartMinimized();
}
bool SettingsConfigController::isScreenshotsEnabled() const
bool SettingsController::isScreenshotsEnabled() const
{
return m_settings->isScreenshotsEnabled();
}
QByteArray SettingsConfigController::backupAppConfig() const
QByteArray SettingsController::backupAppConfig() const
{
return m_settings->backupAppConfig();
}
bool SettingsConfigController::restoreAppConfig(const QByteArray &data)
bool SettingsController::restoreAppConfig(const QByteArray &data)
{
return m_settings->restoreAppConfig(data);
}
QString SettingsConfigController::getInstallationUuid() const
QString SettingsController::getInstallationUuid() const
{
return m_settings->getInstallationUuid(false);
}
void SettingsConfigController::resetGatewayEndpoint()
void SettingsController::resetGatewayEndpoint()
{
m_settings->resetGatewayEndpoint();
}
void SettingsConfigController::setGatewayEndpoint(const QString &endpoint)
void SettingsController::setGatewayEndpoint(const QString &endpoint)
{
m_settings->setGatewayEndpoint(endpoint);
}
QString SettingsConfigController::getGatewayEndpoint() const
QString SettingsController::getGatewayEndpoint() const
{
if (m_settings->isDevGatewayEnv()) {
return "Dev endpoint";
@@ -189,12 +189,12 @@ QString SettingsConfigController::getGatewayEndpoint() const
return m_settings->getGatewayEndpoint();
}
bool SettingsConfigController::isDevGatewayEnv() const
bool SettingsController::isDevGatewayEnv() const
{
return m_settings->isDevGatewayEnv();
}
void SettingsConfigController::toggleDevGatewayEnv(bool enabled)
void SettingsController::toggleDevGatewayEnv(bool enabled)
{
m_settings->toggleDevGatewayEnv(enabled);
if (enabled) {
@@ -204,22 +204,22 @@ void SettingsConfigController::toggleDevGatewayEnv(bool enabled)
}
}
void SettingsConfigController::setDevGatewayEndpoint()
void SettingsController::setDevGatewayEndpoint()
{
m_settings->setDevGatewayEndpoint();
}
bool SettingsConfigController::isHomeAdLabelVisible() const
bool SettingsController::isHomeAdLabelVisible() const
{
return m_settings->isHomeAdLabelVisible();
}
void SettingsConfigController::disableHomeAdLabel()
void SettingsController::disableHomeAdLabel()
{
m_settings->disableHomeAdLabel();
}
QDateTime SettingsConfigController::getLogEnableDate() const
QDateTime SettingsController::getLogEnableDate() const
{
return m_settings->getLogEnableDate();
}

10
client/core/controllers/settingsConfigController.h → client/core/controllers/settingsController.h
View File

@@ -1,5 +1,5 @@
#ifndef SETTINGSCONFIGCONTROLLER_H
#define SETTINGSCONFIGCONTROLLER_H
#ifndef SETTINGSCONTROLLER_H
#define SETTINGSCONTROLLER_H
#include <QObject>
#include <QFuture>
@@ -11,12 +11,12 @@ class Settings;
using namespace amnezia;
class SettingsConfigController : public QObject
class SettingsController : public QObject
{
Q_OBJECT
public:
explicit SettingsConfigController(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
explicit SettingsController(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
void resetAllSettings();
@@ -79,4 +79,4 @@ private:
std::shared_ptr<Settings> m_settings;
};
#endif // SETTINGSCONFIGCONTROLLER_H
#endif // SETTINGSCONTROLLER_H

342
client/ui/controllers/settingsController.cpp
View File

@@ -1,342 +0,0 @@
#include "settingsController.h"
#include <QStandardPaths>
#include "logger.h"
#include "systemController.h"
#include "ui/qautostart.h"
#include "version.h"
#ifdef Q_OS_ANDROID
#include "platforms/android/android_controller.h"
#endif
#ifdef Q_OS_IOS
#include <AmneziaVPN-Swift.h>
#endif
SettingsController::SettingsController(const QSharedPointer<ServersModel> &serversModel,
const QSharedPointer<ContainersModel> &containersModel,
const QSharedPointer<LanguageModel> &languageModel,
const QSharedPointer<SitesModel> &sitesModel,
const QSharedPointer<AppSplitTunnelingModel> &appSplitTunnelingModel,
QSharedPointer<SettingsConfigController> settingsConfigController,
QObject *parent)
: QObject(parent),
m_serversModel(serversModel),
m_containersModel(containersModel),
m_languageModel(languageModel),
m_sitesModel(sitesModel),
m_appSplitTunnelingModel(appSplitTunnelingModel),
m_settingsConfigController(settingsConfigController)
{
m_appVersion = QString("%1 (%2, %3)").arg(QString(APP_VERSION), __DATE__, GIT_COMMIT_HASH);
checkIfNeedDisableLogs();
#ifdef Q_OS_ANDROID
connect(AndroidController::instance(), &AndroidController::notificationStateChanged, this, &SettingsController::onNotificationStateChanged);
#endif
}
void SettingsController::toggleAmneziaDns(bool enable)
{
m_settingsConfigController->toggleAmneziaDns(enable);
emit amneziaDnsToggled(enable);
}
bool SettingsController::isAmneziaDnsEnabled()
{
return m_settingsConfigController->isAmneziaDnsEnabled();
}
QString SettingsController::getPrimaryDns()
{
return m_settingsConfigController->getPrimaryDns();
}
void SettingsController::setPrimaryDns(const QString &dns)
{
m_settingsConfigController->configureDns(dns, m_settingsConfigController->getSecondaryDns());
emit primaryDnsChanged();
}
QString SettingsController::getSecondaryDns()
{
return m_settingsConfigController->getSecondaryDns();
}
void SettingsController::setSecondaryDns(const QString &dns)
{
m_settingsConfigController->configureDns(m_settingsConfigController->getPrimaryDns(), dns);
emit secondaryDnsChanged();
}
bool SettingsController::isLoggingEnabled()
{
return m_settingsConfigController->isLoggingEnabled();
}
void SettingsController::toggleLogging(bool enable)
{
m_settingsConfigController->configureLogging(enable);
#ifdef Q_OS_IOS
AmneziaVPN::toggleLogging(enable);
#endif
if (enable == true) {
qInfo().noquote() << QString("Logging has enabled on %1 version %2 %3").arg(APPLICATION_NAME, APP_VERSION, GIT_COMMIT_HASH);
qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName(), QSysInfo::currentCpuArchitecture());
}
emit loggingStateChanged();
}
void SettingsController::openLogsFolder()
{
Logger::openLogsFolder(false);
}
void SettingsController::openServiceLogsFolder()
{
Logger::openLogsFolder(true);
}
void SettingsController::exportLogsFile(const QString &fileName)
{
m_settingsConfigController->exportLogsFile(fileName);
}
void SettingsController::exportServiceLogsFile(const QString &fileName)
{
m_settingsConfigController->exportServiceLogsFile(fileName);
}
void SettingsController::clearLogs()
{
m_settingsConfigController->clearLogs();
}
void SettingsController::backupAppConfig(const QString &fileName)
{
m_settingsConfigController->backupAppConfig(fileName);
}
void SettingsController::restoreAppConfig(const QString &fileName)
{
bool success = m_settingsConfigController->restoreAppConfig(fileName);
if (success) {
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
emit restoreBackupFinished();
} else {
emit changeSettingsErrorOccurred(tr("Backup file is corrupted"));
}
}
void SettingsController::restoreAppConfigFromData(const QByteArray &data)
{
bool success = m_settingsConfigController->restoreAppConfigFromData(data);
if (success) {
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
emit restoreBackupFinished();
} else {
emit changeSettingsErrorOccurred(tr("Backup file is corrupted"));
}
}
QString SettingsController::getAppVersion()
{
return m_appVersion;
}
void SettingsController::clearSettings()
{
m_settingsConfigController->resetAllSettings();
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
m_sitesModel->setRouteMode(Settings::RouteMode::VpnOnlyForwardSites);
m_sitesModel->toggleSplitTunneling(false);
m_appSplitTunnelingModel->setRouteMode(Settings::AppsRouteMode::VpnAllExceptApps);
m_appSplitTunnelingModel->toggleSplitTunneling(false);
toggleAutoStart(false);
emit changeSettingsFinished(tr("All settings have been reset to default values"));
#ifdef Q_OS_IOS
AmneziaVPN::clearSettings();
#endif
}
bool SettingsController::isAutoConnectEnabled()
{
return m_settingsConfigController->isAutoConnectEnabled();
}
void SettingsController::toggleAutoConnect(bool enable)
{
m_settingsConfigController->configureAutoConnect(enable);
}
bool SettingsController::isAutoStartEnabled()
{
return m_settingsConfigController->isAutoStartEnabled();
}
void SettingsController::toggleAutoStart(bool enable)
{
m_settingsConfigController->configureAutoStart(enable);
}
bool SettingsController::isStartMinimizedEnabled()
{
return m_settingsConfigController->isStartMinimizedEnabled();
}
void SettingsController::toggleStartMinimized(bool enable)
{
m_settingsConfigController->configureStartMinimized(enable);
}
bool SettingsController::isScreenshotsEnabled()
{
return m_settingsConfigController->isScreenshotsEnabled();
}
void SettingsController::toggleScreenshotsEnabled(bool enable)
{
m_settingsConfigController->configureScreenshots(enable);
}
bool SettingsController::isCameraPresent()
{
#if defined Q_OS_IOS
return true;
#elif defined Q_OS_ANDROID
return AndroidController::instance()->isCameraPresent();
#else
return false;
#endif
}
void SettingsController::checkIfNeedDisableLogs()
{
if (m_settingsConfigController->isLoggingEnabled()) {
m_loggingDisableDate = m_settingsConfigController->getLogEnableDate().addDays(14);
if (m_loggingDisableDate <= QDateTime::currentDateTime()) {
toggleLogging(false);
clearLogs();
emit loggingDisableByWatcher();
}
}
}
bool SettingsController::isKillSwitchEnabled()
{
return m_settingsConfigController->isKillSwitchEnabled();
}
void SettingsController::toggleKillSwitch(bool enable)
{
m_settingsConfigController->configureKillSwitch(enable, false);
emit killSwitchEnabledChanged();
if (enable == false) {
emit strictKillSwitchEnabledChanged(false);
} else {
emit strictKillSwitchEnabledChanged(isStrictKillSwitchEnabled());
}
}
bool SettingsController::isStrictKillSwitchEnabled()
{
return m_settingsConfigController->isStrictKillSwitchEnabled();
}
void SettingsController::toggleStrictKillSwitch(bool enable)
{
m_settingsConfigController->configureKillSwitch(m_settingsConfigController->isKillSwitchEnabled(), enable);
emit strictKillSwitchEnabledChanged(enable);
}
bool SettingsController::isNotificationPermissionGranted()
{
#ifdef Q_OS_ANDROID
return AndroidController::instance()->isNotificationPermissionGranted();
#else
return true;
#endif
}
void SettingsController::requestNotificationPermission()
{
#ifdef Q_OS_ANDROID
AndroidController::instance()->requestNotificationPermission();
#endif
}
QString SettingsController::getInstallationUuid()
{
return m_settingsConfigController->getInstallationUuid();
}
void SettingsController::enableDevMode()
{
m_isDevModeEnabled = true;
emit devModeEnabled();
}
bool SettingsController::isDevModeEnabled()
{
return m_isDevModeEnabled;
}
void SettingsController::resetGatewayEndpoint()
{
m_settingsConfigController->resetGatewayEndpoint();
emit gatewayEndpointChanged(m_settingsConfigController->getGatewayEndpoint());
}
void SettingsController::setGatewayEndpoint(const QString &endpoint)
{
m_settingsConfigController->setGatewayEndpoint(endpoint);
emit gatewayEndpointChanged(endpoint);
}
QString SettingsController::getGatewayEndpoint()
{
return m_settingsConfigController->getGatewayEndpoint();
}
bool SettingsController::isDevGatewayEnv()
{
return m_settingsConfigController->isDevGatewayEnv();
}
void SettingsController::toggleDevGatewayEnv(bool enabled)
{
m_settingsConfigController->toggleDevGatewayEnv(enabled);
emit gatewayEndpointChanged(m_settingsConfigController->getGatewayEndpoint());
emit devGatewayEnvChanged(enabled);
}
bool SettingsController::isOnTv()
{
#ifdef Q_OS_ANDROID
return AndroidController::instance()->isOnTv();
#else
return false;
#endif
}
bool SettingsController::isHomeAdLabelVisible()
{
return m_settingsConfigController->isHomeAdLabelVisible();
}
void SettingsController::disableHomeAdLabel()
{
m_settingsConfigController->disableHomeAdLabel();
emit isHomeAdLabelVisibleChanged(false);
}

342
client/ui/controllers/settingsUIController.cpp Normal file
View File

@@ -0,0 +1,342 @@
#include "settingsUIController.h"
#include <QStandardPaths>
#include "logger.h"
#include "systemController.h"
#include "ui/qautostart.h"
#include "version.h"
#ifdef Q_OS_ANDROID
#include "platforms/android/android_controller.h"
#endif
#ifdef Q_OS_IOS
#include <AmneziaVPN-Swift.h>
#endif
SettingsUIController::SettingsUIController(const QSharedPointer<ServersModel> &serversModel,
const QSharedPointer<ContainersModel> &containersModel,
const QSharedPointer<LanguageModel> &languageModel,
const QSharedPointer<SitesModel> &sitesModel,
const QSharedPointer<AppSplitTunnelingModel> &appSplitTunnelingModel,
QSharedPointer<SettingsController> settingsController,
QObject *parent)
: QObject(parent),
m_serversModel(serversModel),
m_containersModel(containersModel),
m_languageModel(languageModel),
m_sitesModel(sitesModel),
m_appSplitTunnelingModel(appSplitTunnelingModel),
m_settingsController(settingsController)
{
m_appVersion = QString("%1 (%2, %3)").arg(QString(APP_VERSION), __DATE__, GIT_COMMIT_HASH);
checkIfNeedDisableLogs();
#ifdef Q_OS_ANDROID
connect(AndroidController::instance(), &AndroidController::notificationStateChanged, this, &SettingsUIController::onNotificationStateChanged);
#endif
}
void SettingsUIController::toggleAmneziaDns(bool enable)
{
m_settingsController->toggleAmneziaDns(enable);
emit amneziaDnsToggled(enable);
}
bool SettingsUIController::isAmneziaDnsEnabled()
{
return m_settingsController->isAmneziaDnsEnabled();
}
QString SettingsUIController::getPrimaryDns()
{
return m_settingsController->getPrimaryDns();
}
void SettingsUIController::setPrimaryDns(const QString &dns)
{
m_settingsController->configureDns(dns, m_settingsController->getSecondaryDns());
emit primaryDnsChanged();
}
QString SettingsUIController::getSecondaryDns()
{
return m_settingsController->getSecondaryDns();
}
void SettingsUIController::setSecondaryDns(const QString &dns)
{
m_settingsController->configureDns(m_settingsController->getPrimaryDns(), dns);
emit secondaryDnsChanged();
}
bool SettingsUIController::isLoggingEnabled()
{
return m_settingsController->isLoggingEnabled();
}
void SettingsUIController::toggleLogging(bool enable)
{
m_settingsController->configureLogging(enable);
#ifdef Q_OS_IOS
AmneziaVPN::toggleLogging(enable);
#endif
if (enable == true) {
qInfo().noquote() << QString("Logging has enabled on %1 version %2 %3").arg(APPLICATION_NAME, APP_VERSION, GIT_COMMIT_HASH);
qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName(), QSysInfo::currentCpuArchitecture());
}
emit loggingStateChanged();
}
void SettingsUIController::openLogsFolder()
{
Logger::openLogsFolder(false);
}
void SettingsUIController::openServiceLogsFolder()
{
Logger::openLogsFolder(true);
}
void SettingsUIController::exportLogsFile(const QString &fileName)
{
m_settingsController->exportLogsFile(fileName);
}
void SettingsUIController::exportServiceLogsFile(const QString &fileName)
{
m_settingsController->exportServiceLogsFile(fileName);
}
void SettingsUIController::clearLogs()
{
m_settingsController->clearLogs();
}
void SettingsUIController::backupAppConfig(const QString &fileName)
{
m_settingsController->backupAppConfig(fileName);
}
void SettingsUIController::restoreAppConfig(const QString &fileName)
{
bool success = m_settingsController->restoreAppConfig(fileName);
if (success) {
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
emit restoreBackupFinished();
} else {
emit changeSettingsErrorOccurred(tr("Backup file is corrupted"));
}
}
void SettingsUIController::restoreAppConfigFromData(const QByteArray &data)
{
bool success = m_settingsController->restoreAppConfigFromData(data);
if (success) {
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
emit restoreBackupFinished();
} else {
emit changeSettingsErrorOccurred(tr("Backup file is corrupted"));
}
}
QString SettingsUIController::getAppVersion()
{
return m_appVersion;
}
void SettingsUIController::clearSettings()
{
m_settingsController->resetAllSettings();
m_serversModel->resetModel();
m_languageModel->changeLanguage(
static_cast<LanguageSettings::AvailableLanguageEnum>(m_languageModel->getCurrentLanguageIndex()));
m_sitesModel->setRouteMode(Settings::RouteMode::VpnOnlyForwardSites);
m_sitesModel->toggleSplitTunneling(false);
m_appSplitTunnelingModel->setRouteMode(Settings::AppsRouteMode::VpnAllExceptApps);
m_appSplitTunnelingModel->toggleSplitTunneling(false);
toggleAutoStart(false);
emit changeSettingsFinished(tr("All settings have been reset to default values"));
#ifdef Q_OS_IOS
AmneziaVPN::clearSettings();
#endif
}
bool SettingsUIController::isAutoConnectEnabled()
{
return m_settingsController->isAutoConnectEnabled();
}
void SettingsUIController::toggleAutoConnect(bool enable)
{
m_settingsController->configureAutoConnect(enable);
}
bool SettingsUIController::isAutoStartEnabled()
{
return m_settingsController->isAutoStartEnabled();
}
void SettingsUIController::toggleAutoStart(bool enable)
{
m_settingsController->configureAutoStart(enable);
}
bool SettingsUIController::isStartMinimizedEnabled()
{
return m_settingsController->isStartMinimizedEnabled();
}
void SettingsUIController::toggleStartMinimized(bool enable)
{
m_settingsController->configureStartMinimized(enable);
}
bool SettingsUIController::isScreenshotsEnabled()
{
return m_settingsController->isScreenshotsEnabled();
}
void SettingsUIController::toggleScreenshotsEnabled(bool enable)
{
m_settingsController->configureScreenshots(enable);
}
bool SettingsUIController::isCameraPresent()
{
#if defined Q_OS_IOS
return true;
#elif defined Q_OS_ANDROID
return AndroidController::instance()->isCameraPresent();
#else
return false;
#endif
}
void SettingsUIController::checkIfNeedDisableLogs()
{
if (m_settingsController->isLoggingEnabled()) {
m_loggingDisableDate = m_settingsController->getLogEnableDate().addDays(14);
if (m_loggingDisableDate <= QDateTime::currentDateTime()) {
toggleLogging(false);
clearLogs();
emit loggingDisableByWatcher();
}
}
}
bool SettingsUIController::isKillSwitchEnabled()
{
return m_settingsController->isKillSwitchEnabled();
}
void SettingsUIController::toggleKillSwitch(bool enable)
{
m_settingsController->configureKillSwitch(enable, false);
emit killSwitchEnabledChanged();
if (enable == false) {
emit strictKillSwitchEnabledChanged(false);
} else {
emit strictKillSwitchEnabledChanged(isStrictKillSwitchEnabled());
}
}
bool SettingsUIController::isStrictKillSwitchEnabled()
{
return m_settingsController->isStrictKillSwitchEnabled();
}
void SettingsUIController::toggleStrictKillSwitch(bool enable)
{
m_settingsController->configureKillSwitch(m_settingsController->isKillSwitchEnabled(), enable);
emit strictKillSwitchEnabledChanged(enable);
}
bool SettingsUIController::isNotificationPermissionGranted()
{
#ifdef Q_OS_ANDROID
return AndroidController::instance()->isNotificationPermissionGranted();
#else
return true;
#endif
}
void SettingsUIController::requestNotificationPermission()
{
#ifdef Q_OS_ANDROID
AndroidController::instance()->requestNotificationPermission();
#endif
}
QString SettingsUIController::getInstallationUuid()
{
return m_settingsController->getInstallationUuid();
}
void SettingsUIController::enableDevMode()
{
m_isDevModeEnabled = true;
emit devModeEnabled();
}
bool SettingsUIController::isDevModeEnabled()
{
return m_isDevModeEnabled;
}
void SettingsUIController::resetGatewayEndpoint()
{
m_settingsController->resetGatewayEndpoint();
emit gatewayEndpointChanged(m_settingsController->getGatewayEndpoint());
}
void SettingsUIController::setGatewayEndpoint(const QString &endpoint)
{
m_settingsController->setGatewayEndpoint(endpoint);
emit gatewayEndpointChanged(endpoint);
}
QString SettingsUIController::getGatewayEndpoint()
{
return m_settingsController->getGatewayEndpoint();
}
bool SettingsUIController::isDevGatewayEnv()
{
return m_settingsController->isDevGatewayEnv();
}
void SettingsUIController::toggleDevGatewayEnv(bool enabled)
{
m_settingsController->toggleDevGatewayEnv(enabled);
emit gatewayEndpointChanged(m_settingsController->getGatewayEndpoint());
emit devGatewayEnvChanged(enabled);
}
bool SettingsUIController::isOnTv()
{
#ifdef Q_OS_ANDROID
return AndroidController::instance()->isOnTv();
#else
return false;
#endif
}
bool SettingsUIController::isHomeAdLabelVisible()
{
return m_settingsController->isHomeAdLabelVisible();
}
void SettingsUIController::disableHomeAdLabel()
{
m_settingsController->disableHomeAdLabel();
emit isHomeAdLabelVisibleChanged(false);
}

16
client/ui/controllers/settingsController.h → client/ui/controllers/settingsUIController.h
View File

@@ -1,5 +1,5 @@
#ifndef SETTINGSCONTROLLER_H
#define SETTINGSCONTROLLER_H
#ifndef SETTINGSUICONTROLLER_H
#define SETTINGSUICONTROLLER_H
#include <QObject>
@@ -9,18 +9,18 @@
#include "ui/models/sites_model.h"
#include "ui/models/appSplitTunnelingModel.h"
#include "core/controllers/settingsConfigController.h"
#include "core/controllers/settingsController.h"
class SettingsController : public QObject
class SettingsUIController : public QObject
{
Q_OBJECT
public:
explicit SettingsController(const QSharedPointer<ServersModel> &serversModel,
explicit SettingsUIController(const QSharedPointer<ServersModel> &serversModel,
const QSharedPointer<ContainersModel> &containersModel,
const QSharedPointer<LanguageModel> &languageModel,
const QSharedPointer<SitesModel> &sitesModel,
const QSharedPointer<AppSplitTunnelingModel> &appSplitTunnelingModel,
QSharedPointer<SettingsConfigController> settingsConfigController,
QSharedPointer<SettingsController> settingsController,
QObject *parent = nullptr);
Q_PROPERTY(QString primaryDns READ getPrimaryDns WRITE setPrimaryDns NOTIFY primaryDnsChanged)
@@ -135,7 +135,7 @@ private:
QSharedPointer<LanguageModel> m_languageModel;
QSharedPointer<SitesModel> m_sitesModel;
QSharedPointer<AppSplitTunnelingModel> m_appSplitTunnelingModel;
QSharedPointer<SettingsConfigController> m_settingsConfigController;
QSharedPointer<SettingsController> m_settingsController;
QString m_appVersion;
@@ -146,4 +146,4 @@ private:
void checkIfNeedDisableLogs();
};
#endif // SETTINGSCONTROLLER_H
#endif // SETTINGSUICONTROLLER_H

6
client/ui/models/servers_model.cpp
View File

@@ -36,9 +36,9 @@ ServersModel::ServersModel(std::shared_ptr<Settings> settings, QObject *parent)
{
m_serverConfigController = std::make_shared<SelfhostedConfigController>(settings);
m_installationController = std::make_shared<InstallationController>(settings);
m_settingsConfigController = std::make_shared<SettingsConfigController>(settings);
m_settingsController = std::make_shared<SettingsController>(settings);
m_isAmneziaDnsEnabled = m_settingsConfigController->isAmneziaDnsEnabled();
m_isAmneziaDnsEnabled = m_settingsController->isAmneziaDnsEnabled();
connect(this, &ServersModel::defaultServerIndexChanged, this, &ServersModel::defaultServerNameChanged);
@@ -570,7 +570,7 @@ QStringList ServersModel::getAllInstalledServicesName(const int serverIndex)
void ServersModel::toggleAmneziaDns(bool enabled)
{
m_settingsConfigController->toggleAmneziaDns(enabled);
m_settingsController->toggleAmneziaDns(enabled);
m_isAmneziaDnsEnabled = enabled;
emit defaultServerDescriptionChanged();
}

4
client/ui/models/servers_model.h
View File

@@ -6,7 +6,7 @@
#include "core/controllers/selfhosted/serverController.h"
#include "core/controllers/selfhosted/selfhostedConfigController.h"
#include "core/controllers/selfhosted/installationController.h"
#include "core/controllers/settingsConfigController.h"
#include "core/controllers/settingsController.h"
#include "core/models/servers/serverConfig.h"
#include "settings.h"
@@ -162,7 +162,7 @@ private:
std::shared_ptr<Settings> m_settings;
std::shared_ptr<SelfhostedConfigController> m_serverConfigController;
std::shared_ptr<InstallationController> m_installationController;
std::shared_ptr<SettingsConfigController> m_settingsConfigController;
std::shared_ptr<SettingsController> m_settingsController;
int m_defaultServerIndex;
int m_processedServerIndex;