feat: ios in-app purchase methods (#1652)

* Add in-app purchase methods * fix: init StoreKit controller on startup * fix: Add transaction details to StoreKit callbacks * nullpointer access fixed * feat: in app purchase for ios * feat: add IAP product fetching and logging for iOS platform * feat: iOS Simulator building pipeline made * feat: add support for multiple IAP product IDs and attempt purchase of the first valid one * feat: add support for retrieving Base64-encoded app receipt after successful IAP purchase * refactor: inapp-purchase code cleanup * feat: iap processing * refactor: move to storekit 2 * feat: add request to billing * chore: add ios ifdef * feat: remove iOS simulator specific code and exclusions * refactor: remove unused StoreKit 2 transaction observer and simplify IAP product fetching logic * feat: implement StoreKit 2 for iOS and macOS, add restore purchases functionality * fix: Restore Purchases button appearance updated * feat: enhance error handling and duplicate config detection in ApiConfigsController * feat: add support for Mac OS NE in-app purchases and StoreKitController * ci-cd fix * Revert "ci-cd fix" This reverts commit f22fd7a13bb093205a81561e4e397d2075776646. --------- Co-authored-by: vladimir.kuznetsov <nethiuswork@gmail.com> Co-authored-by: vkamn <vk@amnezia.org> Co-authored-by: spectrum <yyy@amnezia.org>
2026-05-17 08:36:37 +03:00 · 2025-12-18 16:36:12 +02:00
parent 46ce22b85c
commit 6178b05643
22 changed files with 910 additions and 14 deletions
--- a/client/ui/controllers/api/apiConfigsController.cpp
+++ b/client/ui/controllers/api/apiConfigsController.cpp
@@ -1,8 +1,9 @@
 #include "apiConfigsController.h"

 #include <QClipboard>
+#include <QDebug>
 #include <QEventLoop>
-
+#include <QSet>
 #include "amnezia_application.h"
 #include "configurators/wireguard_configurator.h"
 #include "core/api/apiDefs.h"
@@ -12,6 +13,8 @@
 #include "ui/controllers/systemController.h"
 #include "version.h"

+#include "platforms/ios/ios_controller.h"
+
 namespace
 {
    namespace configKey
@@ -173,7 +176,7 @@ namespace
            auto clientProtocolConfig =
                    QJsonDocument::fromJson(serverProtocolConfig.value(config_key::last_config).toString().toUtf8()).object();

-            // TODO looks like this block can be removed after v1 configs EOL
+            //TODO looks like this block can be removed after v1 configs EOL

            serverProtocolConfig[config_key::junkPacketCount] = clientProtocolConfig.value(config_key::junkPacketCount);
            serverProtocolConfig[config_key::junkPacketMinSize] = clientProtocolConfig.value(config_key::junkPacketMinSize);
@@ -397,6 +400,259 @@ bool ApiConfigsController::fillAvailableServices()

    QJsonObject data = QJsonDocument::fromJson(responseBody).object();
    m_apiServicesModel->updateModel(data);
+    if (m_apiServicesModel->rowCount() > 0) {
+        m_apiServicesModel->setServiceIndex(0);
+    }
+    return true;
+}
+
+bool ApiConfigsController::importSerivceFromAppStore()
+{
+#if defined(Q_OS_IOS) || defined(MACOS_NE)
+    QString chosenProductId;
+    {
+        const QStringList productIds = { QStringLiteral("com.amnezia.amneziavpn.1_month"), QStringLiteral("com.amnezia.AmneziaVPN.6_month") };
+        qInfo().noquote() << "[IAP] Fetching products" << productIds;
+
+        QList<QVariantMap> products;
+        QString fetchError;
+        QEventLoop waitFetch;
+        IosController::Instance()->fetchProducts(productIds,
+                                                 [&](const QList<QVariantMap> &prods, const QStringList &invalid, const QString &err) {
+                                                     products = prods;
+                                                     fetchError = err;
+                                                     qInfo().noquote() << "[IAP] Fetch callback" << "invalid=" << invalid
+                                                                       << "error=" << err;
+                                                     waitFetch.quit();
+                                                 });
+        waitFetch.exec();
+
+        qInfo().noquote() << "[IAP] Product fetch completed; success =" << fetchError.isEmpty()
+                          << "returned =" << products.size() << "invalid =" << !fetchError.isEmpty();
+
+        if (fetchError.isEmpty() && !products.isEmpty()) {
+            chosenProductId = products.first().value("productId").toString();
+        }
+        if (chosenProductId.isEmpty() && !productIds.isEmpty()) {
+            chosenProductId = productIds.first();
+        }
+        qInfo().noquote() << "[IAP] Chosen product =" << chosenProductId;
+    }
+
+    bool purchaseOk = false;
+    QString originalTransactionId;
+    QString storeTransactionId;
+    QString storeProductId;
+    QString purchaseError;
+    QEventLoop waitPurchase;
+    IosController::Instance()->purchaseProduct(chosenProductId,
+                                                [&](bool success, const QString &txId, const QString &purchasedProductId,
+                                                    const QString &originalTxId, const QString &errorString) {
+                                                   purchaseOk = success;
+                                                   originalTransactionId = originalTxId;
+                                                   storeTransactionId = txId;
+                                                   storeProductId = purchasedProductId;
+                                                   purchaseError = errorString;
+                                                   waitPurchase.quit();
+                                               });
+    waitPurchase.exec();
+
+    if (!purchaseOk || originalTransactionId.isEmpty()) {
+        qDebug() << "IAP purchase failed:" << purchaseError;
+        emit errorOccurred(ErrorCode::ApiPurchaseError);
+        return false;
+    }
+    qInfo().noquote() << "[IAP] Purchase success. transactionId =" << storeTransactionId
+                      << "originalTransactionId =" << originalTransactionId
+                      << "productId =" << storeProductId;
+
+    GatewayRequestData gatewayRequestData { QSysInfo::productType(),
+                                            QString(APP_VERSION),
+                                            m_settings->getInstallationUuid(true),
+                                            m_apiServicesModel->getCountryCode(),
+                                            "",
+                                            m_apiServicesModel->getSelectedServiceType(),
+                                            m_apiServicesModel->getSelectedServiceProtocol(),
+                                            QJsonObject() };
+
+    QJsonObject apiPayload = gatewayRequestData.toJsonObject();
+    apiPayload[apiDefs::key::transactionId] = originalTransactionId;
+    qInfo().noquote() << "[IAP] Sending subscription request. Payload:"
+                      << QJsonDocument(apiPayload).toJson(QJsonDocument::Compact);
+
+    ErrorCode errorCode;
+    QByteArray responseBody;
+    errorCode = executeRequest(QString("%1v1/subscriptions"), apiPayload, responseBody);
+    if (errorCode != ErrorCode::NoError) {
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    ErrorCode installError = ErrorCode::NoError;
+    if (!installServerFromSubscriptionResponse(responseBody, &installError)) {
+        const ErrorCode errorToEmit = installError == ErrorCode::NoError ? ErrorCode::ApiPurchaseError : installError;
+        emit errorOccurred(errorToEmit);
+        return false;
+    }
+
+    qInfo().noquote() << "[IAP] Subscription config installed after purchase";
+    emit installServerFromApiFinished(tr("%1 installed successfully.").arg(m_apiServicesModel->getSelectedServiceName()));
+#endif
+    return true;
+}
+
+bool ApiConfigsController::restoreSerivceFromAppStore()
+{
+#if defined(Q_OS_IOS) || defined(MACOS_NE)
+    const QString premiumServiceType = QStringLiteral("amnezia-premium");
+    const QString originalServiceType = m_apiServicesModel->rowCount() > 0 ? m_apiServicesModel->getSelectedServiceType() : QString();
+
+    if (m_apiServicesModel->rowCount() <= 0) {
+        qInfo().noquote() << "[IAP] Services model is empty before restore, requesting available services";
+        if (!fillAvailableServices()) {
+            qWarning().noquote() << "[IAP] Unable to fetch services list before restore";
+            emit errorOccurred(ErrorCode::ApiServicesMissingError);
+            return false;
+        }
+    }
+
+    if (m_apiServicesModel->rowCount() <= 0) {
+        qWarning().noquote() << "[IAP] Restore aborted: services list is still empty";
+        emit errorOccurred(ErrorCode::ApiServicesMissingError);
+        return false;
+    }
+    // Ensure we have a valid premium selection for gateway requests
+    bool premiumSelected = false;
+    for (int i = 0; i < m_apiServicesModel->rowCount(); ++i) {
+        m_apiServicesModel->setServiceIndex(i);
+        if (m_apiServicesModel->getSelectedServiceType() == premiumServiceType) {
+            premiumSelected = true;
+            break;
+        }
+    }
+    if (!premiumSelected) {
+        m_apiServicesModel->setServiceIndex(0);
+    }
+
+    bool restoreSuccess = false;
+    QList<QVariantMap> restoredTransactions;
+    QString restoreError;
+    QEventLoop waitRestore;
+
+    IosController::Instance()->restorePurchases([&](bool success,
+                                                    const QList<QVariantMap> &transactions,
+                                                    const QString &errorString) {
+        restoreSuccess = success;
+        restoredTransactions = transactions;
+        restoreError = errorString;
+        waitRestore.quit();
+    });
+    waitRestore.exec();
+
+    if (!restoreSuccess) {
+        qWarning().noquote() << "[IAP] Restore failed:" << restoreError;
+        emit errorOccurred(ErrorCode::ApiPurchaseError);
+        return false;
+    }
+
+    if (restoredTransactions.isEmpty()) {
+        qInfo().noquote() << "[IAP] Restore completed, but no transactions were returned";
+        emit errorOccurred(ErrorCode::ApiPurchaseError);
+        return false;
+    }
+
+    bool hasInstalledConfig = false;
+    bool duplicateConfigAlreadyPresent = false;
+    int duplicateCount = 0;
+    QSet<QString> processedTransactions;
+    for (const QVariantMap &transaction : restoredTransactions) {
+        const QString originalTransactionId = transaction.value(QStringLiteral("originalTransactionId")).toString();
+        const QString transactionId = transaction.value(QStringLiteral("transactionId")).toString();
+        const QString productId = transaction.value(QStringLiteral("productId")).toString();
+
+        if (originalTransactionId.isEmpty()) {
+            qWarning().noquote() << "[IAP] Skipping restored transaction without originalTransactionId"
+                                 << transactionId;
+            continue;
+        }
+
+        if (processedTransactions.contains(originalTransactionId)) {
+            duplicateCount++;
+            continue;
+        }
+        processedTransactions.insert(originalTransactionId);
+
+        qInfo().noquote() << "[IAP] Restoring subscription. transactionId =" << transactionId
+                          << "originalTransactionId =" << originalTransactionId
+                          << "productId =" << productId;
+
+        GatewayRequestData gatewayRequestData { QSysInfo::productType(),
+                                                QString(APP_VERSION),
+                                                m_settings->getInstallationUuid(true),
+                                                m_apiServicesModel->getCountryCode(),
+                                                "",
+                                                m_apiServicesModel->getSelectedServiceType(),
+                                                m_apiServicesModel->getSelectedServiceProtocol(),
+                                                QJsonObject() };
+
+        QJsonObject apiPayload = gatewayRequestData.toJsonObject();
+        apiPayload[apiDefs::key::transactionId] = originalTransactionId;
+
+        QByteArray responseBody;
+        ErrorCode errorCode = executeRequest(QString("%1v1/subscriptions"), apiPayload, responseBody);
+        if (errorCode != ErrorCode::NoError) {
+            qWarning().noquote() << "[IAP] Failed to restore transaction" << originalTransactionId
+                                 << "errorCode =" << static_cast<int>(errorCode);
+            continue;
+        }
+
+        ErrorCode installError = ErrorCode::NoError;
+        if (!installServerFromSubscriptionResponse(responseBody, &installError)) {
+            if (installError == ErrorCode::ApiConfigAlreadyAdded) {
+                duplicateConfigAlreadyPresent = true;
+                qInfo().noquote() << "[IAP] Skipping restored transaction" << originalTransactionId
+                                  << "because subscription config with the same vpn_key already exists";
+            } else {
+                qWarning().noquote() << "[IAP] Failed to process restored subscription response for transaction"
+                                     << originalTransactionId;
+            }
+            continue;
+        }
+
+        hasInstalledConfig = true;
+    }
+
+    if (!hasInstalledConfig) {
+        const ErrorCode restoreError = duplicateConfigAlreadyPresent ? ErrorCode::ApiConfigAlreadyAdded : ErrorCode::ApiPurchaseError;
+        emit errorOccurred(restoreError);
+        // Restore previous selection so that start page state is unchanged.
+        if (!originalServiceType.isEmpty()) {
+            for (int i = 0; i < m_apiServicesModel->rowCount(); ++i) {
+                m_apiServicesModel->setServiceIndex(i);
+                if (m_apiServicesModel->getSelectedServiceType() == originalServiceType) {
+                    break;
+                }
+            }
+        }
+        return false;
+    }
+
+    emit installServerFromApiFinished(tr("Subscription restored successfully."));
+    if (duplicateCount > 0) {
+        qInfo().noquote() << "[IAP] Skipped" << duplicateCount
+                          << "duplicate restored transactions for original transaction IDs already processed";
+    }
+
+    // Restore previous selection if it differs from premium
+    if (!originalServiceType.isEmpty() && originalServiceType != premiumServiceType) {
+        for (int i = 0; i < m_apiServicesModel->rowCount(); ++i) {
+            m_apiServicesModel->setServiceIndex(i);
+            if (m_apiServicesModel->getSelectedServiceType() == originalServiceType) {
+                break;
+            }
+        }
+    }
+#endif
    return true;
 }

@@ -423,8 +679,10 @@ bool ApiConfigsController::importServiceFromGateway()
    QJsonObject apiPayload = gatewayRequestData.toJsonObject();
    appendProtocolDataToApiPayload(gatewayRequestData.serviceProtocol, protocolData, apiPayload);

+    ErrorCode errorCode;
    QByteArray responseBody;
-    ErrorCode errorCode = executeRequest(QString("%1v1/config"), apiPayload, responseBody);
+
+    errorCode = executeRequest(QString("%1v1/config"), apiPayload, responseBody);

    QJsonObject serverConfig;
    if (errorCode == ErrorCode::NoError) {
@@ -706,7 +964,7 @@ QList<QString> ApiConfigsController::getQrCodes()

 int ApiConfigsController::getQrCodesCount()
 {
-    return m_qrCodes.size();
+    return static_cast<int>(m_qrCodes.size());
 }

 QString ApiConfigsController::getVpnKey()
@@ -714,6 +972,92 @@ QString ApiConfigsController::getVpnKey()
    return m_vpnKey;
 }

+bool ApiConfigsController::installServerFromSubscriptionResponse(const QByteArray &responseBody, ErrorCode *errorOut)
+{
+#ifdef Q_OS_IOS
+    if (errorOut) {
+        *errorOut = ErrorCode::NoError;
+    }
+    QJsonParseError parseError {};
+    QJsonDocument responseDoc = QJsonDocument::fromJson(responseBody, &parseError);
+    if (parseError.error == QJsonParseError::NoError) {
+        qInfo().noquote() << "[IAP] Subscription raw response" << responseDoc.toJson(QJsonDocument::Compact);
+    } else {
+        qWarning().noquote() << "[IAP] Subscription raw response parse error:" << parseError.errorString()
+                             << "raw=" << QString::fromUtf8(responseBody);
+    }
+
+    const QJsonObject responseObject = responseDoc.object();
+    QString key = responseObject.value(QStringLiteral("key")).toString();
+    if (key.isEmpty()) {
+        qWarning().noquote() << "[IAP] Subscription response does not contain a key field";
+        if (errorOut) {
+            *errorOut = ErrorCode::ApiPurchaseError;
+        }
+        return false;
+    }
+
+    if (m_serversModel->hasServerWithVpnKey(key)) {
+        qInfo().noquote() << "[IAP] Subscription config with the same vpn_key already exists";
+        if (errorOut) {
+            *errorOut = ErrorCode::ApiConfigAlreadyAdded;
+        }
+        return false;
+    }
+
+    QString normalizedKey = key;
+    normalizedKey.replace(QStringLiteral("vpn://"), QString());
+
+    QByteArray config = QByteArray::fromBase64(normalizedKey.toUtf8(),
+                                               QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+    QByteArray configUncompressed = qUncompress(config);
+    if (!configUncompressed.isEmpty()) {
+        config = configUncompressed;
+    }
+    if (config.isEmpty()) {
+        qWarning().noquote() << "[IAP] Subscription response config payload is empty";
+        if (errorOut) {
+            *errorOut = ErrorCode::ApiPurchaseError;
+        }
+        return false;
+    }
+
+    QJsonParseError configParseError {};
+    QJsonDocument configDoc = QJsonDocument::fromJson(config, &configParseError);
+    if (configParseError.error != QJsonParseError::NoError) {
+        qWarning().noquote() << "[IAP] Failed to parse subscription config:" << configParseError.errorString();
+        if (errorOut) {
+            *errorOut = ErrorCode::ApiPurchaseError;
+        }
+        return false;
+    }
+
+    QJsonObject configJson = configDoc.object();
+
+    quint16 crc = qChecksum(QJsonDocument(configJson).toJson());
+    auto apiConfig = configJson.value(apiDefs::key::apiConfig).toObject();
+    apiConfig[apiDefs::key::vpnKey] = normalizedKey;
+    auto subscriptionObject = apiConfig.value(configKey::subscription).toObject();
+    qInfo().noquote() << "[IAP] Subscription payload details" << "serviceType="
+                      << apiConfig.value(configKey::serviceType).toString()
+                      << "serviceProtocol=" << apiConfig.value(configKey::serviceProtocol).toString()
+                      << "subscriptionEnd=" << subscriptionObject.value(apiDefs::key::subscriptionEndDate).toString()
+                      << "subscriptionType=" << subscriptionObject.value(QStringLiteral("type")).toString();
+    configJson.insert(apiDefs::key::apiConfig, apiConfig);
+    configJson.insert(config_key::crc, crc);
+    m_serversModel->addServer(configJson);
+
+    qDebug() << configJson;
+    return true;
+#else
+    Q_UNUSED(responseBody)
+    if (errorOut) {
+        *errorOut = ErrorCode::ApiPurchaseError;
+    }
+    return false;
+#endif
+}
+
 ErrorCode ApiConfigsController::executeRequest(const QString &endpoint, const QJsonObject &apiPayload, QByteArray &responseBody)
 {
    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs,