Merge branch 'dev' of github.com:amnezia-vpn/amnezia-client into HEAD

2025-03-25 22:43:18 +07:00 · 2025-03-25 22:43:18 +07:00 · 805bc5fb61
commit 805bc5fb61
parent 3241782098 050066132b
773 changed files with 61955 additions and 17793 deletions
--- a/client/ui/controllers/api/apiConfigsController.cpp
+++ b/client/ui/controllers/api/apiConfigsController.cpp
@ -0,0 +1,519 @@
+#include "apiConfigsController.h"
+
+#include <QClipboard>
+#include <QEventLoop>
+
+#include "amnezia_application.h"
+#include "configurators/wireguard_configurator.h"
+#include "core/api/apiDefs.h"
+#include "core/api/apiUtils.h"
+#include "core/controllers/gatewayController.h"
+#include "core/qrCodeUtils.h"
+#include "ui/controllers/systemController.h"
+#include "version.h"
+
+namespace
+{
+    namespace configKey
+    {
+        constexpr char cloak[] = "cloak";
+        constexpr char awg[] = "awg";
+
+        constexpr char apiEndpoint[] = "api_endpoint";
+        constexpr char accessToken[] = "api_key";
+        constexpr char certificate[] = "certificate";
+        constexpr char publicKey[] = "public_key";
+        constexpr char protocol[] = "protocol";
+
+        constexpr char uuid[] = "installation_uuid";
+        constexpr char osVersion[] = "os_version";
+        constexpr char appVersion[] = "app_version";
+
+        constexpr char userCountryCode[] = "user_country_code";
+        constexpr char serverCountryCode[] = "server_country_code";
+        constexpr char serviceType[] = "service_type";
+        constexpr char serviceInfo[] = "service_info";
+        constexpr char serviceProtocol[] = "service_protocol";
+
+        constexpr char aesKey[] = "aes_key";
+        constexpr char aesIv[] = "aes_iv";
+        constexpr char aesSalt[] = "aes_salt";
+
+        constexpr char apiPayload[] = "api_payload";
+        constexpr char keyPayload[] = "key_payload";
+
+        constexpr char apiConfig[] = "api_config";
+        constexpr char authData[] = "auth_data";
+
+        constexpr char config[] = "config";
+    }
+}
+
+ApiConfigsController::ApiConfigsController(const QSharedPointer<ServersModel> &serversModel,
+                                           const QSharedPointer<ApiServicesModel> &apiServicesModel,
+                                           const std::shared_ptr<Settings> &settings, QObject *parent)
+    : QObject(parent), m_serversModel(serversModel), m_apiServicesModel(apiServicesModel), m_settings(settings)
+{
+}
+
+bool ApiConfigsController::exportNativeConfig(const QString &serverCountryCode, const QString &fileName)
+{
+    if (fileName.isEmpty()) {
+        emit errorOccurred(ErrorCode::PermissionsError);
+        return false;
+    }
+
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverConfigObject = m_serversModel->getServerConfig(m_serversModel->getProcessedServerIndex());
+    auto apiConfigObject = serverConfigObject.value(configKey::apiConfig).toObject();
+
+    QString protocol = apiConfigObject.value(configKey::serviceProtocol).toString();
+    ApiPayloadData apiPayloadData = generateApiPayloadData(protocol);
+
+    QJsonObject apiPayload = fillApiPayload(protocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = apiConfigObject.value(configKey::userCountryCode);
+    apiPayload[configKey::serverCountryCode] = serverCountryCode;
+    apiPayload[configKey::serviceType] = apiConfigObject.value(configKey::serviceType);
+    apiPayload[configKey::authData] = serverConfigObject.value(configKey::authData);
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/native_config"), apiPayload, responseBody);
+    if (errorCode != ErrorCode::NoError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    QJsonObject jsonConfig = QJsonDocument::fromJson(responseBody).object();
+    QString nativeConfig = jsonConfig.value(configKey::config).toString();
+    nativeConfig.replace("$WIREGUARD_CLIENT_PRIVATE_KEY", apiPayloadData.wireGuardClientPrivKey);
+
+    SystemController::saveFile(fileName, nativeConfig);
+    return true;
+}
+
+bool ApiConfigsController::revokeNativeConfig(const QString &serverCountryCode)
+{
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverConfigObject = m_serversModel->getServerConfig(m_serversModel->getProcessedServerIndex());
+    auto apiConfigObject = serverConfigObject.value(configKey::apiConfig).toObject();
+
+    QString protocol = apiConfigObject.value(configKey::serviceProtocol).toString();
+    ApiPayloadData apiPayloadData = generateApiPayloadData(protocol);
+
+    QJsonObject apiPayload = fillApiPayload(protocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = apiConfigObject.value(configKey::userCountryCode);
+    apiPayload[configKey::serverCountryCode] = serverCountryCode;
+    apiPayload[configKey::serviceType] = apiConfigObject.value(configKey::serviceType);
+    apiPayload[configKey::authData] = serverConfigObject.value(configKey::authData);
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/revoke_native_config"), apiPayload, responseBody);
+    if (errorCode != ErrorCode::NoError && errorCode != ErrorCode::ApiNotFoundError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+    return true;
+}
+
+void ApiConfigsController::prepareVpnKeyExport()
+{
+    auto serverConfigObject = m_serversModel->getServerConfig(m_serversModel->getProcessedServerIndex());
+    auto apiConfigObject = serverConfigObject.value(configKey::apiConfig).toObject();
+
+    auto vpnKey = apiConfigObject.value(apiDefs::key::vpnKey).toString();
+    m_vpnKey = vpnKey;
+
+    vpnKey.replace("vpn://", "");
+
+    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(vpnKey.toUtf8());
+
+    emit vpnKeyExportReady();
+}
+
+void ApiConfigsController::copyVpnKeyToClipboard()
+{
+    auto clipboard = amnApp->getClipboard();
+    clipboard->setText(m_vpnKey);
+}
+
+bool ApiConfigsController::fillAvailableServices()
+{
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    QJsonObject apiPayload;
+    apiPayload[configKey::osVersion] = QSysInfo::productType();
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/services"), apiPayload, responseBody);
+    if (errorCode == ErrorCode::NoError) {
+        if (!responseBody.contains("services")) {
+            errorCode = ErrorCode::ApiServicesMissingError;
+        }
+    }
+
+    if (errorCode != ErrorCode::NoError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    QJsonObject data = QJsonDocument::fromJson(responseBody).object();
+    m_apiServicesModel->updateModel(data);
+    return true;
+}
+
+bool ApiConfigsController::importServiceFromGateway()
+{
+    if (m_serversModel->isServerFromApiAlreadyExists(m_apiServicesModel->getCountryCode(), m_apiServicesModel->getSelectedServiceType(),
+                                                     m_apiServicesModel->getSelectedServiceProtocol())) {
+        emit errorOccurred(ErrorCode::ApiConfigAlreadyAdded);
+        return false;
+    }
+
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto installationUuid = m_settings->getInstallationUuid(true);
+    auto userCountryCode = m_apiServicesModel->getCountryCode();
+    auto serviceType = m_apiServicesModel->getSelectedServiceType();
+    auto serviceProtocol = m_apiServicesModel->getSelectedServiceProtocol();
+
+    ApiPayloadData apiPayloadData = generateApiPayloadData(serviceProtocol);
+
+    QJsonObject apiPayload = fillApiPayload(serviceProtocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = userCountryCode;
+    apiPayload[configKey::serviceType] = serviceType;
+    apiPayload[configKey::uuid] = installationUuid;
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/config"), apiPayload, responseBody);
+
+    QJsonObject serverConfig;
+    if (errorCode == ErrorCode::NoError) {
+        fillServerConfig(serviceProtocol, apiPayloadData, responseBody, serverConfig);
+
+        QJsonObject apiConfig = serverConfig.value(configKey::apiConfig).toObject();
+        apiConfig.insert(configKey::userCountryCode, m_apiServicesModel->getCountryCode());
+        apiConfig.insert(configKey::serviceType, m_apiServicesModel->getSelectedServiceType());
+        apiConfig.insert(configKey::serviceProtocol, m_apiServicesModel->getSelectedServiceProtocol());
+
+        serverConfig.insert(configKey::apiConfig, apiConfig);
+
+        m_serversModel->addServer(serverConfig);
+        emit installServerFromApiFinished(tr("%1 installed successfully.").arg(m_apiServicesModel->getSelectedServiceName()));
+        return true;
+    } else {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+}
+
+bool ApiConfigsController::updateServiceFromGateway(const int serverIndex, const QString &newCountryCode, const QString &newCountryName,
+                                                    bool reloadServiceConfig)
+{
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverConfig = m_serversModel->getServerConfig(serverIndex);
+    auto apiConfig = serverConfig.value(configKey::apiConfig).toObject();
+    auto authData = serverConfig.value(configKey::authData).toObject();
+
+    auto installationUuid = m_settings->getInstallationUuid(true);
+    auto userCountryCode = apiConfig.value(configKey::userCountryCode).toString();
+    auto serviceType = apiConfig.value(configKey::serviceType).toString();
+    auto serviceProtocol = apiConfig.value(configKey::serviceProtocol).toString();
+
+    ApiPayloadData apiPayloadData = generateApiPayloadData(serviceProtocol);
+
+    QJsonObject apiPayload = fillApiPayload(serviceProtocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = userCountryCode;
+    apiPayload[configKey::serviceType] = serviceType;
+    apiPayload[configKey::uuid] = installationUuid;
+
+    if (!newCountryCode.isEmpty()) {
+        apiPayload[configKey::serverCountryCode] = newCountryCode;
+    }
+    if (!authData.isEmpty()) {
+        apiPayload[configKey::authData] = authData;
+    }
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/config"), apiPayload, responseBody);
+
+    QJsonObject newServerConfig;
+    if (errorCode == ErrorCode::NoError) {
+        fillServerConfig(serviceProtocol, apiPayloadData, responseBody, newServerConfig);
+
+        QJsonObject newApiConfig = newServerConfig.value(configKey::apiConfig).toObject();
+        newApiConfig.insert(configKey::userCountryCode, apiConfig.value(configKey::userCountryCode));
+        newApiConfig.insert(configKey::serviceType, apiConfig.value(configKey::serviceType));
+        newApiConfig.insert(configKey::serviceProtocol, apiConfig.value(configKey::serviceProtocol));
+        newApiConfig.insert(apiDefs::key::vpnKey, apiConfig.value(apiDefs::key::vpnKey));
+
+        newServerConfig.insert(configKey::apiConfig, newApiConfig);
+        newServerConfig.insert(configKey::authData, authData);
+
+        m_serversModel->editServer(newServerConfig, serverIndex);
+        if (reloadServiceConfig) {
+            emit reloadServerFromApiFinished(tr("API config reloaded"));
+        } else if (newCountryName.isEmpty()) {
+            emit updateServerFromApiFinished();
+        } else {
+            emit changeApiCountryFinished(tr("Successfully changed the country of connection to %1").arg(newCountryName));
+        }
+        return true;
+    } else {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+}
+
+bool ApiConfigsController::updateServiceFromTelegram(const int serverIndex)
+{
+#ifdef Q_OS_IOS
+    IosController::Instance()->requestInetAccess();
+    QThread::msleep(10);
+#endif
+
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverConfig = m_serversModel->getServerConfig(serverIndex);
+    auto installationUuid = m_settings->getInstallationUuid(true);
+
+    QString serviceProtocol = serverConfig.value(configKey::protocol).toString();
+    ApiPayloadData apiPayloadData = generateApiPayloadData(serviceProtocol);
+
+    QJsonObject apiPayload = fillApiPayload(serviceProtocol, apiPayloadData);
+    apiPayload[configKey::uuid] = installationUuid;
+    apiPayload[configKey::accessToken] = serverConfig.value(configKey::accessToken).toString();
+    apiPayload[configKey::apiEndpoint] = serverConfig.value(configKey::apiEndpoint).toString();
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/proxy_config"), apiPayload, responseBody);
+
+    if (errorCode == ErrorCode::NoError) {
+        fillServerConfig(serviceProtocol, apiPayloadData, responseBody, serverConfig);
+
+        m_serversModel->editServer(serverConfig, serverIndex);
+        emit updateServerFromApiFinished();
+        return true;
+    } else {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+}
+
+bool ApiConfigsController::deactivateDevice()
+{
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverIndex = m_serversModel->getProcessedServerIndex();
+    auto serverConfigObject = m_serversModel->getServerConfig(serverIndex);
+    auto apiConfigObject = serverConfigObject.value(configKey::apiConfig).toObject();
+
+    if (apiUtils::getConfigType(serverConfigObject) != apiDefs::ConfigType::AmneziaPremiumV2) {
+        return true;
+    }
+
+    QString protocol = apiConfigObject.value(configKey::serviceProtocol).toString();
+    ApiPayloadData apiPayloadData = generateApiPayloadData(protocol);
+
+    QJsonObject apiPayload = fillApiPayload(protocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = apiConfigObject.value(configKey::userCountryCode);
+    apiPayload[configKey::serverCountryCode] = apiConfigObject.value(configKey::serverCountryCode);
+    apiPayload[configKey::serviceType] = apiConfigObject.value(configKey::serviceType);
+    apiPayload[configKey::authData] = serverConfigObject.value(configKey::authData);
+    apiPayload[configKey::uuid] = m_settings->getInstallationUuid(true);
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/revoke_config"), apiPayload, responseBody);
+    if (errorCode != ErrorCode::NoError && errorCode != ErrorCode::ApiNotFoundError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    serverConfigObject.remove(config_key::containers);
+    m_serversModel->editServer(serverConfigObject, serverIndex);
+
+    return true;
+}
+
+bool ApiConfigsController::deactivateExternalDevice(const QString &uuid, const QString &serverCountryCode)
+{
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs);
+
+    auto serverIndex = m_serversModel->getProcessedServerIndex();
+    auto serverConfigObject = m_serversModel->getServerConfig(serverIndex);
+    auto apiConfigObject = serverConfigObject.value(configKey::apiConfig).toObject();
+
+    if (apiUtils::getConfigType(serverConfigObject) != apiDefs::ConfigType::AmneziaPremiumV2) {
+        return true;
+    }
+
+    QString protocol = apiConfigObject.value(configKey::serviceProtocol).toString();
+    ApiPayloadData apiPayloadData = generateApiPayloadData(protocol);
+
+    QJsonObject apiPayload = fillApiPayload(protocol, apiPayloadData);
+    apiPayload[configKey::userCountryCode] = apiConfigObject.value(configKey::userCountryCode);
+    apiPayload[configKey::serverCountryCode] = serverCountryCode;
+    apiPayload[configKey::serviceType] = apiConfigObject.value(configKey::serviceType);
+    apiPayload[configKey::authData] = serverConfigObject.value(configKey::authData);
+    apiPayload[configKey::uuid] = uuid;
+
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(QString("%1v1/revoke_config"), apiPayload, responseBody);
+    if (errorCode != ErrorCode::NoError && errorCode != ErrorCode::ApiNotFoundError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    if (uuid == m_settings->getInstallationUuid(true)) {
+        serverConfigObject.remove(config_key::containers);
+        m_serversModel->editServer(serverConfigObject, serverIndex);
+    }
+
+    return true;
+}
+
+bool ApiConfigsController::isConfigValid()
+{
+    int serverIndex = m_serversModel->getDefaultServerIndex();
+    QJsonObject serverConfigObject = m_serversModel->getServerConfig(serverIndex);
+    auto configSource = apiUtils::getConfigSource(serverConfigObject);
+
+    if (configSource == apiDefs::ConfigSource::Telegram
+        && !m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
+        m_serversModel->removeApiConfig(serverIndex);
+        return updateServiceFromTelegram(serverIndex);
+    } else if (configSource == apiDefs::ConfigSource::AmneziaGateway
+               && !m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
+        return updateServiceFromGateway(serverIndex, "", "");
+    } else if (configSource && m_serversModel->isApiKeyExpired(serverIndex)) {
+        qDebug() << "attempt to update api config by expires_at event";
+        if (configSource == apiDefs::ConfigSource::AmneziaGateway) {
+            return updateServiceFromGateway(serverIndex, "", "");
+        } else {
+            m_serversModel->removeApiConfig(serverIndex);
+            return updateServiceFromTelegram(serverIndex);
+        }
+    }
+    return true;
+}
+
+ApiConfigsController::ApiPayloadData ApiConfigsController::generateApiPayloadData(const QString &protocol)
+{
+    ApiConfigsController::ApiPayloadData apiPayload;
+    if (protocol == configKey::cloak) {
+        apiPayload.certRequest = OpenVpnConfigurator::createCertRequest();
+    } else if (protocol == configKey::awg) {
+        auto connData = WireguardConfigurator::genClientKeys();
+        apiPayload.wireGuardClientPubKey = connData.clientPubKey;
+        apiPayload.wireGuardClientPrivKey = connData.clientPrivKey;
+    }
+    return apiPayload;
+}
+
+QJsonObject ApiConfigsController::fillApiPayload(const QString &protocol, const ApiPayloadData &apiPayloadData)
+{
+    QJsonObject obj;
+    if (protocol == configKey::cloak) {
+        obj[configKey::certificate] = apiPayloadData.certRequest.request;
+    } else if (protocol == configKey::awg) {
+        obj[configKey::publicKey] = apiPayloadData.wireGuardClientPubKey;
+    }
+
+    obj[configKey::osVersion] = QSysInfo::productType();
+    obj[configKey::appVersion] = QString(APP_VERSION);
+
+    return obj;
+}
+
+void ApiConfigsController::fillServerConfig(const QString &protocol, const ApiPayloadData &apiPayloadData,
+                                            const QByteArray &apiResponseBody, QJsonObject &serverConfig)
+{
+    QString data = QJsonDocument::fromJson(apiResponseBody).object().value(config_key::config).toString();
+
+    data.replace("vpn://", "");
+    QByteArray ba = QByteArray::fromBase64(data.toUtf8(), QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+
+    if (ba.isEmpty()) {
+        emit errorOccurred(ErrorCode::ApiConfigEmptyError);
+        return;
+    }
+
+    QByteArray ba_uncompressed = qUncompress(ba);
+    if (!ba_uncompressed.isEmpty()) {
+        ba = ba_uncompressed;
+    }
+
+    QString configStr = ba;
+    if (protocol == configKey::cloak) {
+        configStr.replace("<key>", "<key>\n");
+        configStr.replace("$OPENVPN_PRIV_KEY", apiPayloadData.certRequest.privKey);
+    } else if (protocol == configKey::awg) {
+        configStr.replace("$WIREGUARD_CLIENT_PRIVATE_KEY", apiPayloadData.wireGuardClientPrivKey);
+        auto newServerConfig = QJsonDocument::fromJson(configStr.toUtf8()).object();
+        auto containers = newServerConfig.value(config_key::containers).toArray();
+        if (containers.isEmpty()) {
+            return; // todo process error
+        }
+        auto container = containers.at(0).toObject();
+        QString containerName = ContainerProps::containerTypeToString(DockerContainer::Awg);
+        auto containerConfig = container.value(containerName).toObject();
+        auto protocolConfig = QJsonDocument::fromJson(containerConfig.value(config_key::last_config).toString().toUtf8()).object();
+        containerConfig[config_key::junkPacketCount] = protocolConfig.value(config_key::junkPacketCount);
+        containerConfig[config_key::junkPacketMinSize] = protocolConfig.value(config_key::junkPacketMinSize);
+        containerConfig[config_key::junkPacketMaxSize] = protocolConfig.value(config_key::junkPacketMaxSize);
+        containerConfig[config_key::initPacketJunkSize] = protocolConfig.value(config_key::initPacketJunkSize);
+        containerConfig[config_key::responsePacketJunkSize] = protocolConfig.value(config_key::responsePacketJunkSize);
+        containerConfig[config_key::initPacketMagicHeader] = protocolConfig.value(config_key::initPacketMagicHeader);
+        containerConfig[config_key::responsePacketMagicHeader] = protocolConfig.value(config_key::responsePacketMagicHeader);
+        containerConfig[config_key::underloadPacketMagicHeader] = protocolConfig.value(config_key::underloadPacketMagicHeader);
+        containerConfig[config_key::transportPacketMagicHeader] = protocolConfig.value(config_key::transportPacketMagicHeader);
+        container[containerName] = containerConfig;
+        containers.replace(0, container);
+        newServerConfig[config_key::containers] = containers;
+        configStr = QString(QJsonDocument(newServerConfig).toJson());
+    }
+
+    QJsonObject newServerConfig = QJsonDocument::fromJson(configStr.toUtf8()).object();
+    serverConfig[config_key::dns1] = newServerConfig.value(config_key::dns1);
+    serverConfig[config_key::dns2] = newServerConfig.value(config_key::dns2);
+    serverConfig[config_key::containers] = newServerConfig.value(config_key::containers);
+    serverConfig[config_key::hostName] = newServerConfig.value(config_key::hostName);
+
+    if (newServerConfig.value(config_key::configVersion).toInt() == apiDefs::ConfigSource::AmneziaGateway) {
+        serverConfig[config_key::configVersion] = newServerConfig.value(config_key::configVersion);
+        serverConfig[config_key::description] = newServerConfig.value(config_key::description);
+        serverConfig[config_key::name] = newServerConfig.value(config_key::name);
+    }
+
+    auto defaultContainer = newServerConfig.value(config_key::defaultContainer).toString();
+    serverConfig[config_key::defaultContainer] = defaultContainer;
+
+    QVariantMap map = serverConfig.value(configKey::apiConfig).toObject().toVariantMap();
+    map.insert(newServerConfig.value(configKey::apiConfig).toObject().toVariantMap());
+    auto apiConfig = QJsonObject::fromVariantMap(map);
+
+    if (newServerConfig.value(config_key::configVersion).toInt() == apiDefs::ConfigSource::AmneziaGateway) {
+        apiConfig.insert(configKey::serviceInfo, QJsonDocument::fromJson(apiResponseBody).object().value(configKey::serviceInfo).toObject());
+    }
+
+    serverConfig[configKey::apiConfig] = apiConfig;
+
+    return;
+}
+
+QList<QString> ApiConfigsController::getQrCodes()
+{
+    return m_qrCodes;
+}
+
+int ApiConfigsController::getQrCodesCount()
+{
+    return m_qrCodes.size();
+}
+
+QString ApiConfigsController::getVpnKey()
+{
+    return m_vpnKey;
+}
--- a/client/ui/controllers/api/apiConfigsController.h
+++ b/client/ui/controllers/api/apiConfigsController.h
@ -0,0 +1,74 @@
+#ifndef APICONFIGSCONTROLLER_H
+#define APICONFIGSCONTROLLER_H
+
+#include <QObject>
+
+#include "configurators/openvpn_configurator.h"
+#include "ui/models/api/apiServicesModel.h"
+#include "ui/models/servers_model.h"
+
+class ApiConfigsController : public QObject
+{
+    Q_OBJECT
+public:
+    ApiConfigsController(const QSharedPointer<ServersModel> &serversModel, const QSharedPointer<ApiServicesModel> &apiServicesModel,
+                         const std::shared_ptr<Settings> &settings, QObject *parent = nullptr);
+
+    Q_PROPERTY(QList<QString> qrCodes READ getQrCodes NOTIFY vpnKeyExportReady)
+    Q_PROPERTY(int qrCodesCount READ getQrCodesCount NOTIFY vpnKeyExportReady)
+    Q_PROPERTY(QString vpnKey READ getVpnKey NOTIFY vpnKeyExportReady)
+
+public slots:
+    bool exportNativeConfig(const QString &serverCountryCode, const QString &fileName);
+    bool revokeNativeConfig(const QString &serverCountryCode);
+    // bool exportVpnKey(const QString &fileName);
+    void prepareVpnKeyExport();
+    void copyVpnKeyToClipboard();
+
+    bool fillAvailableServices();
+    bool importServiceFromGateway();
+    bool updateServiceFromGateway(const int serverIndex, const QString &newCountryCode, const QString &newCountryName,
+                                  bool reloadServiceConfig = false);
+    bool updateServiceFromTelegram(const int serverIndex);
+    bool deactivateDevice();
+    bool deactivateExternalDevice(const QString &uuid, const QString &serverCountryCode);
+
+    bool isConfigValid();
+
+signals:
+    void errorOccurred(ErrorCode errorCode);
+
+    void installServerFromApiFinished(const QString &message);
+    void changeApiCountryFinished(const QString &message);
+    void reloadServerFromApiFinished(const QString &message);
+    void updateServerFromApiFinished();
+
+    void vpnKeyExportReady();
+
+private:
+    struct ApiPayloadData
+    {
+        OpenVpnConfigurator::ConnectionData certRequest;
+
+        QString wireGuardClientPrivKey;
+        QString wireGuardClientPubKey;
+    };
+
+    ApiPayloadData generateApiPayloadData(const QString &protocol);
+    QJsonObject fillApiPayload(const QString &protocol, const ApiPayloadData &apiPayloadData);
+    void fillServerConfig(const QString &protocol, const ApiPayloadData &apiPayloadData, const QByteArray &apiResponseBody,
+                          QJsonObject &serverConfig);
+
+    QList<QString> getQrCodes();
+    int getQrCodesCount();
+    QString getVpnKey();
+
+    QList<QString> m_qrCodes;
+    QString m_vpnKey;
+
+    QSharedPointer<ServersModel> m_serversModel;
+    QSharedPointer<ApiServicesModel> m_apiServicesModel;
+    std::shared_ptr<Settings> m_settings;
+};
+
+#endif // APICONFIGSCONTROLLER_H
--- a/client/ui/controllers/api/apiSettingsController.cpp
+++ b/client/ui/controllers/api/apiSettingsController.cpp
@ -0,0 +1,93 @@
+#include "apiSettingsController.h"
+
+#include <QEventLoop>
+#include <QTimer>
+
+#include "core/api/apiUtils.h"
+#include "core/controllers/gatewayController.h"
+
+namespace
+{
+    namespace configKey
+    {
+        constexpr char userCountryCode[] = "user_country_code";
+        constexpr char serverCountryCode[] = "server_country_code";
+        constexpr char serviceType[] = "service_type";
+        constexpr char serviceInfo[] = "service_info";
+
+        constexpr char apiConfig[] = "api_config";
+        constexpr char authData[] = "auth_data";
+    }
+
+    const int requestTimeoutMsecs = 12 * 1000; // 12 secs
+}
+
+ApiSettingsController::ApiSettingsController(const QSharedPointer<ServersModel> &serversModel,
+                                             const QSharedPointer<ApiAccountInfoModel> &apiAccountInfoModel,
+                                             const QSharedPointer<ApiCountryModel> &apiCountryModel,
+                                             const QSharedPointer<ApiDevicesModel> &apiDevicesModel,
+                                             const std::shared_ptr<Settings> &settings, QObject *parent)
+    : QObject(parent),
+      m_serversModel(serversModel),
+      m_apiAccountInfoModel(apiAccountInfoModel),
+      m_apiCountryModel(apiCountryModel),
+      m_apiDevicesModel(apiDevicesModel),
+      m_settings(settings)
+{
+}
+
+ApiSettingsController::~ApiSettingsController()
+{
+}
+
+bool ApiSettingsController::getAccountInfo(bool reload)
+{
+    if (reload) {
+        QEventLoop wait;
+        QTimer::singleShot(1000, &wait, &QEventLoop::quit);
+        wait.exec();
+    }
+
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), requestTimeoutMsecs);
+
+    auto processedIndex = m_serversModel->getProcessedServerIndex();
+    auto serverConfig = m_serversModel->getServerConfig(processedIndex);
+    auto apiConfig = serverConfig.value(configKey::apiConfig).toObject();
+    auto authData = serverConfig.value(configKey::authData).toObject();
+
+    QJsonObject apiPayload;
+    apiPayload[configKey::userCountryCode] = apiConfig.value(configKey::userCountryCode).toString();
+    apiPayload[configKey::serviceType] = apiConfig.value(configKey::serviceType).toString();
+    apiPayload[configKey::authData] = authData;
+
+    QByteArray responseBody;
+
+    if (apiUtils::getConfigType(serverConfig) == apiDefs::ConfigType::AmneziaPremiumV2) {
+        ErrorCode errorCode = gatewayController.post(QString("%1v1/account_info"), apiPayload, responseBody);
+        if (errorCode != ErrorCode::NoError) {
+            emit errorOccurred(errorCode);
+            return false;
+        }
+    }
+
+    QJsonObject accountInfo = QJsonDocument::fromJson(responseBody).object();
+    m_apiAccountInfoModel->updateModel(accountInfo, serverConfig);
+
+    if (reload) {
+        updateApiCountryModel();
+        updateApiDevicesModel();
+    }
+
+    return true;
+}
+
+void ApiSettingsController::updateApiCountryModel()
+{
+    m_apiCountryModel->updateModel(m_apiAccountInfoModel->getAvailableCountries(), "");
+    m_apiCountryModel->updateIssuedConfigsInfo(m_apiAccountInfoModel->getIssuedConfigsInfo());
+}
+
+void ApiSettingsController::updateApiDevicesModel()
+{
+    m_apiDevicesModel->updateModel(m_apiAccountInfoModel->getIssuedConfigsInfo());
+}
--- a/client/ui/controllers/api/apiSettingsController.h
+++ b/client/ui/controllers/api/apiSettingsController.h
@ -0,0 +1,37 @@
+#ifndef APISETTINGSCONTROLLER_H
+#define APISETTINGSCONTROLLER_H
+
+#include <QObject>
+
+#include "ui/models/api/apiAccountInfoModel.h"
+#include "ui/models/api/apiCountryModel.h"
+#include "ui/models/api/apiDevicesModel.h"
+#include "ui/models/servers_model.h"
+
+class ApiSettingsController : public QObject
+{
+    Q_OBJECT
+public:
+    ApiSettingsController(const QSharedPointer<ServersModel> &serversModel, const QSharedPointer<ApiAccountInfoModel> &apiAccountInfoModel,
+                          const QSharedPointer<ApiCountryModel> &apiCountryModel, const QSharedPointer<ApiDevicesModel> &apiDevicesModel,
+                          const std::shared_ptr<Settings> &settings, QObject *parent = nullptr);
+    ~ApiSettingsController();
+
+public slots:
+    bool getAccountInfo(bool reload);
+    void updateApiCountryModel();
+    void updateApiDevicesModel();
+
+signals:
+    void errorOccurred(ErrorCode errorCode);
+
+private:
+    QSharedPointer<ServersModel> m_serversModel;
+    QSharedPointer<ApiAccountInfoModel> m_apiAccountInfoModel;
+    QSharedPointer<ApiCountryModel> m_apiCountryModel;
+    QSharedPointer<ApiDevicesModel> m_apiDevicesModel;
+
+    std::shared_ptr<Settings> m_settings;
+};
+
+#endif // APISETTINGSCONTROLLER_H
--- a/client/ui/controllers/connectionController.cpp
+++ b/client/ui/controllers/connectionController.cpp
@ -5,10 +5,8 @@
 #else
    #include <QApplication>
 #endif
-#include <QtConcurrent>

 #include "core/controllers/vpnConfigurationController.h"
-#include "core/errorstrings.h"
 #include "version.h"

 ConnectionController::ConnectionController(const QSharedPointer<ServersModel> &serversModel,
@ -17,7 +15,6 @@ ConnectionController::ConnectionController(const QSharedPointer<ServersModel> &s
                                           const QSharedPointer<VpnConnection> &vpnConnection, const std::shared_ptr<Settings> &settings,
                                           QObject *parent)
    : QObject(parent),
-      m_apiController(this),
      m_serversModel(serversModel),
      m_containersModel(containersModel),
      m_clientManagementModel(clientManagementModel),
@ -28,9 +25,7 @@ ConnectionController::ConnectionController(const QSharedPointer<ServersModel> &s
    connect(this, &ConnectionController::connectToVpn, m_vpnConnection.get(), &VpnConnection::connectToVpn, Qt::QueuedConnection);
    connect(this, &ConnectionController::disconnectFromVpn, m_vpnConnection.get(), &VpnConnection::disconnectFromVpn, Qt::QueuedConnection);

-    connect(&m_apiController, &ApiController::configUpdated, this,
-            static_cast<void (ConnectionController::*)(const bool, const QJsonObject &, const int)>(&ConnectionController::openConnection));
-    connect(&m_apiController, &ApiController::errorOccurred, this, &ConnectionController::connectionErrorOccurred);
+    connect(this, &ConnectionController::connectButtonClicked, this, &ConnectionController::toggleConnection, Qt::QueuedConnection);

    m_state = Vpn::ConnectionState::Disconnected;
 }
@ -38,9 +33,8 @@ ConnectionController::ConnectionController(const QSharedPointer<ServersModel> &s
 void ConnectionController::openConnection()
 {
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
-    if (!Utils::processIsRunning(Utils::executable(SERVICE_NAME, false), true))
-    {
-        emit connectionErrorOccurred(errorString(ErrorCode::AmneziaServiceNotRunning));
+    if (!Utils::processIsRunning(Utils::executable(SERVICE_NAME, false), true)) {
+        emit connectionErrorOccurred(ErrorCode::AmneziaServiceNotRunning);
        return;
    }
 #endif
@ -48,14 +42,23 @@ void ConnectionController::openConnection()
    int serverIndex = m_serversModel->getDefaultServerIndex();
    QJsonObject serverConfig = m_serversModel->getServerConfig(serverIndex);

-    emit m_vpnConnection->connectionStateChanged(Vpn::ConnectionState::Preparing);
+    DockerContainer container = qvariant_cast<DockerContainer>(m_serversModel->data(serverIndex, ServersModel::Roles::DefaultContainerRole));

-    if (serverConfig.value(config_key::configVersion).toInt()
-        && !m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
-        m_apiController.updateServerConfigFromApi(m_settings->getInstallationUuid(true), serverIndex, serverConfig);
-    } else {
-        openConnection(false, serverConfig, serverIndex);
+    if (!m_containersModel->isSupportedByCurrentPlatform(container)) {
+        emit connectionErrorOccurred(ErrorCode::NotSupportedOnThisPlatform);
+        return;
    }
+
+    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
+    VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
+
+    QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
+    ServerCredentials credentials = m_serversModel->getServerCredentials(serverIndex);
+
+    auto dns = m_serversModel->getDnsPair(serverIndex);
+
+    auto vpnConfiguration = vpnConfigurationController.createVpnConfiguration(dns, serverConfig, containerConfig, container);
+    emit connectToVpn(serverIndex, credentials, container, vpnConfiguration);
 }

 void ConnectionController::closeConnection()
@ -63,9 +66,9 @@ void ConnectionController::closeConnection()
    emit disconnectFromVpn();
 }

-QString ConnectionController::getLastConnectionError()
+ErrorCode ConnectionController::getLastConnectionError()
 {
-    return errorString(m_vpnConnection->lastError());
+    return m_vpnConnection->lastError();
 }

 void ConnectionController::onConnectionStateChanged(Vpn::ConnectionState state)
@ -124,7 +127,7 @@ void ConnectionController::onConnectionStateChanged(Vpn::ConnectionState state)
 void ConnectionController::onCurrentContainerUpdated()
 {
    if (m_isConnected || m_isConnectionInProgress) {
-        emit reconnectWithUpdatedContainer(tr("Settings updated successfully, Reconnnection..."));
+        emit reconnectWithUpdatedContainer(tr("Settings updated successfully, reconnnection..."));
        openConnection();
    } else {
        emit reconnectWithUpdatedContainer(tr("Settings updated successfully"));
@ -159,7 +162,7 @@ void ConnectionController::toggleConnection()
    } else if (isConnected()) {
        closeConnection();
    } else {
-        openConnection();
+        emit prepareConfig();
    }
 }

@ -172,99 +175,3 @@ bool ConnectionController::isConnected() const
 {
    return m_isConnected;
 }
-
-bool ConnectionController::isProtocolConfigExists(const QJsonObject &containerConfig, const DockerContainer container)
-{
-    for (Proto protocol : ContainerProps::protocolsForContainer(container)) {
-        QString protocolConfig =
-                containerConfig.value(ProtocolProps::protoToString(protocol)).toObject().value(config_key::last_config).toString();
-
-        if (protocolConfig.isEmpty()) {
-            return false;
-        }
-    }
-    return true;
-}
-
-void ConnectionController::openConnection(const bool updateConfig, const QJsonObject &config, const int serverIndex)
-{
-    // Update config for this server as it was received from API
-    if (updateConfig) {
-        m_serversModel->editServer(config, serverIndex);
-    }
-
-    if (!m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
-        emit noInstalledContainers();
-        emit m_vpnConnection->connectionStateChanged(Vpn::ConnectionState::Disconnected);
-        return;
-    }
-
-    DockerContainer container = qvariant_cast<DockerContainer>(m_serversModel->data(serverIndex, ServersModel::Roles::DefaultContainerRole));
-
-    if (!m_containersModel->isSupportedByCurrentPlatform(container)) {
-        emit connectionErrorOccurred(tr("The selected protocol is not supported on the current platform"));
-        return;
-    }
-
-    if (container == DockerContainer::None) {
-        emit connectionErrorOccurred(tr("VPN Protocols is not installed.\n Please install VPN container at first"));
-        return;
-    }
-
-    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
-    VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
-
-    QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
-    ServerCredentials credentials = m_serversModel->getServerCredentials(serverIndex);
-    ErrorCode errorCode = updateProtocolConfig(container, credentials, containerConfig, serverController);
-    if (errorCode != ErrorCode::NoError) {
-        emit connectionErrorOccurred(errorString(errorCode));
-        return;
-    }
-
-    auto dns = m_serversModel->getDnsPair(serverIndex);
-
-    auto vpnConfiguration = vpnConfigurationController.createVpnConfiguration(dns, config, containerConfig, container, errorCode);
-    if (errorCode != ErrorCode::NoError) {
-        emit connectionErrorOccurred(tr("unable to create configuration"));
-        return;
-    }
-
-    emit connectToVpn(serverIndex, credentials, container, vpnConfiguration);
-}
-
-ErrorCode ConnectionController::updateProtocolConfig(const DockerContainer container, const ServerCredentials &credentials,
-                                                     QJsonObject &containerConfig, QSharedPointer<ServerController> serverController)
-{
-    QFutureWatcher<ErrorCode> watcher;
-
-    if (serverController.isNull()) {
-        serverController.reset(new ServerController(m_settings));
-    }
-
-    QFuture<ErrorCode> future = QtConcurrent::run([this, container, &credentials, &containerConfig, &serverController]() {
-        ErrorCode errorCode = ErrorCode::NoError;
-        if (!isProtocolConfigExists(containerConfig, container)) {
-            VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
-            errorCode = vpnConfigurationController.createProtocolConfigForContainer(credentials, container, containerConfig);
-            if (errorCode != ErrorCode::NoError) {
-                return errorCode;
-            }
-            m_serversModel->updateContainerConfig(container, containerConfig);
-
-            errorCode = m_clientManagementModel->appendClient(container, credentials, containerConfig,
-                                                              QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
-            if (errorCode != ErrorCode::NoError) {
-                return errorCode;
-            }
-        }
-        return errorCode;
-    });
-
-    QEventLoop wait;
-    connect(&watcher, &QFutureWatcher<ErrorCode>::finished, &wait, &QEventLoop::quit);
-    watcher.setFuture(future);
-    wait.exec();
-
-    return watcher.result();
-}
--- a/client/ui/controllers/connectionController.h
+++ b/client/ui/controllers/connectionController.h
@ -1,7 +1,6 @@
 #ifndef CONNECTIONCONTROLLER_H
 #define CONNECTIONCONTROLLER_H

-#include "core/controllers/apiController.h"
 #include "protocols/vpnprotocol.h"
 #include "ui/models/clientManagementModel.h"
 #include "ui/models/containers_model.h"
@ -34,36 +33,29 @@ public slots:
    void openConnection();
    void closeConnection();

-    QString getLastConnectionError();
+    ErrorCode getLastConnectionError();
    void onConnectionStateChanged(Vpn::ConnectionState state);

    void onCurrentContainerUpdated();

    void onTranslationsUpdated();

-    ErrorCode updateProtocolConfig(const DockerContainer container, const ServerCredentials &credentials, QJsonObject &containerConfig,
-                                   QSharedPointer<ServerController> serverController = nullptr);
-
 signals:
    void connectToVpn(int serverIndex, const ServerCredentials &credentials, DockerContainer container, const QJsonObject &vpnConfiguration);
    void disconnectFromVpn();
    void connectionStateChanged();

-    void connectionErrorOccurred(const QString &errorMessage);
+    void connectionErrorOccurred(ErrorCode errorCode);
    void reconnectWithUpdatedContainer(const QString &message);

-    void noInstalledContainers();
-
    void connectButtonClicked();
    void preparingConfig();
+    void prepareConfig();

 private:
    Vpn::ConnectionState getCurrentConnectionState();
-    bool isProtocolConfigExists(const QJsonObject &containerConfig, const DockerContainer container);

-    void openConnection(const bool updateConfig, const QJsonObject &config, const int serverIndex);
-
-    ApiController m_apiController;
+    void continueConnection();

    QSharedPointer<ServersModel> m_serversModel;
    QSharedPointer<ContainersModel> m_containersModel;
--- a/client/ui/controllers/exportController.cpp
+++ b/client/ui/controllers/exportController.cpp
@ -9,12 +9,8 @@
 #include <QStandardPaths>

 #include "core/controllers/vpnConfigurationController.h"
-#include "core/errorstrings.h"
+#include "core/qrCodeUtils.h"
 #include "systemController.h"
-#ifdef Q_OS_ANDROID
-    #include "platforms/android/android_utils.h"
-#endif
-#include "qrcodegen.hpp"

 ExportController::ExportController(const QSharedPointer<ServersModel> &serversModel, const QSharedPointer<ContainersModel> &containersModel,
                                   const QSharedPointer<ClientManagementModel> &clientManagementModel,
@ -25,12 +21,6 @@ ExportController::ExportController(const QSharedPointer<ServersModel> &serversMo
      m_clientManagementModel(clientManagementModel),
      m_settings(settings)
 {
-#ifdef Q_OS_ANDROID
-    m_authResultNotifier.reset(new AuthResultNotifier);
-    m_authResultReceiver.reset(new AuthResultReceiver(m_authResultNotifier));
-    connect(m_authResultNotifier.get(), &AuthResultNotifier::authFailed, this, [this]() { emit exportErrorOccurred(tr("Access error!")); });
-    connect(m_authResultNotifier.get(), &AuthResultNotifier::authSuccessful, this, &ExportController::generateFullAccessConfig);
-#endif
 }

 void ExportController::generateFullAccessConfig()
@ -60,30 +50,10 @@ void ExportController::generateFullAccessConfig()
    compressedConfig = qCompress(compressedConfig, 8);
    m_config = QString("vpn://%1").arg(QString(compressedConfig.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals)));

-    m_qrCodes = generateQrCodeImageSeries(compressedConfig);
+    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(compressedConfig);
    emit exportConfigChanged();
 }

-#if defined(Q_OS_ANDROID)
-void ExportController::generateFullAccessConfigAndroid()
-{
-    /* We use builtin keyguard for ssh key export protection on Android */
-    QJniObject activity = AndroidUtils::getActivity();
-    auto appContext = activity.callObjectMethod("getApplicationContext", "()Landroid/content/Context;");
-    if (appContext.isValid()) {
-        auto intent = QJniObject::callStaticObjectMethod("org/amnezia/vpn/AuthHelper", "getAuthIntent",
-                                                         "(Landroid/content/Context;)Landroid/content/Intent;", appContext.object());
-        if (intent.isValid()) {
-            if (intent.object<jobject>() != nullptr) {
-                QtAndroidPrivate::startActivity(intent.object<jobject>(), 1, m_authResultReceiver.get());
-            }
-        } else {
-            generateFullAccessConfig();
-        }
-    }
-}
-#endif
-
 void ExportController::generateConnectionConfig(const QString &clientName)
 {
    clearPreviousConfig();
@ -101,7 +71,7 @@ void ExportController::generateConnectionConfig(const QString &clientName)

    errorCode = m_clientManagementModel->appendClient(container, credentials, containerConfig, clientName, serverController);
    if (errorCode != ErrorCode::NoError) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -122,7 +92,7 @@ void ExportController::generateConnectionConfig(const QString &clientName)
    compressedConfig = qCompress(compressedConfig, 8);
    m_config = QString("vpn://%1").arg(QString(compressedConfig.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals)));

-    m_qrCodes = generateQrCodeImageSeries(compressedConfig);
+    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(compressedConfig);
    emit exportConfigChanged();
 }

@ -134,7 +104,7 @@ ErrorCode ExportController::generateNativeConfig(const DockerContainer container
    int serverIndex = m_serversModel->getProcessedServerIndex();
    ServerCredentials credentials = m_serversModel->getServerCredentials(serverIndex);
    auto dns = m_serversModel->getDnsPair(serverIndex);
-    bool isApiConfig = qvariant_cast<bool>(m_serversModel->data(serverIndex, ServersModel::IsServerFromApiRole));
+    bool isApiConfig = qvariant_cast<bool>(m_serversModel->data(serverIndex, ServersModel::IsServerFromTelegramApiRole));

    QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
    containerConfig.insert(config_key::container, ContainerProps::containerToString(container));
@ -151,9 +121,8 @@ ErrorCode ExportController::generateNativeConfig(const DockerContainer container

    jsonNativeConfig = QJsonDocument::fromJson(protocolConfigString.toUtf8()).object();

-    if (protocol == Proto::OpenVpn || protocol == Proto::WireGuard || protocol == Proto::Awg) {
-        auto clientId = jsonNativeConfig.value(config_key::clientId).toString();
-        errorCode = m_clientManagementModel->appendClient(clientId, clientName, container, credentials, serverController);
+    if (protocol == Proto::OpenVpn || protocol == Proto::WireGuard || protocol == Proto::Awg || protocol == Proto::Xray) {
+        errorCode = m_clientManagementModel->appendClient(jsonNativeConfig, clientName, container, credentials, serverController);
    }
    return errorCode;
 }
@ -171,7 +140,7 @@ void ExportController::generateOpenVpnConfig(const QString &clientName)
    }

    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -180,7 +149,7 @@ void ExportController::generateOpenVpnConfig(const QString &clientName)
        m_config.append(line + "\n");
    }

-    m_qrCodes = generateQrCodeImageSeries(m_config.toUtf8());
+    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(m_config.toUtf8());
    emit exportConfigChanged();
 }

@ -189,7 +158,7 @@ void ExportController::generateWireGuardConfig(const QString &clientName)
    QJsonObject nativeConfig;
    ErrorCode errorCode = generateNativeConfig(DockerContainer::WireGuard, clientName, Proto::WireGuard, nativeConfig);
    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -198,8 +167,8 @@ void ExportController::generateWireGuardConfig(const QString &clientName)
        m_config.append(line + "\n");
    }

-    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(m_config.toUtf8(), qrcodegen::QrCode::Ecc::LOW);
-    m_qrCodes << svgToBase64(QString::fromStdString(toSvgString(qr, 1)));
+    auto qr = qrCodeUtils::generateQrCode(m_config.toUtf8());
+    m_qrCodes << qrCodeUtils::svgToBase64(QString::fromStdString(toSvgString(qr, 1)));

    emit exportConfigChanged();
 }
@ -209,7 +178,7 @@ void ExportController::generateAwgConfig(const QString &clientName)
    QJsonObject nativeConfig;
    ErrorCode errorCode = generateNativeConfig(DockerContainer::Awg, clientName, Proto::Awg, nativeConfig);
    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -218,8 +187,8 @@ void ExportController::generateAwgConfig(const QString &clientName)
        m_config.append(line + "\n");
    }

-    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(m_config.toUtf8(), qrcodegen::QrCode::Ecc::LOW);
-    m_qrCodes << svgToBase64(QString::fromStdString(toSvgString(qr, 1)));
+    auto qr = qrCodeUtils::generateQrCode(m_config.toUtf8());
+    m_qrCodes << qrCodeUtils::svgToBase64(QString::fromStdString(toSvgString(qr, 1)));

    emit exportConfigChanged();
 }
@ -237,7 +206,7 @@ void ExportController::generateShadowSocksConfig()
    }

    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -252,8 +221,8 @@ void ExportController::generateShadowSocksConfig()

    m_nativeConfigString = "ss://" + m_nativeConfigString.toUtf8().toBase64();

-    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(m_nativeConfigString.toUtf8(), qrcodegen::QrCode::Ecc::LOW);
-    m_qrCodes << svgToBase64(QString::fromStdString(toSvgString(qr, 1)));
+    auto qr = qrCodeUtils::generateQrCode(m_nativeConfigString.toUtf8());
+    m_qrCodes << qrCodeUtils::svgToBase64(QString::fromStdString(toSvgString(qr, 1)));

    emit exportConfigChanged();
 }
@ -263,7 +232,7 @@ void ExportController::generateCloakConfig()
    QJsonObject nativeConfig;
    ErrorCode errorCode = generateNativeConfig(DockerContainer::Cloak, "", Proto::Cloak, nativeConfig);
    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -278,12 +247,12 @@ void ExportController::generateCloakConfig()
    emit exportConfigChanged();
 }

-void ExportController::generateXrayConfig()
+void ExportController::generateXrayConfig(const QString &clientName)
 {
    QJsonObject nativeConfig;
-    ErrorCode errorCode = generateNativeConfig(DockerContainer::Xray, "", Proto::Xray, nativeConfig);
+    ErrorCode errorCode = generateNativeConfig(DockerContainer::Xray, clientName, Proto::Xray, nativeConfig);
    if (errorCode) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
        return;
    }

@ -320,7 +289,7 @@ void ExportController::updateClientManagementModel(const DockerContainer contain
    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
    ErrorCode errorCode = m_clientManagementModel->updateModel(container, credentials, serverController);
    if (errorCode != ErrorCode::NoError) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
    }
 }

@ -330,7 +299,7 @@ void ExportController::revokeConfig(const int row, const DockerContainer contain
    ErrorCode errorCode =
            m_clientManagementModel->revokeClient(row, container, credentials, m_serversModel->getProcessedServerIndex(), serverController);
    if (errorCode != ErrorCode::NoError) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
    }
 }

@ -339,36 +308,10 @@ void ExportController::renameClient(const int row, const QString &clientName, co
    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
    ErrorCode errorCode = m_clientManagementModel->renameClient(row, clientName, container, credentials, serverController);
    if (errorCode != ErrorCode::NoError) {
-        emit exportErrorOccurred(errorString(errorCode));
+        emit exportErrorOccurred(errorCode);
    }
 }

-QList<QString> ExportController::generateQrCodeImageSeries(const QByteArray &data)
-{
-    double k = 850;
-
-    quint8 chunksCount = std::ceil(data.size() / k);
-    QList<QString> chunks;
-    for (int i = 0; i < data.size(); i = i + k) {
-        QByteArray chunk;
-        QDataStream s(&chunk, QIODevice::WriteOnly);
-        s << amnezia::qrMagicCode << chunksCount << (quint8)std::round(i / k) << data.mid(i, k);
-
-        QByteArray ba = chunk.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
-
-        qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(ba, qrcodegen::QrCode::Ecc::LOW);
-        QString svg = QString::fromStdString(toSvgString(qr, 1));
-        chunks.append(svgToBase64(svg));
-    }
-
-    return chunks;
-}
-
-QString ExportController::svgToBase64(const QString &image)
-{
-    return "data:image/svg;base64," + QString::fromLatin1(image.toUtf8().toBase64().data());
-}
-
 int ExportController::getQrCodesCount()
 {
    return m_qrCodes.size();
--- a/client/ui/controllers/exportController.h
+++ b/client/ui/controllers/exportController.h
@ -6,9 +6,6 @@
 #include "ui/models/clientManagementModel.h"
 #include "ui/models/containers_model.h"
 #include "ui/models/servers_model.h"
-#ifdef Q_OS_ANDROID
-    #include "platforms/android/authResultReceiver.h"
-#endif

 class ExportController : public QObject
 {
@ -25,16 +22,13 @@ public:

 public slots:
    void generateFullAccessConfig();
-#if defined(Q_OS_ANDROID)
-    void generateFullAccessConfigAndroid();
-#endif
    void generateConnectionConfig(const QString &clientName);
    void generateOpenVpnConfig(const QString &clientName);
    void generateWireGuardConfig(const QString &clientName);
    void generateAwgConfig(const QString &clientName);
    void generateShadowSocksConfig();
    void generateCloakConfig();
-    void generateXrayConfig();
+    void generateXrayConfig(const QString &clientName);

    QString getConfig();
    QString getNativeConfigString();
@ -49,15 +43,13 @@ public slots:
 signals:
    void generateConfig(int type);
    void exportErrorOccurred(const QString &errorMessage);
+    void exportErrorOccurred(ErrorCode errorCode);

    void exportConfigChanged();

    void saveFile(const QString &fileName, const QString &data);

 private:
-    QList<QString> generateQrCodeImageSeries(const QByteArray &data);
-    QString svgToBase64(const QString &image);
-
    int getQrCodesCount();

    void clearPreviousConfig();
@ -73,11 +65,6 @@ private:
    QString m_config;
    QString m_nativeConfigString;
    QList<QString> m_qrCodes;
-
-#ifdef Q_OS_ANDROID
-    QSharedPointer<AuthResultNotifier> m_authResultNotifier;
-    QSharedPointer<QAndroidActivityResultReceiver> m_authResultReceiver;
-#endif
 };

 #endif // EXPORTCONTROLLER_H
--- a/client/ui/controllers/focusController.cpp
+++ b/client/ui/controllers/focusController.cpp
@ -0,0 +1,209 @@
+#include "focusController.h"
+#include "utils/qmlUtils.h"
+
+#include <QQmlApplicationEngine>
+#include <QQuickWindow>
+
+FocusController::FocusController(QQmlApplicationEngine *engine, QObject *parent)
+    : QObject { parent },
+      m_engine { engine },
+      m_focusChain {},
+      m_focusedItem { nullptr },
+      m_rootObjects {},
+      m_defaultFocusItem { nullptr },
+      m_lvfc { nullptr }
+{
+    QObject::connect(m_engine, &QQmlApplicationEngine::objectCreated, this, [this](QObject *object, const QUrl &url) {
+        QQuickItem *newDefaultFocusItem = object->findChild<QQuickItem *>("defaultFocusItem");
+        if (newDefaultFocusItem && m_defaultFocusItem != newDefaultFocusItem) {
+            m_defaultFocusItem = newDefaultFocusItem;
+        }
+    });
+
+    QObject::connect(this, &FocusController::focusedItemChanged, this,
+                     [this]() { m_focusedItem->forceActiveFocus(Qt::TabFocusReason); });
+}
+
+void FocusController::nextKeyTabItem()
+{
+    nextItem(Direction::Forward);
+}
+
+void FocusController::previousKeyTabItem()
+{
+    nextItem(Direction::Backward);
+}
+
+void FocusController::nextKeyUpItem()
+{
+    nextItem(Direction::Backward);
+}
+
+void FocusController::nextKeyDownItem()
+{
+    nextItem(Direction::Forward);
+}
+
+void FocusController::nextKeyLeftItem()
+{
+    nextItem(Direction::Backward);
+}
+
+void FocusController::nextKeyRightItem()
+{
+    nextItem(Direction::Forward);
+}
+
+void FocusController::setFocusItem(QQuickItem *item)
+{
+    if (m_focusedItem != item) {
+        m_focusedItem = item;
+    }
+    emit focusedItemChanged();
+}
+
+void FocusController::setFocusOnDefaultItem()
+{
+    setFocusItem(m_defaultFocusItem);
+}
+
+void FocusController::pushRootObject(QObject *object)
+{
+    m_rootObjects.push(object);
+    dropListView();
+    // setFocusOnDefaultItem();
+}
+
+void FocusController::dropRootObject(QObject *object)
+{
+    if (m_rootObjects.empty()) {
+        return;
+    }
+
+    if (m_rootObjects.top() == object) {
+        m_rootObjects.pop();
+        dropListView();
+        setFocusOnDefaultItem();
+    } else {
+        qWarning() << "===>> TRY TO DROP WRONG ROOT OBJECT: " << m_rootObjects.top() << " SHOULD BE: " << object;
+    }
+}
+
+void FocusController::resetRootObject()
+{
+    m_rootObjects.clear();
+}
+
+void FocusController::reload(Direction direction)
+{
+    m_focusChain.clear();
+
+    QObject *rootObject = (m_rootObjects.empty() ? m_engine->rootObjects().value(0) : m_rootObjects.top());
+
+    if (!rootObject) {
+        qCritical() << "No ROOT OBJECT found!";
+        resetRootObject();
+        dropListView();
+        return;
+    }
+
+    m_focusChain.append(FocusControl::getSubChain(rootObject));
+
+    std::sort(m_focusChain.begin(), m_focusChain.end(),
+              direction == Direction::Forward ? FocusControl::isLess : FocusControl::isMore);
+
+    if (m_focusChain.empty()) {
+        qWarning() << "Focus chain is empty!";
+        resetRootObject();
+        dropListView();
+        return;
+    }
+}
+
+void FocusController::nextItem(Direction direction)
+{
+    reload(direction);
+
+    if (m_lvfc && FocusControl::isListView(m_focusedItem)) {
+        direction == Direction::Forward ? focusNextListViewItem() : focusPreviousListViewItem();
+
+        return;
+    }
+
+    if (m_focusChain.empty()) {
+        qWarning() << "There are no items to navigate";
+        setFocusOnDefaultItem();
+        return;
+    }
+
+    auto focusedItemIndex = m_focusChain.indexOf(m_focusedItem);
+
+    if (focusedItemIndex == -1) {
+        focusedItemIndex = 0;
+    } else if (focusedItemIndex == (m_focusChain.size() - 1)) {
+        focusedItemIndex = 0;
+    } else {
+        focusedItemIndex++;
+    }
+
+    const auto focusedItem = qobject_cast<QQuickItem *>(m_focusChain.at(focusedItemIndex));
+
+    if (focusedItem == nullptr) {
+        qWarning() << "Failed to get item to focus on. Setting focus on default";
+        setFocusOnDefaultItem();
+        return;
+    }
+
+    if (FocusControl::isListView(focusedItem)) {
+        m_lvfc = new ListViewFocusController(focusedItem, this);
+        m_focusedItem = focusedItem;
+        if (direction == Direction::Forward) {
+            m_lvfc->nextDelegate();
+            focusNextListViewItem();
+        } else {
+            m_lvfc->previousDelegate();
+            focusPreviousListViewItem();
+        }
+        return;
+    }
+
+    setFocusItem(focusedItem);
+}
+
+void FocusController::focusNextListViewItem()
+{
+    m_lvfc->reloadFocusChain();
+    if (m_lvfc->isLastFocusItemInListView() || m_lvfc->isReturnNeeded()) {
+        dropListView();
+        nextItem(Direction::Forward);
+        return;
+    } else if (m_lvfc->isLastFocusItemInDelegate()) {
+        m_lvfc->resetFocusChain();
+        m_lvfc->nextDelegate();
+    }
+
+    m_lvfc->focusNextItem();
+}
+
+void FocusController::focusPreviousListViewItem()
+{
+    m_lvfc->reloadFocusChain();
+    if (m_lvfc->isFirstFocusItemInListView() || m_lvfc->isReturnNeeded()) {
+        dropListView();
+        nextItem(Direction::Backward);
+        return;
+    } else if (m_lvfc->isFirstFocusItemInDelegate()) {
+        m_lvfc->resetFocusChain();
+        m_lvfc->previousDelegate();
+    }
+
+    m_lvfc->focusPreviousItem();
+}
+
+void FocusController::dropListView()
+{
+    if (m_lvfc) {
+        delete m_lvfc;
+        m_lvfc = nullptr;
+    }
+}
--- a/client/ui/controllers/focusController.h
+++ b/client/ui/controllers/focusController.h
@ -0,0 +1,57 @@
+#ifndef FOCUSCONTROLLER_H
+#define FOCUSCONTROLLER_H
+
+#include "ui/controllers/listViewFocusController.h"
+
+#include <QQmlApplicationEngine>
+
+/*!
+ * \brief The FocusController class makes focus control more straightforward
+ * \details Focus is handled only for visible and enabled items which have
+ *          `isFocused` property from top left to bottom right.
+ * \note There are items handled differently (e.g. ListView)
+ */
+class FocusController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit FocusController(QQmlApplicationEngine *engine, QObject *parent = nullptr);
+    ~FocusController() override = default;
+
+    Q_INVOKABLE void nextKeyTabItem();
+    Q_INVOKABLE void previousKeyTabItem();
+    Q_INVOKABLE void nextKeyUpItem();
+    Q_INVOKABLE void nextKeyDownItem();
+    Q_INVOKABLE void nextKeyLeftItem();
+    Q_INVOKABLE void nextKeyRightItem();
+    Q_INVOKABLE void setFocusItem(QQuickItem *item);
+    Q_INVOKABLE void setFocusOnDefaultItem();
+    Q_INVOKABLE void pushRootObject(QObject *object);
+    Q_INVOKABLE void dropRootObject(QObject *object);
+    Q_INVOKABLE void resetRootObject();
+
+private:
+    enum class Direction {
+        Forward,
+        Backward,
+    };
+
+    void reload(Direction direction);
+    void nextItem(Direction direction);
+    void focusNextListViewItem();
+    void focusPreviousListViewItem();
+    void dropListView();
+
+    QQmlApplicationEngine *m_engine; // Pointer to engine to get root object
+    QList<QObject *> m_focusChain;   // List of current objects to be focused
+    QQuickItem *m_focusedItem;       // Pointer to the active focus item
+    QStack<QObject *> m_rootObjects; // Pointer to stack of roots for focus chain
+    QQuickItem *m_defaultFocusItem;
+
+    ListViewFocusController *m_lvfc; // ListView focus manager
+
+signals:
+    void focusedItemChanged();
+};
+
+#endif // FOCUSCONTROLLER_H
--- a/client/ui/controllers/importController.cpp
+++ b/client/ui/controllers/importController.cpp
@ -5,8 +5,16 @@
 #include <QQuickItem>
 #include <QRandomGenerator>
 #include <QStandardPaths>
+#include <QUrlQuery>

+#include "core/api/apiDefs.h"
+#include "core/api/apiUtils.h"
 #include "core/errorstrings.h"
+#include "core/qrCodeUtils.h"
+#include "core/serialization/serialization.h"
+#include "systemController.h"
+#include "utilities.h"
+
 #ifdef Q_OS_ANDROID
    #include "platforms/android/android_controller.h"
 #endif
@ -19,8 +27,6 @@ namespace
    ConfigTypes checkConfigFormat(const QString &config)
    {
        const QString openVpnConfigPatternCli = "client";
-        const QString openVpnConfigPatternProto1 = "proto tcp";
-        const QString openVpnConfigPatternProto2 = "proto udp";
        const QString openVpnConfigPatternDriver1 = "dev tun";
        const QString openVpnConfigPatternDriver2 = "dev tap";

@ -35,22 +41,23 @@ namespace
        const QString amneziaConfigPatternUserName = "userName";
        const QString amneziaConfigPatternPassword = "password";
        const QString amneziaFreeConfigPattern = "api_key";
+        const QString amneziaPremiumConfigPattern = "auth_data";
        const QString backupPattern = "Servers/serversList";

        if (config.contains(backupPattern)) {
            return ConfigTypes::Backup;
        } else if (config.contains(amneziaConfigPattern) || config.contains(amneziaFreeConfigPattern)
+                   || config.contains(amneziaPremiumConfigPattern)
                   || (config.contains(amneziaConfigPatternHostName) && config.contains(amneziaConfigPatternUserName)
                       && config.contains(amneziaConfigPatternPassword))) {
            return ConfigTypes::Amnezia;
-        } else if (config.contains(openVpnConfigPatternCli)
-                   && (config.contains(openVpnConfigPatternProto1) || config.contains(openVpnConfigPatternProto2))
-                   && (config.contains(openVpnConfigPatternDriver1) || config.contains(openVpnConfigPatternDriver2))) {
-            return ConfigTypes::OpenVpn;
        } else if (config.contains(wireguardConfigPatternSectionInterface) && config.contains(wireguardConfigPatternSectionPeer)) {
            return ConfigTypes::WireGuard;
        } else if ((config.contains(xrayConfigPatternInbound)) && (config.contains(xrayConfigPatternOutbound))) {
            return ConfigTypes::Xray;
+        } else if (config.contains(openVpnConfigPatternCli)
+            && (config.contains(openVpnConfigPatternDriver1) || config.contains(openVpnConfigPatternDriver2))) {
+            return ConfigTypes::OpenVpn;
        }
        return ConfigTypes::Invalid;
    }
@ -71,29 +78,83 @@ ImportController::ImportController(const QSharedPointer<ServersModel> &serversMo

 bool ImportController::extractConfigFromFile(const QString &fileName)
 {
-    QFile file(fileName);
-
-    if (file.open(QIODevice::ReadOnly)) {
-        QString data = file.readAll();
-
-        m_configFileName = QFileInfo(file.fileName()).fileName();
-        return extractConfigFromData(data);
+    QString data;
+    if (!SystemController::readFile(fileName, data)) {
+        emit importErrorOccurred(ErrorCode::ImportOpenConfigError, false);
+        return false;
    }
-
-    emit importErrorOccurred(tr("Unable to open file"), false);
-    return false;
+    m_configFileName = QFileInfo(QFile(fileName).fileName()).fileName();
+#ifdef Q_OS_ANDROID
+    if (m_configFileName.isEmpty()) {
+        m_configFileName = AndroidController::instance()->getFileName(fileName);
+    }
+#endif
+    return extractConfigFromData(data);
 }

 bool ImportController::extractConfigFromData(QString data)
 {
    QString config = data;
+    QString prefix;
+    QString errormsg;
+
+    if (config.startsWith("vless://")) {
+        m_configType = ConfigTypes::Xray;
+        m_config = extractXrayConfig(
+                Utils::JsonToString(serialization::vless::Deserialize(config, &prefix, &errormsg), QJsonDocument::JsonFormat::Compact),
+                prefix);
+        return m_config.empty() ? false : true;
+    }
+
+    if (config.startsWith("vmess://") && config.contains("@")) {
+        m_configType = ConfigTypes::Xray;
+        m_config = extractXrayConfig(
+                Utils::JsonToString(serialization::vmess_new::Deserialize(config, &prefix, &errormsg), QJsonDocument::JsonFormat::Compact),
+                prefix);
+        return m_config.empty() ? false : true;
+    }
+
+    if (config.startsWith("vmess://")) {
+        m_configType = ConfigTypes::Xray;
+        m_config = extractXrayConfig(
+                Utils::JsonToString(serialization::vmess::Deserialize(config, &prefix, &errormsg), QJsonDocument::JsonFormat::Compact),
+                prefix);
+        return m_config.empty() ? false : true;
+    }
+
+    if (config.startsWith("trojan://")) {
+        m_configType = ConfigTypes::Xray;
+        m_config = extractXrayConfig(
+                Utils::JsonToString(serialization::trojan::Deserialize(config, &prefix, &errormsg), QJsonDocument::JsonFormat::Compact),
+                prefix);
+        return m_config.empty() ? false : true;
+    }
+
+    if (config.startsWith("ss://") && !config.contains("plugin=")) {
+        m_configType = ConfigTypes::ShadowSocks;
+        m_config = extractXrayConfig(
+                Utils::JsonToString(serialization::ss::Deserialize(config, &prefix, &errormsg), QJsonDocument::JsonFormat::Compact), prefix);
+        return m_config.empty() ? false : true;
+    }
+
+    if (config.startsWith("ssd://")) {
+        QStringList tmp;
+        QList<std::pair<QString, QJsonObject>> servers = serialization::ssd::Deserialize(config, &prefix, &tmp);
+        m_configType = ConfigTypes::ShadowSocks;
+        // Took only first config from list
+        if (!servers.isEmpty()) {
+            m_config = extractXrayConfig(servers.first().first);
+        }
+        return m_config.empty() ? false : true;
+    }
+
    m_configType = checkConfigFormat(config);
    if (m_configType == ConfigTypes::Invalid) {
-        data.replace("vpn://", "");
-        QByteArray ba = QByteArray::fromBase64(data.toUtf8(), QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
-        QByteArray ba_uncompressed = qUncompress(ba);
-        if (!ba_uncompressed.isEmpty()) {
-            ba = ba_uncompressed;
+        config.replace("vpn://", "");
+        QByteArray ba = QByteArray::fromBase64(config.toUtf8(), QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+        QByteArray baUncompressed = qUncompress(ba);
+        if (!baUncompressed.isEmpty()) {
+            ba = baUncompressed;
        }

        config = ba;
@ -120,6 +181,14 @@ bool ImportController::extractConfigFromData(QString data)
    }
    case ConfigTypes::Amnezia: {
        m_config = QJsonDocument::fromJson(config.toUtf8()).object();
+
+        if (apiUtils::isServerFromApi(m_config)) {
+            auto apiConfig = m_config.value(apiDefs::key::apiConfig).toObject();
+            apiConfig[apiDefs::key::vpnKey] = data;
+            m_config[apiDefs::key::apiConfig] = apiConfig;
+        }
+
+        processAmneziaConfig(m_config);
        if (!m_config.empty()) {
            checkForMaliciousStrings(m_config);
            return true;
@ -130,12 +199,12 @@ bool ImportController::extractConfigFromData(QString data)
        if (!m_serversModel->getServersCount()) {
            emit restoreAppConfig(config.toUtf8());
        } else {
-            emit importErrorOccurred(tr("Invalid configuration file"), false);
+            emit importErrorOccurred(ErrorCode::ImportInvalidConfigError, false);
        }
        break;
    }
    case ConfigTypes::Invalid: {
-        emit importErrorOccurred(tr("Invalid configuration file"), false);
+        emit importErrorOccurred(ErrorCode::ImportInvalidConfigError, false);
        break;
    }
    }
@ -156,6 +225,21 @@ bool ImportController::extractConfigFromQr(const QByteArray &data)
        return true;
    }

+    m_configType = checkConfigFormat(data);
+    if (m_configType == ConfigTypes::Invalid) {
+        QByteArray ba = QByteArray::fromBase64(data, QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+        QByteArray baUncompressed = qUncompress(ba);
+
+        if (!baUncompressed.isEmpty()) {
+            ba = baUncompressed;
+        }
+
+        if (!ba.isEmpty()) {
+            m_config = QJsonDocument::fromJson(ba).object();
+            return true;
+        }
+    }
+
    return false;
 }

@ -184,24 +268,26 @@ void ImportController::processNativeWireGuardConfig()
    auto containers = m_config.value(config_key::containers).toArray();
    if (!containers.isEmpty()) {
        auto container = containers.at(0).toObject();
-        auto containerConfig = container.value(ContainerProps::containerTypeToString(DockerContainer::WireGuard)).toObject();
-        auto protocolConfig = QJsonDocument::fromJson(containerConfig.value(config_key::last_config).toString().toUtf8()).object();
+        auto serverProtocolConfig = container.value(ContainerProps::containerTypeToString(DockerContainer::WireGuard)).toObject();
+        auto clientProtocolConfig = QJsonDocument::fromJson(serverProtocolConfig.value(config_key::last_config).toString().toUtf8()).object();

-        QString junkPacketCount = QString::number(QRandomGenerator::global()->bounded(3, 10));
-        QString junkPacketMinSize = QString::number(50);
-        QString junkPacketMaxSize = QString::number(1000);
-        protocolConfig[config_key::junkPacketCount] = junkPacketCount;
-        protocolConfig[config_key::junkPacketMinSize] = junkPacketMinSize;
-        protocolConfig[config_key::junkPacketMaxSize] = junkPacketMaxSize;
-        protocolConfig[config_key::initPacketJunkSize] = "0";
-        protocolConfig[config_key::responsePacketJunkSize] = "0";
-        protocolConfig[config_key::initPacketMagicHeader] = "1";
-        protocolConfig[config_key::responsePacketMagicHeader] = "2";
-        protocolConfig[config_key::underloadPacketMagicHeader] = "3";
-        protocolConfig[config_key::transportPacketMagicHeader] = "4";
+        QString junkPacketCount = QString::number(QRandomGenerator::global()->bounded(2, 5));
+        QString junkPacketMinSize = QString::number(10);
+        QString junkPacketMaxSize = QString::number(50);
+        clientProtocolConfig[config_key::junkPacketCount] = junkPacketCount;
+        clientProtocolConfig[config_key::junkPacketMinSize] = junkPacketMinSize;
+        clientProtocolConfig[config_key::junkPacketMaxSize] = junkPacketMaxSize;
+        clientProtocolConfig[config_key::initPacketJunkSize] = "0";
+        clientProtocolConfig[config_key::responsePacketJunkSize] = "0";
+        clientProtocolConfig[config_key::initPacketMagicHeader] = "1";
+        clientProtocolConfig[config_key::responsePacketMagicHeader] = "2";
+        clientProtocolConfig[config_key::underloadPacketMagicHeader] = "3";
+        clientProtocolConfig[config_key::transportPacketMagicHeader] = "4";

-        containerConfig[config_key::last_config] = QString(QJsonDocument(protocolConfig).toJson());
-        container["wireguard"] = containerConfig;
+        clientProtocolConfig[config_key::isObfuscationEnabled] = true;
+
+        serverProtocolConfig[config_key::last_config] = QString(QJsonDocument(clientProtocolConfig).toJson());
+        container["wireguard"] = serverProtocolConfig;
        containers.replace(0, container);
        m_config[config_key::containers] = containers;
    }
@ -221,7 +307,7 @@ void ImportController::importConfig()
    } else if (m_config.contains(config_key::configVersion)) {
        quint16 crc = qChecksum(QJsonDocument(m_config).toJson());
        if (m_serversModel->isServerFromApiAlreadyExists(crc)) {
-            emit importErrorOccurred(errorString(ErrorCode::ApiConfigAlreadyAdded), true);
+            emit importErrorOccurred(ErrorCode::ApiConfigAlreadyAdded, true);
        } else {
            m_config.insert(config_key::crc, crc);

@ -231,7 +317,7 @@ void ImportController::importConfig()
    } else {
        qDebug() << "Failed to import profile";
        qDebug().noquote() << QJsonDocument(m_config).toJson();
-        emit importErrorOccurred(errorString(ErrorCode::ImportInvalidConfigError), false);
+        emit importErrorOccurred(ErrorCode::ImportInvalidConfigError, false);
    }

    m_config = {};
@ -256,7 +342,7 @@ QJsonObject ImportController::extractOpenVpnConfig(const QString &data)
    arr.push_back(containers);

    QString hostName;
-    const static QRegularExpression hostNameRegExp("remote (.*) [0-9]*");
+    const static QRegularExpression hostNameRegExp("remote\\s+([^\\s]+)");
    QRegularExpressionMatch hostNameMatch = hostNameRegExp.match(data);
    if (hostNameMatch.hasMatch()) {
        hostName = hostNameMatch.captured(1);
@ -300,20 +386,19 @@ QJsonObject ImportController::extractWireGuardConfig(const QString &data)
    QJsonObject lastConfig;
    lastConfig[config_key::config] = data;

-    const static QRegularExpression hostNameAndPortRegExp("Endpoint = (.*):([0-9]*)");
-    QRegularExpressionMatch hostNameAndPortMatch = hostNameAndPortRegExp.match(data);
+    auto url { QUrl::fromUserInput(configMap.value("Endpoint")) };
    QString hostName;
    QString port;
-    if (hostNameAndPortMatch.hasCaptured(1)) {
-        hostName = hostNameAndPortMatch.captured(1);
+    if (!url.host().isEmpty()) {
+        hostName = url.host();
    } else {
-        qDebug() << "Key parameter 'Endpoint' is missing";
-        emit importErrorOccurred(errorString(ErrorCode::ImportInvalidConfigError), false);
+        qDebug() << "Key parameter 'Endpoint' is missing or has an invalid format";
+        emit importErrorOccurred(ErrorCode::ImportInvalidConfigError, false);
        return QJsonObject();
    }

-    if (hostNameAndPortMatch.hasCaptured(2)) {
-        port = hostNameAndPortMatch.captured(2);
+    if (url.port() != -1) {
+        port = QString::number(url.port());
    } else {
        port = protocols::wireguard::defaultPort;
    }
@ -334,7 +419,7 @@ QJsonObject ImportController::extractWireGuardConfig(const QString &data)
        lastConfig[config_key::server_pub_key] = configMap.value("PublicKey");
    } else {
        qDebug() << "One of the key parameters is missing (PrivateKey, Address, PublicKey)";
-        emit importErrorOccurred(errorString(ErrorCode::ImportInvalidConfigError), false);
+        emit importErrorOccurred(ErrorCode::ImportInvalidConfigError, false);
        return QJsonObject();
    }

@ -342,7 +427,11 @@ QJsonObject ImportController::extractWireGuardConfig(const QString &data)
        lastConfig[config_key::mtu] = configMap.value("MTU");
    }

-    QJsonArray allowedIpsJsonArray = QJsonArray::fromStringList(configMap.value("AllowedIPs").split(","));
+    if (!configMap.value("PersistentKeepalive").isEmpty()) {
+        lastConfig[config_key::persistent_keep_alive] = configMap.value("PersistentKeepalive");
+    }
+
+    QJsonArray allowedIpsJsonArray = QJsonArray::fromStringList(configMap.value("AllowedIPs").split(", "));

    lastConfig[config_key::allowed_ips] = allowedIpsJsonArray;

@ -366,6 +455,12 @@ QJsonObject ImportController::extractWireGuardConfig(const QString &data)
        m_configType = ConfigTypes::Awg;
    }

+    if (!configMap.value("MTU").isEmpty()) {
+        lastConfig[config_key::mtu] = configMap.value("MTU");
+    } else {
+        lastConfig[config_key::mtu] = protocolName == "awg" ? protocols::awg::defaultMtu : protocols::wireguard::defaultMtu;
+    }
+
    QJsonObject wireguardConfig;
    wireguardConfig[config_key::last_config] = QString(QJsonDocument(lastConfig).toJson());
    wireguardConfig[config_key::isThirdPartyConfig] = true;
@ -398,7 +493,7 @@ QJsonObject ImportController::extractWireGuardConfig(const QString &data)
    return config;
 }

-QJsonObject ImportController::extractXrayConfig(const QString &data)
+QJsonObject ImportController::extractXrayConfig(const QString &data, const QString &description)
 {
    QJsonParseError parserErr;
    QJsonDocument jsonConf = QJsonDocument::fromJson(data.toLocal8Bit(), &parserErr);
@ -410,8 +505,13 @@ QJsonObject ImportController::extractXrayConfig(const QString &data)
    lastConfig[config_key::isThirdPartyConfig] = true;

    QJsonObject containers;
-    containers.insert(config_key::container, QJsonValue("amnezia-xray"));
-    containers.insert(config_key::xray, QJsonValue(lastConfig));
+    if (m_configType == ConfigTypes::ShadowSocks) {
+        containers.insert(config_key::ssxray, QJsonValue(lastConfig));
+        containers.insert(config_key::container, QJsonValue("amnezia-ssxray"));
+    } else {
+        containers.insert(config_key::container, QJsonValue("amnezia-xray"));
+        containers.insert(config_key::xray, QJsonValue(lastConfig));
+    }

    QJsonArray arr;
    arr.push_back(containers);
@ -426,9 +526,17 @@ QJsonObject ImportController::extractXrayConfig(const QString &data)

    QJsonObject config;
    config[config_key::containers] = arr;
-    config[config_key::defaultContainer] = "amnezia-xray";
-    config[config_key::description] = m_settings->nextAvailableServerName();

+    if (m_configType == ConfigTypes::ShadowSocks) {
+        config[config_key::defaultContainer] = "amnezia-ssxray";
+    } else {
+        config[config_key::defaultContainer] = "amnezia-xray";
+    }
+    if (description.isEmpty()) {
+        config[config_key::description] = m_settings->nextAvailableServerName();
+    } else {
+        config[config_key::description] = description;
+    }
    config[config_key::hostName] = hostName;

    return config;
@ -484,7 +592,7 @@ bool ImportController::parseQrCodeChunk(const QString &code)
    qint16 magic;
    s >> magic;

-    if (magic == amnezia::qrMagicCode) {
+    if (magic == qrCodeUtils::qrMagicCode) {
        quint8 chunksCount;
        s >> chunksCount;
        if (m_totalQrCodeChunksCount != chunksCount) {
@ -580,3 +688,29 @@ void ImportController::checkForMaliciousStrings(const QJsonObject &serverConfig)
        }
    }
 }
+
+void ImportController::processAmneziaConfig(QJsonObject &config)
+{
+    auto containers = config.value(config_key::containers).toArray();
+    for (auto i = 0; i < containers.size(); i++) {
+        auto container = containers.at(i).toObject();
+        auto dockerContainer = ContainerProps::containerFromString(container.value(config_key::container).toString());
+        if (dockerContainer == DockerContainer::Awg || dockerContainer == DockerContainer::WireGuard) {
+            auto containerConfig = container.value(ContainerProps::containerTypeToString(dockerContainer)).toObject();
+            auto protocolConfig = containerConfig.value(config_key::last_config).toString();
+            if (protocolConfig.isEmpty()) {
+                return;
+            }
+
+            QJsonObject jsonConfig = QJsonDocument::fromJson(protocolConfig.toUtf8()).object();
+            jsonConfig[config_key::mtu] =
+                    dockerContainer == DockerContainer::Awg ? protocols::awg::defaultMtu : protocols::wireguard::defaultMtu;
+
+            containerConfig[config_key::last_config] = QString(QJsonDocument(jsonConfig).toJson());
+
+            container[ContainerProps::containerTypeToString(dockerContainer)] = containerConfig;
+            containers.replace(i, container);
+            config.insert(config_key::containers, containers);
+        }
+    }
+}
--- a/client/ui/controllers/importController.h
+++ b/client/ui/controllers/importController.h
@ -14,6 +14,7 @@ namespace
        WireGuard,
        Awg,
        Xray,
+        ShadowSocks,
        Backup,
        Invalid
    };
@ -53,7 +54,7 @@ public slots:

 signals:
    void importFinished();
-    void importErrorOccurred(const QString &errorMessage, bool goToPageHome);
+    void importErrorOccurred(ErrorCode errorCode, bool goToPageHome);

    void qrDecodingFinished();

@ -62,10 +63,12 @@ signals:
 private:
    QJsonObject extractOpenVpnConfig(const QString &data);
    QJsonObject extractWireGuardConfig(const QString &data);
-    QJsonObject extractXrayConfig(const QString &data);
+    QJsonObject extractXrayConfig(const QString &data, const QString &description = "");

    void checkForMaliciousStrings(const QJsonObject &protocolConfig);

+    void processAmneziaConfig(QJsonObject &config);
+
 #if defined Q_OS_ANDROID || defined Q_OS_IOS
    void stopDecodingQr();
 #endif
--- a/client/ui/controllers/installController.cpp
+++ b/client/ui/controllers/installController.cpp
@ -6,48 +6,35 @@
 #include <QJsonObject>
 #include <QRandomGenerator>
 #include <QStandardPaths>
+#include <QtConcurrent>

 #include "core/controllers/serverController.h"
 #include "core/controllers/vpnConfigurationController.h"
-#include "core/errorstrings.h"
 #include "core/networkUtilities.h"
 #include "logger.h"
 #include "ui/models/protocols/awgConfigModel.h"
 #include "ui/models/protocols/wireguardConfigModel.h"
 #include "utilities.h"
-
-#ifdef Q_OS_IOS
-    #include <AmneziaVPN-Swift.h>
-#endif
+#include "core/api/apiUtils.h"

 namespace
 {
    Logger logger("ServerController");

-#ifdef Q_OS_WINDOWS
-    QString getNextDriverLetter()
+    namespace configKey
    {
-        QProcess drivesProc;
-        drivesProc.start("wmic logicaldisk get caption");
-        drivesProc.waitForFinished();
-        QString drives = drivesProc.readAll();
-        qDebug() << drives;
+        constexpr char serviceInfo[] = "service_info";
+        constexpr char serviceType[] = "service_type";
+        constexpr char serviceProtocol[] = "service_protocol";
+        constexpr char userCountryCode[] = "user_country_code";

-        QString letters = "CFGHIJKLMNOPQRSTUVWXYZ";
-        QString letter;
-        for (int i = letters.size() - 1; i > 0; i--) {
-            letter = letters.at(i);
-            if (!drives.contains(letter + ":"))
-                break;
-        }
-        if (letter == "C:") {
-            // set err info
-            qDebug() << "Can't find free drive letter";
-            return "";
-        }
-        return letter;
+        constexpr char serverCountryCode[] = "server_country_code";
+        constexpr char serverCountryName[] = "server_country_name";
+        constexpr char availableCountries[] = "available_countries";
+
+        constexpr char apiConfig[] = "api_config";
+        constexpr char authData[] = "auth_data";
    }
-#endif
 }

 InstallController::InstallController(const QSharedPointer<ServersModel> &serversModel, const QSharedPointer<ContainersModel> &containersModel,
@ -86,9 +73,9 @@ void InstallController::install(DockerContainer container, int port, TransportPr
            containerConfig.insert(config_key::transport_proto, ProtocolProps::transportProtoToString(transportProto, protocol));

            if (container == DockerContainer::Awg) {
-                QString junkPacketCount = QString::number(QRandomGenerator::global()->bounded(3, 10));
-                QString junkPacketMinSize = QString::number(50);
-                QString junkPacketMaxSize = QString::number(1000);
+                QString junkPacketCount = QString::number(QRandomGenerator::global()->bounded(2, 5));
+                QString junkPacketMinSize = QString::number(10);
+                QString junkPacketMaxSize = QString::number(50);

                int s1 = QRandomGenerator::global()->bounded(15, 150);
                int s2 = QRandomGenerator::global()->bounded(15, 150);
@ -123,7 +110,10 @@ void InstallController::install(DockerContainer container, int port, TransportPr
                containerConfig[config_key::transportPacketMagicHeader] = transportPacketMagicHeader;
            } else if (container == DockerContainer::Sftp) {
                containerConfig.insert(config_key::userName, protocols::sftp::defaultUserName);
-                containerConfig.insert(config_key::password, Utils::getRandomString(10));
+                containerConfig.insert(config_key::password, Utils::getRandomString(16));
+            } else if (container == DockerContainer::Socks5Proxy) {
+                containerConfig.insert(config_key::userName, protocols::socks5Proxy::defaultUserName);
+                containerConfig.insert(config_key::password, Utils::getRandomString(16));
            }

            config.insert(config_key::container, ContainerProps::containerToString(container));
@ -149,7 +139,7 @@ void InstallController::install(DockerContainer container, int port, TransportPr
    QMap<DockerContainer, QJsonObject> installedContainers;
    ErrorCode errorCode = getAlreadyInstalledContainers(serverCredentials, serverController, installedContainers);
    if (errorCode) {
-        emit installationErrorOccurred(errorString(errorCode));
+        emit installationErrorOccurred(errorCode);
        return;
    }

@ -158,7 +148,7 @@ void InstallController::install(DockerContainer container, int port, TransportPr
    if (!installedContainers.contains(container)) {
        errorCode = serverController->setupContainer(serverCredentials, container, config);
        if (errorCode) {
-            emit installationErrorOccurred(errorString(errorCode));
+            emit installationErrorOccurred(errorCode);
            return;
        }

@ -169,7 +159,7 @@ void InstallController::install(DockerContainer container, int port, TransportPr
    }

    if (errorCode) {
-        emit installationErrorOccurred(errorString(errorCode));
+        emit installationErrorOccurred(errorCode);
        return;
    }

@ -204,7 +194,7 @@ void InstallController::installServer(const DockerContainer container, const QMa
            auto errorCode = vpnConfigurationController.createProtocolConfigForContainer(m_processedServerCredentials, iterator.key(),
                                                                                         containerConfig);
            if (errorCode) {
-                emit installationErrorOccurred(errorString(errorCode));
+                emit installationErrorOccurred(errorCode);
                return;
            }
            containerConfigs.append(containerConfig);
@ -212,7 +202,7 @@ void InstallController::installServer(const DockerContainer container, const QMa
            errorCode = m_clientManagementModel->appendClient(iterator.key(), serverCredentials, containerConfig,
                                                              QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
            if (errorCode) {
-                emit installationErrorOccurred(errorString(errorCode));
+                emit installationErrorOccurred(errorCode);
                return;
            }
        } else {
@ -244,7 +234,7 @@ void InstallController::installContainer(const DockerContainer container, const
                auto errorCode =
                        vpnConfigurationController.createProtocolConfigForContainer(serverCredentials, iterator.key(), containerConfig);
                if (errorCode) {
-                    emit installationErrorOccurred(errorString(errorCode));
+                    emit installationErrorOccurred(errorCode);
                    return;
                }
                m_serversModel->addContainerConfig(iterator.key(), containerConfig);
@ -252,7 +242,7 @@ void InstallController::installContainer(const DockerContainer container, const
                errorCode = m_clientManagementModel->appendClient(iterator.key(), serverCredentials, containerConfig,
                                                                  QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
                if (errorCode) {
-                    emit installationErrorOccurred(errorString(errorCode));
+                    emit installationErrorOccurred(errorCode);
                    return;
                }
            } else {
@ -310,7 +300,7 @@ void InstallController::scanServerForInstalledContainers()
                    auto errorCode =
                            vpnConfigurationController.createProtocolConfigForContainer(serverCredentials, container, containerConfig);
                    if (errorCode) {
-                        emit installationErrorOccurred(errorString(errorCode));
+                        emit installationErrorOccurred(errorCode);
                        return;
                    }
                    m_serversModel->addContainerConfig(container, containerConfig);
@ -319,7 +309,7 @@ void InstallController::scanServerForInstalledContainers()
                                                                      QString("Admin [%1]").arg(QSysInfo::prettyProductName()),
                                                                      serverController);
                    if (errorCode) {
-                        emit installationErrorOccurred(errorString(errorCode));
+                        emit installationErrorOccurred(errorCode);
                        return;
                    }
                } else {
@ -334,7 +324,7 @@ void InstallController::scanServerForInstalledContainers()
        return;
    }

-    emit installationErrorOccurred(errorString(errorCode));
+    emit installationErrorOccurred(errorCode);
 }

 ErrorCode InstallController::getAlreadyInstalledContainers(const ServerCredentials &credentials,
@ -363,7 +353,7 @@ ErrorCode InstallController::getAlreadyInstalledContainers(const ServerCredentia
        if (containerInfo.isEmpty()) {
            continue;
        }
-        const static QRegularExpression containerAndPortRegExp("(amnezia[-a-z]*).*?:([0-9]*)->[0-9]*/(udp|tcp).*");
+        const static QRegularExpression containerAndPortRegExp("(amnezia[-a-z0-9]*).*?:([0-9]*)->[0-9]*/(udp|tcp).*");
        QRegularExpressionMatch containerAndPortMatch = containerAndPortRegExp.match(containerInfo);
        if (containerAndPortMatch.hasMatch()) {
            QString name = containerAndPortMatch.captured(1);
@ -437,6 +427,20 @@ ErrorCode InstallController::getAlreadyInstalledContainers(const ServerCredentia

                        containerConfig.insert(config_key::userName, userName);
                        containerConfig.insert(config_key::password, password);
+                    } else if (protocol == Proto::Socks5Proxy) {
+                        QString proxyConfig = serverController->getTextFileFromContainer(container, credentials,
+                                                                                         protocols::socks5Proxy::proxyConfigPath, errorCode);
+
+                        const static QRegularExpression usernameAndPasswordRegExp("users (\\w+):CL:(\\w+)");
+                        QRegularExpressionMatch usernameAndPasswordMatch = usernameAndPasswordRegExp.match(proxyConfig);
+
+                        if (usernameAndPasswordMatch.hasMatch()) {
+                            QString userName = usernameAndPasswordMatch.captured(1);
+                            QString password = usernameAndPasswordMatch.captured(2);
+
+                            containerConfig.insert(config_key::userName, userName);
+                            containerConfig.insert(config_key::password, password);
+                        }
                    }

                    config.insert(config_key::container, ContainerProps::containerToString(container));
@ -524,7 +528,7 @@ void InstallController::updateContainer(QJsonObject config)
        return;
    }

-    emit installationErrorOccurred(errorString(errorCode));
+    emit installationErrorOccurred(errorCode);
 }

 void InstallController::rebootProcessedServer()
@ -537,7 +541,7 @@ void InstallController::rebootProcessedServer()
    if (errorCode == ErrorCode::NoError) {
        emit rebootProcessedServerFinished(tr("Server '%1' was rebooted").arg(serverName));
    } else {
-        emit installationErrorOccurred(errorString(errorCode));
+        emit installationErrorOccurred(errorCode);
    }
 }

@ -561,7 +565,7 @@ void InstallController::removeAllContainers()
        emit removeAllContainersFinished(tr("All containers from server '%1' have been removed").arg(serverName));
        return;
    }
-    emit installationErrorOccurred(errorString(errorCode));
+    emit installationErrorOccurred(errorCode);
 }

 void InstallController::removeProcessedContainer()
@ -579,30 +583,13 @@ void InstallController::removeProcessedContainer()
        emit removeProcessedContainerFinished(tr("%1 has been removed from the server '%2'").arg(containerName, serverName));
        return;
    }
-    emit installationErrorOccurred(errorString(errorCode));
+    emit installationErrorOccurred(errorCode);
 }

 void InstallController::removeApiConfig(const int serverIndex)
 {
-    auto serverConfig = m_serversModel->getServerConfig(serverIndex);
-
-#ifdef Q_OS_IOS
-    QString vpncName = QString("%1 (%2) %3")
-        .arg(serverConfig[config_key::description].toString())
-        .arg(serverConfig[config_key::hostName].toString())
-        .arg(serverConfig[config_key::vpnproto].toString());
-
-    AmneziaVPN::removeVPNC(vpncName.toStdString());
-#endif
-
-    serverConfig.remove(config_key::dns1);
-    serverConfig.remove(config_key::dns2);
-    serverConfig.remove(config_key::containers);
-    serverConfig.remove(config_key::hostName);
-
-    serverConfig.insert(config_key::defaultContainer, ContainerProps::containerToString(DockerContainer::None));
-
-    m_serversModel->editServer(serverConfig, serverIndex);
+    m_serversModel->removeApiConfig(serverIndex);
+    emit apiConfigRemoved(tr("Api config removed"));
 }

 void InstallController::clearCachedProfile(QSharedPointer<ServerController> serverController)
@ -613,6 +600,10 @@ void InstallController::clearCachedProfile(QSharedPointer<ServerController> serv

    int serverIndex = m_serversModel->getProcessedServerIndex();
    DockerContainer container = static_cast<DockerContainer>(m_containersModel->getProcessedContainerIndex());
+    if (ContainerProps::containerService(container) == ServiceType::Other) {
+        return;
+    }
+
    QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
    ServerCredentials serverCredentials =
            qvariant_cast<ServerCredentials>(m_serversModel->data(serverIndex, ServersModel::Roles::CredentialsRole));
@ -660,7 +651,7 @@ void InstallController::mountSftpDrive(const QString &port, const QString &passw
    QString hostname = serverCredentials.hostName;

 #ifdef Q_OS_WINDOWS
-    mountPath = getNextDriverLetter() + ":";
+    mountPath = Utils::getNextDriverLetter() + ":";
    //    QString cmd = QString("net use \\\\sshfs\\%1@x.x.x.x!%2 /USER:%1 %3")
    //            .arg(labelTftpUserNameText())
    //            .arg(labelTftpPortText())
@ -747,7 +738,7 @@ bool InstallController::checkSshConnection(QSharedPointer<ServerController> serv
        if (errorCode == ErrorCode::NoError) {
            m_processedServerCredentials.secretData = decryptedPrivateKey;
        } else {
-            emit installationErrorOccurred(errorString(errorCode));
+            emit installationErrorOccurred(errorCode);
            return false;
        }
    }
@ -756,12 +747,12 @@ bool InstallController::checkSshConnection(QSharedPointer<ServerController> serv
    output = serverController->checkSshConnection(m_processedServerCredentials, errorCode);

    if (errorCode != ErrorCode::NoError) {
-        emit installationErrorOccurred(errorString(errorCode));
+        emit installationErrorOccurred(errorCode);
        return false;
    } else {
        if (output.contains(tr("Please login as the user"))) {
            output.replace("\n", "");
-            emit installationErrorOccurred(output);
+            emit wrongInstallationUser(output);
            return false;
        }
    }
@ -790,6 +781,81 @@ void InstallController::addEmptyServer()
    emit installServerFinished(tr("Server added successfully"));
 }

+bool InstallController::isConfigValid()
+{
+    int serverIndex = m_serversModel->getDefaultServerIndex();
+    QJsonObject serverConfigObject = m_serversModel->getServerConfig(serverIndex);
+
+    if (apiUtils::isServerFromApi(serverConfigObject)) {
+        return true;
+    }
+
+    if (!m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
+        emit noInstalledContainers();
+        return false;
+    }
+
+    DockerContainer container = qvariant_cast<DockerContainer>(m_serversModel->data(serverIndex, ServersModel::Roles::DefaultContainerRole));
+
+    if (container == DockerContainer::None) {
+        emit installationErrorOccurred(ErrorCode::NoInstalledContainersError);
+        return false;
+    }
+
+    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
+    VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
+
+    QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
+    ServerCredentials credentials = m_serversModel->getServerCredentials(serverIndex);
+
+    QFutureWatcher<ErrorCode> watcher;
+
+    QFuture<ErrorCode> future = QtConcurrent::run([this, container, &credentials, &containerConfig, &serverController]() {
+        ErrorCode errorCode = ErrorCode::NoError;
+
+        auto isProtocolConfigExists = [](const QJsonObject &containerConfig, const DockerContainer container) {
+            for (Proto protocol : ContainerProps::protocolsForContainer(container)) {
+                QString protocolConfig =
+                        containerConfig.value(ProtocolProps::protoToString(protocol)).toObject().value(config_key::last_config).toString();
+
+                if (protocolConfig.isEmpty()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        if (!isProtocolConfigExists(containerConfig, container)) {
+            VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
+            errorCode = vpnConfigurationController.createProtocolConfigForContainer(credentials, container, containerConfig);
+            if (errorCode != ErrorCode::NoError) {
+                return errorCode;
+            }
+            m_serversModel->updateContainerConfig(container, containerConfig);
+
+            errorCode = m_clientManagementModel->appendClient(container, credentials, containerConfig,
+                                                              QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
+            if (errorCode != ErrorCode::NoError) {
+                return errorCode;
+            }
+        }
+        return errorCode;
+    });
+
+    QEventLoop wait;
+    connect(&watcher, &QFutureWatcher<ErrorCode>::finished, &wait, &QEventLoop::quit);
+    watcher.setFuture(future);
+    wait.exec();
+
+    ErrorCode errorCode = watcher.result();
+
+    if (errorCode != ErrorCode::NoError) {
+        emit installationErrorOccurred(errorCode);
+        return false;
+    }
+    return true;
+}
+
 bool InstallController::isUpdateDockerContainerRequired(const DockerContainer container, const QJsonObject &oldConfig,
                                                        const QJsonObject &newConfig)
 {
--- a/client/ui/controllers/installController.h
+++ b/client/ui/controllers/installController.h
@ -50,6 +50,8 @@ public slots:

    void addEmptyServer();

+    bool isConfigValid();
+
 signals:
    void installContainerFinished(const QString &finishMessage, bool isServiceInstall);
    void installServerFinished(const QString &finishMessage);
@ -63,7 +65,8 @@ signals:
    void removeAllContainersFinished(const QString &finishedMessage);
    void removeProcessedContainerFinished(const QString &finishedMessage);

-    void installationErrorOccurred(const QString &errorMessage);
+    void installationErrorOccurred(ErrorCode errorCode);
+    void wrongInstallationUser(const QString &message);

    void serverAlreadyExists(int serverIndex);

@ -76,6 +79,9 @@ signals:
    void currentContainerUpdated();

    void cachedProfileCleared(const QString &message);
+    void apiConfigRemoved(const QString &message);
+
+    void noInstalledContainers();

 private:
    void installServer(const DockerContainer container, const QMap<DockerContainer, QJsonObject> &installedContainers,
@ -94,6 +100,7 @@ private:
    QSharedPointer<ContainersModel> m_containersModel;
    QSharedPointer<ProtocolsModel> m_protocolModel;
    QSharedPointer<ClientManagementModel> m_clientManagementModel;
+
    std::shared_ptr<Settings> m_settings;

    ServerCredentials m_processedServerCredentials;
--- a/client/ui/controllers/listViewFocusController.cpp
+++ b/client/ui/controllers/listViewFocusController.cpp
@ -0,0 +1,309 @@
+#include "listViewFocusController.h"
+#include "utils/qmlUtils.h"
+
+#include <QQuickWindow>
+
+ListViewFocusController::ListViewFocusController(QQuickItem *listView, QObject *parent)
+    : QObject { parent },
+      m_listView { listView },
+      m_focusChain {},
+      m_currentSection { Section::Default },
+      m_header { nullptr },
+      m_footer { nullptr },
+      m_focusedItem { nullptr },
+      m_focusedItemIndex { -1 },
+      m_delegateIndex { 0 },
+      m_isReturnNeeded { false },
+      m_currentSectionString { "Default", "Header", "Delegate", "Footer" }
+{
+    QVariant headerItemProperty = m_listView->property("headerItem");
+    m_header = headerItemProperty.canConvert<QQuickItem *>() ? headerItemProperty.value<QQuickItem *>() : nullptr;
+
+    QVariant footerItemProperty = m_listView->property("footerItem");
+    m_footer = footerItemProperty.canConvert<QQuickItem *>() ? footerItemProperty.value<QQuickItem *>() : nullptr;
+}
+
+ListViewFocusController::~ListViewFocusController()
+{
+}
+
+void ListViewFocusController::viewAtCurrentIndex() const
+{
+    switch (m_currentSection) {
+    case Section::Default: [[fallthrough]];
+    case Section::Header: {
+        QMetaObject::invokeMethod(m_listView, "positionViewAtBeginning");
+        break;
+    }
+    case Section::Delegate: {
+        QMetaObject::invokeMethod(m_listView, "positionViewAtIndex", Q_ARG(int, m_delegateIndex), // Index
+                                  Q_ARG(int, 2)); // PositionMode (0 = Visible)
+        break;
+    }
+    case Section::Footer: {
+        QMetaObject::invokeMethod(m_listView, "positionViewAtEnd");
+        break;
+    }
+    }
+}
+
+int ListViewFocusController::size() const
+{
+    return m_listView->property("count").toInt();
+}
+
+int ListViewFocusController::currentIndex() const
+{
+    return m_delegateIndex;
+}
+
+void ListViewFocusController::setDelegateIndex(int index)
+{
+    m_delegateIndex = index;
+    m_listView->setProperty("currentIndex", index);
+}
+
+void ListViewFocusController::nextDelegate()
+{
+    switch (m_currentSection) {
+    case Section::Default: {
+        if (hasHeader()) {
+            m_currentSection = Section::Header;
+            viewAtCurrentIndex();
+            break;
+        }
+        [[fallthrough]];
+    }
+    case Section::Header: {
+        if (size() > 0) {
+            m_currentSection = Section::Delegate;
+            viewAtCurrentIndex();
+            break;
+        }
+        [[fallthrough]];
+    }
+    case Section::Delegate:
+        if (m_delegateIndex < (size() - 1)) {
+            setDelegateIndex(m_delegateIndex + 1);
+            viewAtCurrentIndex();
+            break;
+        } else if (hasFooter()) {
+            m_currentSection = Section::Footer;
+            viewAtCurrentIndex();
+            break;
+        }
+        [[fallthrough]];
+    case Section::Footer: {
+        m_isReturnNeeded = true;
+        m_currentSection = Section::Default;
+        viewAtCurrentIndex();
+        break;
+    }
+    default: {
+        qCritical() << "Current section is invalid!";
+        break;
+    }
+    }
+}
+
+void ListViewFocusController::previousDelegate()
+{
+    switch (m_currentSection) {
+    case Section::Default: {
+        if (hasFooter()) {
+            m_currentSection = Section::Footer;
+            break;
+        }
+        [[fallthrough]];
+    }
+    case Section::Footer: {
+        if (size() > 0) {
+            m_currentSection = Section::Delegate;
+            setDelegateIndex(size() - 1);
+            break;
+        }
+        [[fallthrough]];
+    }
+    case Section::Delegate: {
+        if (m_delegateIndex > 0) {
+            setDelegateIndex(m_delegateIndex - 1);
+            break;
+        } else if (hasHeader()) {
+            m_currentSection = Section::Header;
+            break;
+        }
+        [[fallthrough]];
+    }
+    case Section::Header: {
+        m_isReturnNeeded = true;
+        m_currentSection = Section::Default;
+        break;
+    }
+    default: {
+        qCritical() << "Current section is invalid!";
+        break;
+    }
+    }
+}
+
+void ListViewFocusController::decrementIndex()
+{
+    m_delegateIndex--;
+}
+
+QQuickItem *ListViewFocusController::itemAtIndex(const int index) const
+{
+    QQuickItem *item { nullptr };
+
+    QMetaObject::invokeMethod(m_listView, "itemAtIndex", Q_RETURN_ARG(QQuickItem *, item), Q_ARG(int, index));
+
+    return item;
+}
+
+QQuickItem *ListViewFocusController::currentDelegate() const
+{
+    QQuickItem *result { nullptr };
+
+    switch (m_currentSection) {
+    case Section::Default: {
+        qWarning() << "No elements...";
+        break;
+    }
+    case Section::Header: {
+        result = m_header;
+        break;
+    }
+    case Section::Delegate: {
+        result = itemAtIndex(m_delegateIndex);
+        break;
+    }
+    case Section::Footer: {
+        result = m_footer;
+        break;
+    }
+    }
+    return result;
+}
+
+QQuickItem *ListViewFocusController::focusedItem() const
+{
+    return m_focusedItem;
+}
+
+void ListViewFocusController::focusNextItem()
+{
+    if (m_isReturnNeeded) {
+        return;
+    }
+
+    reloadFocusChain();
+
+    if (m_focusChain.empty()) {
+        qWarning() << "No elements found in the delegate. Going to next delegate...";
+        nextDelegate();
+        focusNextItem();
+        return;
+    }
+    m_focusedItemIndex++;
+    m_focusedItem = qobject_cast<QQuickItem *>(m_focusChain.at(m_focusedItemIndex));
+    m_focusedItem->forceActiveFocus(Qt::TabFocusReason);
+}
+
+void ListViewFocusController::focusPreviousItem()
+{
+    if (m_isReturnNeeded) {
+        return;
+    }
+
+    if (m_focusChain.empty()) {
+        qInfo() << "Empty focusChain with current delegate: " << currentDelegate() << "Scanning for elements...";
+        reloadFocusChain();
+    }
+    if (m_focusChain.empty()) {
+        qWarning() << "No elements found in the delegate. Going to next delegate...";
+        previousDelegate();
+        focusPreviousItem();
+        return;
+    }
+    if (m_focusedItemIndex == -1) {
+        m_focusedItemIndex = m_focusChain.size();
+    }
+    m_focusedItemIndex--;
+    m_focusedItem = qobject_cast<QQuickItem *>(m_focusChain.at(m_focusedItemIndex));
+    m_focusedItem->forceActiveFocus(Qt::TabFocusReason);
+}
+
+void ListViewFocusController::resetFocusChain()
+{
+    m_focusChain.clear();
+    m_focusedItem = nullptr;
+    m_focusedItemIndex = -1;
+}
+
+void ListViewFocusController::reloadFocusChain()
+{
+    m_focusChain = FocusControl::getItemsChain(currentDelegate());
+}
+
+bool ListViewFocusController::isFirstFocusItemInDelegate() const
+{
+    return m_focusedItem && (m_focusedItem == m_focusChain.first());
+}
+
+bool ListViewFocusController::isLastFocusItemInDelegate() const
+{
+    return m_focusedItem && (m_focusedItem == m_focusChain.last());
+}
+
+bool ListViewFocusController::hasHeader() const
+{
+    return m_header && !FocusControl::getItemsChain(m_header).isEmpty();
+}
+
+bool ListViewFocusController::hasFooter() const
+{
+    return m_footer && !FocusControl::getItemsChain(m_footer).isEmpty();
+}
+
+bool ListViewFocusController::isFirstFocusItemInListView() const
+{
+    switch (m_currentSection) {
+    case Section::Footer: {
+        return isFirstFocusItemInDelegate() && !hasHeader() && (size() == 0);
+    }
+    case Section::Delegate: {
+        return isFirstFocusItemInDelegate() && (m_delegateIndex == 0) && !hasHeader();
+    }
+    case Section::Header: {
+        isFirstFocusItemInDelegate();
+    }
+    case Section::Default: {
+        return true;
+    }
+    default: qWarning() << "Wrong section"; return true;
+    }
+}
+
+bool ListViewFocusController::isLastFocusItemInListView() const
+{
+    switch (m_currentSection) {
+    case Section::Default: {
+        return !hasHeader() && (size() == 0) && !hasFooter();
+    }
+    case Section::Header: {
+        return isLastFocusItemInDelegate() && (size() == 0) && !hasFooter();
+    }
+    case Section::Delegate: {
+        return isLastFocusItemInDelegate() && (m_delegateIndex == size() - 1) && !hasFooter();
+    }
+    case Section::Footer: {
+        return isLastFocusItemInDelegate();
+    }
+    default: qWarning() << "Wrong section"; return true;
+    }
+}
+
+bool ListViewFocusController::isReturnNeeded() const
+{
+    return m_isReturnNeeded;
+}
--- a/client/ui/controllers/listViewFocusController.h
+++ b/client/ui/controllers/listViewFocusController.h
@ -0,0 +1,70 @@
+#ifndef LISTVIEWFOCUSCONTROLLER_H
+#define LISTVIEWFOCUSCONTROLLER_H
+
+#include <QList>
+#include <QObject>
+#include <QQuickItem>
+#include <QSharedPointer>
+#include <QStack>
+
+/*!
+ * \brief The ListViewFocusController class manages the focus of elements in ListView
+ * \details This class object moving focus to ListView's controls since ListView stores
+ *          it's data implicitly and it could be got one by one.
+ *
+ *          This class was made to store as less as possible data getting it from QML
+ *          when it's needed.
+ */
+class ListViewFocusController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ListViewFocusController(QQuickItem *listView, QObject *parent = nullptr);
+    ~ListViewFocusController();
+
+    void nextDelegate();
+    void previousDelegate();
+    void decrementIndex();
+    void focusNextItem();
+    void focusPreviousItem();
+    void resetFocusChain();
+    void reloadFocusChain();
+    bool isFirstFocusItemInListView() const;
+    bool isFirstFocusItemInDelegate() const;
+    bool isLastFocusItemInListView() const;
+    bool isLastFocusItemInDelegate() const;
+    bool isReturnNeeded() const;
+
+private:
+    enum class Section {
+        Default,
+        Header,
+        Delegate,
+        Footer,
+    };
+
+    int size() const;
+    int currentIndex() const;
+    void setDelegateIndex(int index);
+    void viewAtCurrentIndex() const;
+    QQuickItem *itemAtIndex(const int index) const;
+    QQuickItem *currentDelegate() const;
+    QQuickItem *focusedItem() const;
+
+    bool hasHeader() const;
+    bool hasFooter() const;
+
+    QQuickItem *m_listView;
+    QList<QObject *> m_focusChain;
+    Section m_currentSection;
+    QQuickItem *m_header;
+    QQuickItem *m_footer;
+    QQuickItem *m_focusedItem; // Pointer to focused item on Delegate
+    qsizetype m_focusedItemIndex;
+    qsizetype m_delegateIndex;
+    bool m_isReturnNeeded;
+
+    QList<QString> m_currentSectionString;
+};
+
+#endif // LISTVIEWFOCUSCONTROLLER_H
--- a/client/ui/controllers/pageController.cpp
+++ b/client/ui/controllers/pageController.cpp
@ -1,4 +1,6 @@
 #include "pageController.h"
+#include "utils/converter.h"
+#include "core/errorstrings.h"

 #if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
    #include <QGuiApplication>
@ -8,8 +10,6 @@

 #ifdef Q_OS_ANDROID
    #include "platforms/android/android_controller.h"
-    #include "platforms/android/android_utils.h"
-    #include <QJniObject>
 #endif
 #if defined Q_OS_MAC
    #include "ui/macos_util.h"
@ -20,38 +20,30 @@ PageController::PageController(const QSharedPointer<ServersModel> &serversModel,
    : QObject(parent), m_serversModel(serversModel), m_settings(settings)
 {
 #ifdef Q_OS_ANDROID
-    // Change color of navigation and status bar's
    auto initialPageNavigationBarColor = getInitialPageNavigationBarColor();
-    AndroidUtils::runOnAndroidThreadSync([&initialPageNavigationBarColor]() {
-        QJniObject activity = AndroidUtils::getActivity();
-        QJniObject window = activity.callObjectMethod("getWindow", "()Landroid/view/Window;");
-        if (window.isValid()) {
-            window.callMethod<void>("addFlags", "(I)V", 0x80000000);
-            window.callMethod<void>("clearFlags", "(I)V", 0x04000000);
-            window.callMethod<void>("setStatusBarColor", "(I)V", 0xFF0E0E11);
-            window.callMethod<void>("setNavigationBarColor", "(I)V", initialPageNavigationBarColor);
-        }
-    });
+    AndroidController::instance()->setNavigationBarColor(initialPageNavigationBarColor);
 #endif

 #if defined Q_OS_MACX
    connect(this, &PageController::raiseMainWindow, []() { setDockIconVisible(true); });
    connect(this, &PageController::hideMainWindow, []() { setDockIconVisible(false); });
 #endif
+
+    connect(this, qOverload<ErrorCode>(&PageController::showErrorMessage), this, &PageController::onShowErrorMessage);
    
    m_isTriggeredByConnectButton = false;
 }

-QString PageController::getInitialPage()
+bool PageController::isStartPageVisible()
 {
    if (m_serversModel->getServersCount()) {
        if (m_serversModel->getDefaultServerIndex() < 0) {
            auto defaultServerIndex = m_serversModel->index(0);
            m_serversModel->setData(defaultServerIndex, true, ServersModel::Roles::IsDefaultRole);
        }
-        return getPagePath(PageLoader::PageEnum::PageStart);
+        return false;
    } else {
-        return getPagePath(PageLoader::PageEnum::PageSetupWizardStart);
+        return true;
    }
 }

@ -89,7 +81,7 @@ void PageController::keyPressEvent(Qt::Key key)
    case Qt::Key_Escape: {
        if (m_drawerDepth) {
            emit closeTopDrawer();
-            setDrawerDepth(getDrawerDepth() - 1);
+            decrementDrawerDepth();
        } else {
            emit escapePressed();
        }
@ -111,14 +103,7 @@ unsigned int PageController::getInitialPageNavigationBarColor()
 void PageController::updateNavigationBarColor(const int color)
 {
 #ifdef Q_OS_ANDROID
-    // Change color of navigation bar
-    AndroidUtils::runOnAndroidThreadSync([&color]() {
-        QJniObject activity = AndroidUtils::getActivity();
-        QJniObject window = activity.callObjectMethod("getWindow", "()Landroid/view/Window;");
-        if (window.isValid()) {
-            window.callMethod<void>("setNavigationBarColor", "(I)V", color);
-        }
-    });
+    AndroidController::instance()->setNavigationBarColor(color);
 #endif
 }

@ -127,7 +112,7 @@ void PageController::showOnStartup()
    if (!m_settings->isStartMinimized()) {
        emit raiseMainWindow();
    } else {
-#ifdef Q_OS_WIN
+#if defined(Q_OS_WIN) || (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
        emit hideMainWindow();
 #elif defined Q_OS_MACX
        setDockIconVisible(false);
@ -157,7 +142,31 @@ void PageController::setDrawerDepth(const int depth)
    }
 }

-int PageController::getDrawerDepth()
+int PageController::getDrawerDepth() const
 {
    return m_drawerDepth;
 }
+
+int PageController::incrementDrawerDepth()
+{
+    return ++m_drawerDepth;
+}
+
+int PageController::decrementDrawerDepth()
+{
+    if (m_drawerDepth == 0) {
+        return m_drawerDepth;
+    } else {
+        return --m_drawerDepth;
+    }
+}
+
+void PageController::onShowErrorMessage(ErrorCode errorCode)
+{
+    const auto fullErrorMessage = errorString(errorCode);
+    const auto errorMessage = fullErrorMessage.mid(fullErrorMessage.indexOf(". ") + 1); // remove ErrorCode %1.
+    const auto errorUrl = QStringLiteral("https://docs.amnezia.org/troubleshooting/error-codes/#error-%1-%2").arg(static_cast<int>(errorCode)).arg(utils::enumToString(errorCode).toLower());
+    const auto fullMessage = QStringLiteral("<a href=\"%1\" style=\"color: #FBB26A;\">ErrorCode: %2</a>. %3").arg(errorUrl).arg(static_cast<int>(errorCode)).arg(errorMessage);
+
+    emit showErrorMessage(fullMessage);
+}
--- a/client/ui/controllers/pageController.h
+++ b/client/ui/controllers/pageController.h
@ -4,6 +4,7 @@
 #include <QObject>
 #include <QQmlEngine>

+#include "core/defs.h"
 #include "ui/models/servers_model.h"

 namespace PageLoader
@ -30,10 +31,17 @@ namespace PageLoader
        PageSettingsLogging,
        PageSettingsSplitTunneling,
        PageSettingsAppSplitTunneling,
+        PageSettingsApiServerInfo,
+        PageSettingsApiAvailableCountries,
+        PageSettingsApiSupport,
+        PageSettingsApiInstructions,
+        PageSettingsApiNativeConfigs,
+        PageSettingsApiDevices,

        PageServiceSftpSettings,
        PageServiceTorWebsiteSettings,
        PageServiceDnsSettings,
+        PageServiceSocksProxySettings,

        PageSetupWizardStart,
        PageSetupWizardCredentials,
@ -45,17 +53,24 @@ namespace PageLoader
        PageSetupWizardTextKey,
        PageSetupWizardViewConfig,
        PageSetupWizardQrReader,
+        PageSetupWizardApiServicesList,
+        PageSetupWizardApiServiceInfo,

        PageProtocolOpenVpnSettings,
        PageProtocolShadowSocksSettings,
        PageProtocolCloakSettings,
-        PageProtocolXraySettings,        
+        PageProtocolXraySettings,
        PageProtocolWireGuardSettings,
        PageProtocolAwgSettings,
        PageProtocolIKev2Settings,
        PageProtocolRaw,

-        PageShareFullAccess
+        PageProtocolWireGuardClientSettings,
+        PageProtocolAwgClientSettings,
+
+        PageShareFullAccess,
+
+        PageDevMenu
    };
    Q_ENUM_NS(PageEnum)

@ -73,7 +88,7 @@ public:
                            QObject *parent = nullptr);

 public slots:
-    QString getInitialPage();
+    bool isStartPageVisible();
    QString getPagePath(PageLoader::PageEnum page);

    void closeWindow();
@ -91,7 +106,12 @@ public slots:
    void closeApplication();

    void setDrawerDepth(const int depth);
-    int getDrawerDepth();
+    int getDrawerDepth() const;
+    int incrementDrawerDepth();
+    int decrementDrawerDepth();
+
+private slots:
+    void onShowErrorMessage(amnezia::ErrorCode errorCode);

 signals:
    void goToPage(PageLoader::PageEnum page, bool slide = true);
@ -105,8 +125,8 @@ signals:
    void closePage();

    void restorePageHomeState(bool isContainerInstalled = false);
-    void replaceStartPage();

+    void showErrorMessage(amnezia::ErrorCode);
    void showErrorMessage(const QString &errorMessage);
    void showNotificationMessage(const QString &message);

@ -123,9 +143,6 @@ signals:
    void escapePressed();
    void closeTopDrawer();

-    void forceTabBarActiveFocus();
-    void forceStackActiveFocus();
-
 private:
    QSharedPointer<ServersModel> m_serversModel;

--- a/client/ui/controllers/settingsController.cpp
+++ b/client/ui/controllers/settingsController.cpp
@ -88,7 +88,12 @@ void SettingsController::toggleLogging(bool enable)

 void SettingsController::openLogsFolder()
 {
-    Logger::openLogsFolder();
+    Logger::openLogsFolder(false);
+}
+
+void SettingsController::openServiceLogsFolder()
+{
+    Logger::openLogsFolder(true);
 }

 void SettingsController::exportLogsFile(const QString &fileName)
@ -100,12 +105,21 @@ void SettingsController::exportLogsFile(const QString &fileName)
 #endif
 }

+void SettingsController::exportServiceLogsFile(const QString &fileName)
+{
+#ifdef Q_OS_ANDROID
+    AndroidController::instance()->exportLogsFile(fileName);
+#else
+    SystemController::saveFile(fileName, Logger::getServiceLogFile());
+#endif
+}
+
 void SettingsController::clearLogs()
 {
 #ifdef Q_OS_ANDROID
    AndroidController::instance()->clearLogs();
 #else
-    Logger::clearLogs();
+    Logger::clearLogs(false);
    Logger::clearServiceLogs();
 #endif
 }
@ -117,12 +131,8 @@ void SettingsController::backupAppConfig(const QString &fileName)

 void SettingsController::restoreAppConfig(const QString &fileName)
 {
-    QFile file(fileName);
-
-    file.open(QIODevice::ReadOnly);
-
-    QByteArray data = file.readAll();
-
+    QByteArray data;
+    SystemController::readFile(fileName, data);
    restoreAppConfigFromData(data);
 }

@ -252,3 +262,73 @@ void SettingsController::requestNotificationPermission()
    AndroidController::instance()->requestNotificationPermission();
 #endif
 }
+
+QString SettingsController::getInstallationUuid()
+{
+    return m_settings->getInstallationUuid(false);
+}
+
+void SettingsController::enableDevMode()
+{
+    m_isDevModeEnabled = true;
+    emit devModeEnabled();
+}
+
+bool SettingsController::isDevModeEnabled()
+{
+    return m_isDevModeEnabled;
+}
+
+void SettingsController::resetGatewayEndpoint()
+{
+    m_settings->resetGatewayEndpoint();
+    emit gatewayEndpointChanged(m_settings->getGatewayEndpoint());
+}
+
+void SettingsController::setGatewayEndpoint(const QString &endpoint)
+{
+    m_settings->setGatewayEndpoint(endpoint);
+    emit gatewayEndpointChanged(endpoint);
+}
+
+QString SettingsController::getGatewayEndpoint()
+{
+    return m_settings->isDevGatewayEnv() ? "Dev endpoint" : m_settings->getGatewayEndpoint();
+}
+
+bool SettingsController::isDevGatewayEnv()
+{
+    return m_settings->isDevGatewayEnv();
+}
+
+void SettingsController::toggleDevGatewayEnv(bool enabled)
+{
+    m_settings->toggleDevGatewayEnv(enabled);
+    if (enabled) {
+        m_settings->setDevGatewayEndpoint();
+    } else {
+        m_settings->resetGatewayEndpoint();
+    }
+    emit gatewayEndpointChanged(m_settings->getGatewayEndpoint());
+    emit devGatewayEnvChanged(enabled);
+}
+
+bool SettingsController::isOnTv()
+{
+#ifdef Q_OS_ANDROID
+    return AndroidController::instance()->isOnTv();
+#else
+    return false;
+#endif
+}
+
+bool SettingsController::isHomeAdLabelVisible()
+{
+    return m_settings->isHomeAdLabelVisible();
+}
+
+void SettingsController::disableHomeAdLabel()
+{
+    m_settings->disableHomeAdLabel();
+    emit isHomeAdLabelVisibleChanged(false);
+}
--- a/client/ui/controllers/settingsController.h
+++ b/client/ui/controllers/settingsController.h
@ -25,6 +25,12 @@ public:
    Q_PROPERTY(bool isLoggingEnabled READ isLoggingEnabled WRITE toggleLogging NOTIFY loggingStateChanged)
    Q_PROPERTY(bool isNotificationPermissionGranted READ isNotificationPermissionGranted NOTIFY onNotificationStateChanged)

+    Q_PROPERTY(bool isDevModeEnabled READ isDevModeEnabled NOTIFY devModeEnabled)
+    Q_PROPERTY(QString gatewayEndpoint READ getGatewayEndpoint WRITE setGatewayEndpoint NOTIFY gatewayEndpointChanged)
+    Q_PROPERTY(bool isDevGatewayEnv READ isDevGatewayEnv WRITE toggleDevGatewayEnv NOTIFY devGatewayEnvChanged)
+
+    Q_PROPERTY(bool isHomeAdLabelVisible READ isHomeAdLabelVisible NOTIFY isHomeAdLabelVisibleChanged)
+
 public slots:
    void toggleAmneziaDns(bool enable);
    bool isAmneziaDnsEnabled();
@ -39,7 +45,9 @@ public slots:
    void toggleLogging(bool enable);

    void openLogsFolder();
+    void openServiceLogsFolder();
    void exportLogsFile(const QString &fileName);
+    void exportServiceLogsFile(const QString &fileName);
    void clearLogs();

    void backupAppConfig(const QString &fileName);
@ -70,6 +78,22 @@ public slots:
    bool isNotificationPermissionGranted();
    void requestNotificationPermission();

+    QString getInstallationUuid();
+
+    void enableDevMode();
+    bool isDevModeEnabled();
+
+    void resetGatewayEndpoint();
+    void setGatewayEndpoint(const QString &endpoint);
+    QString getGatewayEndpoint();
+    bool isDevGatewayEnv();
+    void toggleDevGatewayEnv(bool enabled);
+
+    bool isOnTv();
+
+    bool isHomeAdLabelVisible();
+    void disableHomeAdLabel();
+
 signals:
    void primaryDnsChanged();
    void secondaryDnsChanged();
@ -89,6 +113,12 @@ signals:

    void onNotificationStateChanged();

+    void devModeEnabled();
+    void gatewayEndpointChanged(const QString &endpoint);
+    void devGatewayEnvChanged(bool enabled);
+
+    void isHomeAdLabelVisibleChanged(bool visible);
+
 private:
    QSharedPointer<ServersModel> m_serversModel;
    QSharedPointer<ContainersModel> m_containersModel;
@ -101,6 +131,8 @@ private:

    QDateTime m_loggingDisableDate;

+    bool m_isDevModeEnabled = false;
+
    void checkIfNeedDisableLogs();
 };

--- a/client/ui/controllers/sitesController.cpp
+++ b/client/ui/controllers/sitesController.cpp
@ -44,7 +44,6 @@ void SitesController::addSite(QString hostname)
            QMetaObject::invokeMethod(m_vpnConnection.get(), "addRoutes", Qt::QueuedConnection,
                                      Q_ARG(QStringList, QStringList() << hostname));
        }
-        QMetaObject::invokeMethod(m_vpnConnection.get(), "flushDns", Qt::QueuedConnection);
    };

    const auto &resolveCallback = [this, processSite](const QHostInfo &hostInfo) {
@ -75,21 +74,18 @@ void SitesController::removeSite(int index)

    QMetaObject::invokeMethod(m_vpnConnection.get(), "deleteRoutes", Qt::QueuedConnection,
                              Q_ARG(QStringList, QStringList() << hostname));
-    QMetaObject::invokeMethod(m_vpnConnection.get(), "flushDns", Qt::QueuedConnection);

    emit finished(tr("Site removed: %1").arg(hostname));
 }

 void SitesController::importSites(const QString &fileName, bool replaceExisting)
 {
-    QFile file(fileName);
-
-    if (!file.open(QIODevice::ReadOnly)) {
+    QByteArray jsonData;
+    if (!SystemController::readFile(fileName, jsonData)) {
        emit errorOccurred(tr("Can't open file: %1").arg(fileName));
        return;
    }

-    QByteArray jsonData = file.readAll();
    QJsonDocument jsonDocument = QJsonDocument::fromJson(jsonData);
    if (jsonDocument.isNull()) {
        emit errorOccurred(tr("Failed to parse JSON data from file: %1").arg(fileName));
@ -126,7 +122,6 @@ void SitesController::importSites(const QString &fileName, bool replaceExisting)
    m_sitesModel->addSites(sites, replaceExisting);

    QMetaObject::invokeMethod(m_vpnConnection.get(), "addRoutes", Qt::QueuedConnection, Q_ARG(QStringList, ips));
-    QMetaObject::invokeMethod(m_vpnConnection.get(), "flushDns", Qt::QueuedConnection);

    emit finished(tr("Import completed"));
 }
--- a/client/ui/controllers/systemController.cpp
+++ b/client/ui/controllers/systemController.cpp
@ -24,7 +24,7 @@ SystemController::SystemController(const std::shared_ptr<Settings> &settings, QO
 {
 }

-void SystemController::saveFile(QString fileName, const QString &data)
+void SystemController::saveFile(const QString &fileName, const QString &data)
 {
 #if defined Q_OS_ANDROID
    AndroidController::instance()->saveFile(fileName, data);
@ -51,8 +51,40 @@ void SystemController::saveFile(QString fileName, const QString &data)
    return;
 #else
    QFileInfo fi(fileName);
-    QDesktopServices::openUrl(fi.absoluteDir().absolutePath());
+
+#ifdef Q_OS_MAC
+    const auto url = "file://" + fi.absoluteDir().absolutePath();
+#else
+    const auto url = fi.absoluteDir().absolutePath();
 #endif
+
+    QDesktopServices::openUrl(url);
+#endif
+}
+
+bool SystemController::readFile(const QString &fileName, QByteArray &data)
+{
+#ifdef Q_OS_ANDROID
+    int fd = AndroidController::instance()->getFd(fileName);
+    if (fd == -1) return false;
+    QFile file;
+    if(!file.open(fd, QIODevice::ReadOnly)) return false;
+    data = file.readAll();
+    AndroidController::instance()->closeFd();
+#else
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly)) return false;
+    data = file.readAll();
+#endif
+    return true;
+}
+
+bool SystemController::readFile(const QString &fileName, QString &data)
+{
+    QByteArray byteArray;
+    if(!readFile(fileName, byteArray)) return false;
+    data = byteArray;
+    return true;
 }

 QString SystemController::getFileName(const QString &acceptLabel, const QString &nameFilter,
@ -118,3 +150,19 @@ void SystemController::setQmlRoot(QObject *qmlRoot)
 {
    m_qmlRoot = qmlRoot;
 }
+
+bool SystemController::isAuthenticated()
+{
+#ifdef Q_OS_ANDROID
+    return AndroidController::instance()->requestAuthentication();
+#else
+    return true;
+#endif
+}
+
+void SystemController::sendTouch(float x, float y)
+{
+#ifdef Q_OS_ANDROID
+    AndroidController::instance()->sendTouch(x, y);
+#endif
+}
--- a/client/ui/controllers/systemController.h
+++ b/client/ui/controllers/systemController.h
@ -11,7 +11,9 @@ class SystemController : public QObject
 public:
    explicit SystemController(const std::shared_ptr<Settings> &setting, QObject *parent = nullptr);

-    static void saveFile(QString fileName, const QString &data);
+    static void saveFile(const QString &fileName, const QString &data);
+    static bool readFile(const QString &fileName, QByteArray &data);
+    static bool readFile(const QString &fileName, QString &data);

 public slots:
    QString getFileName(const QString &acceptLabel, const QString &nameFilter, const QString &selectedFile = "",
@ -19,6 +21,9 @@ public slots:

    void setQmlRoot(QObject *qmlRoot);

+    bool isAuthenticated();
+    void sendTouch(float x, float y);
+
 signals:
    void fileDialogClosed(const bool isAccepted);