fix: keep pinned go.mod when building amnezia-libxray

fix: double purchase android
fix: rename restore function, fix icon resource error
2026-07-18 06:40:06 +03:00 · 2026-07-11 11:38:39 +03:00 · 2026-07-10 23:45:58 +03:00 · 2026-07-10 15:30:35 +03:00 · 2026-07-08 21:08:40 +03:00 · 2026-07-08 20:59:39 +03:00
34 changed files with 1392 additions and 69 deletions
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -854,13 +854,41 @@ jobs:
        VERSION=$(grep CMAKE_PROJECT_VERSION:STATIC deploy/build/CMakeCache.txt | cut -d= -f2)

        (cd deploy/build/client/android-build && mv AmneziaVPN.apk AmneziaVPN_${VERSION}_android9+_universal.apk)
-        (cd deploy/build/client/android-build/build/outputs/bundle/release && mv android-build-release.aab AmneziaVPN_${VERSION}.aab)
+        (cd deploy/build/client/android-build/build/outputs/bundle/release && mv android-build-release.aab AmneziaVPN_${VERSION}_oss.aab)

        for abi in arm64-v8a armeabi-v7a x86 x86_64; do
          deploy/build.sh -t android --sign --abi ${abi} --build ./deploy/build/${abi}
          (cd deploy/build/${abi}/client/android-build && mv AmneziaVPN.apk AmneziaVPN_${VERSION}_android9+_${abi}.apk)
        done

+    - name: 'Build Play AAB'
+      env:
+        QT_INSTALL_DIR: ${{ runner.temp }}
+        QT_ANDROID_KEYSTORE_PATH: ${{ github.workspace }}/android.keystore
+        QT_ANDROID_KEYSTORE_ALIAS: ${{ secrets.ANDROID_RELEASE_KEYSTORE_KEY_ALIAS }}
+        QT_ANDROID_KEYSTORE_STORE_PASS: ${{ secrets.ANDROID_RELEASE_KEYSTORE_KEY_PASS }}
+      shell: bash
+      run: |
+        VERSION=$(grep CMAKE_PROJECT_VERSION:STATIC deploy/build/CMakeCache.txt | cut -d= -f2)
+
+        deploy/build.sh -t android --sign --aab --play --build ./deploy/build/play
+
+        (cd deploy/build/play/client/android-build/build/outputs/bundle/playRelease && mv *.aab AmneziaVPN_${VERSION}_play.aab)
+
+    - name: 'Build Play APK'
+      env:
+        QT_INSTALL_DIR: ${{ runner.temp }}
+        QT_ANDROID_KEYSTORE_PATH: ${{ github.workspace }}/android.keystore
+        QT_ANDROID_KEYSTORE_ALIAS: ${{ secrets.ANDROID_RELEASE_KEYSTORE_KEY_ALIAS }}
+        QT_ANDROID_KEYSTORE_STORE_PASS: ${{ secrets.ANDROID_RELEASE_KEYSTORE_KEY_PASS }}
+      shell: bash
+      run: |
+        VERSION=$(grep CMAKE_PROJECT_VERSION:STATIC deploy/build/CMakeCache.txt | cut -d= -f2)
+
+        deploy/build.sh -t android --sign --apk --play --abi arm64-v8a --build ./deploy/build/play-apk
+
+        (cd deploy/build/play-apk/client/android-build/build/outputs/apk/play/release && mv *.apk AmneziaVPN_${VERSION}_play.apk)
+
    - name: 'Upload universal APK'
      uses: actions/upload-artifact@v7
      with:
@@ -868,13 +896,27 @@ jobs:
        archive: false
        retention-days: 7

-    - name: 'Upload AAB'
+    - name: 'Upload OSS AAB'
      uses: actions/upload-artifact@v7
      with:
        path: deploy/build/client/android-build/build/outputs/bundle/release/*.aab
        archive: false
        retention-days: 7

+    - name: 'Upload Play AAB'
+      uses: actions/upload-artifact@v7
+      with:
+        path: deploy/build/play/client/android-build/build/outputs/bundle/playRelease/*.aab
+        archive: false
+        retention-days: 7
+
+    - name: 'Upload Play APK'
+      uses: actions/upload-artifact@v7
+      with:
+        path: deploy/build/play-apk/client/android-build/build/outputs/apk/play/release/*.apk
+        archive: false
+        retention-days: 7
+
    - name: 'Upload arm64-v8a APK'
      uses: actions/upload-artifact@v7
      with:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.9.0.3)
+set(AMNEZIAVPN_VERSION 4.8.16.3)

 set(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP ON CACHE BOOL "" FORCE)
 set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES
@@ -28,7 +28,7 @@ string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
 set(RELEASE_DATE "${CURRENT_DATE}")

 set(APP_MAJOR_VERSION ${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH})
-set(APP_ANDROID_VERSION_CODE 2131)
+set(APP_ANDROID_VERSION_CODE 2134)

 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
    set(MZ_PLATFORM_NAME "linux")
--- a/client/amneziaApplication.cpp
+++ b/client/amneziaApplication.cpp
@@ -26,6 +26,10 @@
 #include "version.h"

 #include "platforms/ios/QRCodeReaderBase.h"
+
+#ifdef Q_OS_ANDROID
+#include "platforms/android/android_controller.h"
+#endif
         

 bool AmneziaApplication::m_forceQuit = false;
@@ -139,6 +143,12 @@ void AmneziaApplication::init()
    m_engine->rootContext()->setContextProperty("IsMacOsNeBuild", false);
 #endif

+#ifdef Q_OS_ANDROID
+    m_engine->rootContext()->setContextProperty("IsPlayBuild", AndroidController::instance()->isPlay());
+#else
+    m_engine->rootContext()->setContextProperty("IsPlayBuild", false);
+#endif
+
    m_vpnConnection.reset(new VpnConnection(nullptr, nullptr));
    m_vpnConnection->moveToThread(&m_vpnConnectionThread);
    m_vpnConnectionThread.start();
--- a/client/android/billing/build.gradle.kts
+++ b/client/android/billing/build.gradle.kts
@@ -0,0 +1,19 @@
+plugins {
+    id(libs.plugins.android.library.get().pluginId)
+    id(libs.plugins.kotlin.android.get().pluginId)
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+android {
+    namespace = "org.amnezia.vpn.billing"
+}
+
+dependencies {
+    compileOnly(project(":utils"))
+    implementation(libs.androidx.core)
+    implementation(libs.kotlinx.coroutines)
+    implementation(libs.android.billing)
+}
--- a/client/android/billing/src/main/kotlin/BillingException.kt
+++ b/client/android/billing/src/main/kotlin/BillingException.kt
@@ -0,0 +1,65 @@
+import com.android.billingclient.api.BillingClient.BillingResponseCode.BILLING_UNAVAILABLE
+import com.android.billingclient.api.BillingClient.BillingResponseCode.DEVELOPER_ERROR
+import com.android.billingclient.api.BillingClient.BillingResponseCode.ERROR
+import com.android.billingclient.api.BillingClient.BillingResponseCode.FEATURE_NOT_SUPPORTED
+import com.android.billingclient.api.BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED
+import com.android.billingclient.api.BillingClient.BillingResponseCode.ITEM_NOT_OWNED
+import com.android.billingclient.api.BillingClient.BillingResponseCode.ITEM_UNAVAILABLE
+import com.android.billingclient.api.BillingClient.BillingResponseCode.NETWORK_ERROR
+import com.android.billingclient.api.BillingClient.BillingResponseCode.SERVICE_DISCONNECTED
+import com.android.billingclient.api.BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE
+import com.android.billingclient.api.BillingClient.BillingResponseCode.USER_CANCELED
+import com.android.billingclient.api.BillingResult
+import org.amnezia.vpn.util.ErrorCode
+
+internal class BillingException(
+    billingResult: BillingResult,
+    retryable: Boolean = false
+) : Exception(billingResult.toString()) {
+
+    constructor(msg: String) : this(BillingResult.newBuilder()
+        .setResponseCode(DEVELOPER_ERROR)
+        .setDebugMessage(msg)
+        .build())
+
+    val errorCode: Int
+    val isCanceled = billingResult.responseCode == USER_CANCELED
+    val isRetryable = retryable || billingResult.responseCode in setOf(
+        NETWORK_ERROR,
+        SERVICE_DISCONNECTED,
+        SERVICE_UNAVAILABLE,
+        ERROR
+    )
+
+    init {
+        when (billingResult.responseCode) {
+            ERROR -> {
+                errorCode = ErrorCode.BillingGooglePlayError
+            }
+
+            BILLING_UNAVAILABLE, SERVICE_DISCONNECTED, SERVICE_UNAVAILABLE -> {
+                errorCode = ErrorCode.BillingUnavailable
+            }
+
+            DEVELOPER_ERROR, FEATURE_NOT_SUPPORTED, ITEM_NOT_OWNED -> {
+                errorCode = ErrorCode.BillingError
+            }
+
+            ITEM_ALREADY_OWNED -> {
+                errorCode = ErrorCode.SubscriptionAlreadyOwned
+            }
+
+            ITEM_UNAVAILABLE -> {
+                errorCode = ErrorCode.SubscriptionUnavailable
+            }
+
+            NETWORK_ERROR -> {
+                errorCode = ErrorCode.BillingNetworkError
+            }
+
+            else -> {
+                errorCode = ErrorCode.BillingError
+            }
+        }
+    }
+}
--- a/client/android/billing/src/main/kotlin/BillingProvider.kt
+++ b/client/android/billing/src/main/kotlin/BillingProvider.kt
@@ -0,0 +1,321 @@
+import android.app.Activity
+import android.content.Context
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingFlowParams
+import com.android.billingclient.api.BillingFlowParams.SubscriptionUpdateParams.ReplacementMode
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.GetBillingConfigParams
+import com.android.billingclient.api.PendingPurchasesParams
+import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryProductDetailsParams.Product
+import com.android.billingclient.api.QueryPurchasesParams
+import com.android.billingclient.api.acknowledgePurchase
+import com.android.billingclient.api.queryProductDetails
+import com.android.billingclient.api.queryPurchasesAsync
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.withContext
+import org.amnezia.vpn.util.ErrorCode
+import org.amnezia.vpn.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+
+private const val TAG = "BillingProvider"
+private const val PRODUCT_ID = "premium"
+
+class BillingProvider(context: Context) : AutoCloseable {
+
+    private var billingClient: BillingClient
+    private var subscriptionPurchases = MutableStateFlow<Pair<BillingResult, List<Purchase>?>?>(null)
+
+    private val purchasesUpdatedListeners = PurchasesUpdatedListener { billingResult, purchases ->
+        Log.v(TAG, "Purchases updated: $billingResult")
+        subscriptionPurchases.value = billingResult to purchases
+    }
+
+    init {
+        billingClient = BillingClient.newBuilder(context)
+            .setListener(purchasesUpdatedListeners)
+            .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
+            .build()
+    }
+
+    private suspend fun connect() {
+        if (billingClient.isReady) return
+
+        Log.v(TAG, "Billing client connection")
+        val connection = CompletableDeferred<Unit>()
+        withContext(Dispatchers.IO) {
+            billingClient.startConnection(object : BillingClientStateListener {
+                override fun onBillingSetupFinished(billingResult: BillingResult) {
+                    Log.v(TAG, "Billing setup finished: $billingResult")
+                    if (billingResult.isOk) {
+                        connection.complete(Unit)
+                    } else {
+                        Log.e(TAG, "Billing setup failed: $billingResult")
+                        connection.completeExceptionally(BillingException(billingResult))
+                    }
+                }
+
+                override fun onBillingServiceDisconnected() {
+                    Log.w(TAG, "Billing service disconnected")
+                }
+            })
+        }
+        connection.await()
+    }
+
+    private suspend fun handleBillingApiCall(block: suspend () -> JSONObject): JSONObject {
+        val numberAttempts = 3
+        var attemptCount = 0
+        while (true) {
+            try {
+                return block()
+            } catch (e: BillingException) {
+                if (e.isCanceled) {
+                    Log.w(TAG, "Billing canceled")
+                    return JSONObject().put("responseCode", ErrorCode.BillingCanceled)
+                } else if (e.isRetryable && attemptCount < numberAttempts) {
+                    Log.d(TAG, "Retryable error: $e")
+                    ++attemptCount
+                    delay(1000)
+                } else {
+                    Log.e(TAG, "Billing error: $e")
+                    return JSONObject().put("responseCode", e.errorCode)
+                }
+            } catch (_: CancellationException) {
+                Log.w(TAG, "Billing coroutine canceled")
+                return JSONObject().put("responseCode", ErrorCode.BillingCanceled)
+            }
+        }
+    }
+
+    suspend fun getSubscriptionPlans(): JSONObject {
+        Log.v(TAG, "Get subscription plans")
+
+        val productDetailsList = getProductDetails()
+        val resultJson = JSONObject().put("responseCode", ErrorCode.NoError)
+        val productArray = JSONArray().also { resultJson.put("products", it) }
+        productDetailsList?.forEach { productDetails ->
+            val product = JSONObject().also { productArray.put(it) }
+                .put("productId", productDetails.productId)
+                .put("name", productDetails.name)
+            val offers = JSONArray().also { product.put("offers", it) }
+            productDetails.subscriptionOfferDetails?.forEach { offerDetails ->
+                val offer = JSONObject().also { offers.put(it) }
+                    .put("basePlanId", offerDetails.basePlanId)
+                    .put("offerId", offerDetails.offerId)
+                    .put("offerToken", offerDetails.offerToken)
+                val pricingPhases = JSONArray().also { offer.put("pricingPhases", it) }
+                offerDetails.pricingPhases.pricingPhaseList.forEach { phase ->
+                    JSONObject().also { pricingPhases.put(it) }
+                        .put("billingCycleCount", phase.billingCycleCount)
+                        .put("billingPeriod", phase.billingPeriod)
+                        .put("formatedPrice", phase.formattedPrice)
+                        .put("recurrenceMode", phase.recurrenceMode)
+                }
+            }
+        }
+        return resultJson
+    }
+
+    private suspend fun getProductDetails(): List<ProductDetails>? {
+        Log.v(TAG, "Get product details")
+
+        val productDetailsParams = Product.newBuilder()
+            .setProductId(PRODUCT_ID)
+            .setProductType(ProductType.SUBS)
+            .build()
+
+        val queryProductDetailsParams = QueryProductDetailsParams.newBuilder()
+            .setProductList(listOf(productDetailsParams))
+            .build()
+
+        val result = withContext(Dispatchers.IO) {
+            billingClient.queryProductDetails(queryProductDetailsParams)
+        }
+
+        Log.v(TAG, "Query product details result: ${result.billingResult}")
+
+        if (!result.billingResult.isOk) {
+            Log.e(TAG, "Failed to get product details: ${result.billingResult}")
+            throw BillingException(result.billingResult)
+        }
+
+        return result.productDetailsList
+    }
+
+    suspend fun getCustomerCountryCode(): JSONObject {
+        Log.v(TAG, "Get customer country code")
+
+        val deferred = CompletableDeferred<String>()
+        withContext(Dispatchers.IO) {
+            billingClient.getBillingConfigAsync(GetBillingConfigParams.newBuilder().build(),
+                { billingResult, billingConfig ->
+                    Log.v(TAG, "Billing config: $billingResult, ${billingConfig?.countryCode}")
+                    if (billingResult.isOk) {
+                        deferred.complete(billingConfig?.countryCode ?: "")
+                    } else {
+                        deferred.completeExceptionally(BillingException(billingResult))
+                    }
+                })
+        }
+        val countryCode = deferred.await()
+
+        return JSONObject()
+            .put("responseCode", ErrorCode.NoError)
+            .put("countryCode", countryCode)
+    }
+
+    suspend fun purchaseSubscription(
+        activity: Activity,
+        offerToken: String,
+        oldPurchaseToken: String? = null
+    ): JSONObject {
+        Log.v(TAG, "Purchase subscription")
+        Log.v(TAG, "Offer token: $offerToken")
+        oldPurchaseToken?.let { Log.v(TAG, "Old purchase token: $it") }
+
+        if (offerToken.isBlank()) throw BillingException("offerToken can not be empty")
+
+        val productDetails = getProductDetails()?.let {
+            it.filter { it.productId == PRODUCT_ID }
+        }?.firstOrNull() ?: throw BillingException("Product details not found")
+
+        Log.v(TAG, "Filtered product details:\n$productDetails")
+
+        val productDetail = BillingFlowParams.ProductDetailsParams.newBuilder()
+            .setProductDetails(productDetails)
+            .setOfferToken(offerToken)
+            .build()
+
+        val subscriptionUpdateParams = oldPurchaseToken?.let {
+            BillingFlowParams.SubscriptionUpdateParams.newBuilder()
+                .setOldPurchaseToken(oldPurchaseToken)
+                .setSubscriptionReplacementMode(ReplacementMode.WITHOUT_PRORATION)
+                .build()
+        }
+
+        val billingResult = billingClient.launchBillingFlow(activity, BillingFlowParams.newBuilder()
+            .setProductDetailsParamsList(listOf(productDetail))
+            .apply { subscriptionUpdateParams?.let { setSubscriptionUpdateParams(it) } }
+            .build())
+
+        Log.v(TAG, "Start billing flow result: $billingResult")
+
+        if (billingResult.responseCode == BillingResponseCode.ITEM_ALREADY_OWNED) {
+            Log.w(TAG, "Attempting to purchase already owned product")
+            val purchases = queryPurchases()
+            if (purchases.any { PRODUCT_ID in it.products }) throw BillingException(billingResult)
+            else throw BillingException(billingResult, retryable = true)
+        } else if (billingResult.responseCode == BillingResponseCode.ITEM_NOT_OWNED) {
+            Log.w(TAG, "Attempting to replace not owned product")
+            val purchases = queryPurchases()
+            if (purchases.all { PRODUCT_ID !in it.products }) throw BillingException(billingResult)
+            else throw BillingException(billingResult, retryable = true)
+        } else if (!billingResult.isOk) throw BillingException(billingResult)
+
+        subscriptionPurchases.firstOrNull { it != null }?.let { (billingResult, purchases) ->
+            if (!billingResult.isOk) throw BillingException(billingResult)
+            return JSONObject()
+                .put("responseCode", ErrorCode.NoError)
+                .put("purchases", processPurchases(purchases))
+        } ?: throw BillingException("Purchase failed")
+    }
+
+    private fun processPurchases(purchases: List<Purchase>?): JSONArray {
+        val purchaseArray = JSONArray()
+        purchases?.forEach { purchase ->
+            Log.v(TAG, "processPurchases: purchaseToken=${purchase.purchaseToken} orderId=${purchase.orderId} state=${purchase.purchaseState}")
+            /* val purchaseJson = */ JSONObject().also { purchaseArray.put(it) }
+                .put("purchaseToken", purchase.purchaseToken)
+                .put("purchaseTime", purchase.purchaseTime)
+                .put("purchaseState", purchase.purchaseState)
+                .put("isAcknowledged", purchase.isAcknowledged)
+                .put("isAutoRenewing", purchase.isAutoRenewing)
+                .put("orderId", purchase.orderId)
+                // .put("productIds", JSONArray(purchase.products))
+
+            /* purchase.pendingPurchaseUpdate?.let { purchaseUpdate ->
+                JSONObject()
+                    .put("purchaseToken", purchaseUpdate.purchaseToken)
+                    // .put("productIds", JSONArray(purchaseUpdate.products))
+            }.also { purchaseJson.put("pendingPurchaseUpdate", it) } */
+        }
+        return purchaseArray
+    }
+
+    suspend fun acknowledge(purchaseToken: String): JSONObject {
+        Log.v(TAG, "Acknowledge purchase: $purchaseToken")
+
+        val result = withContext(Dispatchers.IO) {
+            billingClient.acknowledgePurchase(
+                AcknowledgePurchaseParams.newBuilder()
+                    .setPurchaseToken(purchaseToken)
+                    .build()
+            )
+        }
+
+        Log.v(TAG, "Acknowledge purchase result: $result")
+
+        if (result.responseCode == BillingResponseCode.ITEM_NOT_OWNED) {
+            Log.w(TAG, "Attempting to acknowledge not owned product")
+            val purchases = queryPurchases()
+            if (purchases.all { PRODUCT_ID !in it.products }) throw BillingException(result)
+            else throw BillingException(result, retryable = true)
+        } else if (!result.isOk && result.responseCode != BillingResponseCode.ITEM_ALREADY_OWNED) {
+            throw BillingException(result)
+        }
+
+        return JSONObject().put("responseCode", ErrorCode.NoError)
+    }
+
+    suspend fun getPurchases(): JSONObject {
+        Log.v(TAG, "Get purchases")
+        val purchases = queryPurchases()
+        return JSONObject()
+            .put("responseCode", ErrorCode.NoError)
+            .put("purchases", processPurchases(purchases))
+    }
+
+    private suspend fun queryPurchases(): List<Purchase> {
+        Log.v(TAG, "Query purchases")
+        val result = withContext(Dispatchers.IO) {
+            billingClient.queryPurchasesAsync(
+                QueryPurchasesParams.newBuilder().setProductType(ProductType.SUBS).build()
+            )
+        }
+        Log.v(TAG, "Query purchases result: ${result.billingResult}")
+        if (!result.billingResult.isOk) throw BillingException(result.billingResult)
+        return result.purchasesList
+    }
+
+    override fun close() {
+        Log.v(TAG, "Close billing client connection")
+        billingClient.endConnection()
+    }
+
+    companion object {
+        suspend fun withBillingProvider(context: Context, block: suspend BillingProvider.() -> JSONObject): String =
+            BillingProvider(context).use { bp ->
+                bp.handleBillingApiCall {
+                    bp.connect()
+                    bp.block()
+                }.toString()
+            }
+    }
+}
+
+internal val BillingResult.isOk: Boolean
+    get() = responseCode == BillingResponseCode.OK
--- a/client/android/build.gradle.kts
+++ b/client/android/build.gradle.kts
@@ -20,6 +20,7 @@ android {
    namespace = "org.amnezia.vpn"

    buildFeatures {
+        buildConfig = true
        viewBinding = true
    }

@@ -33,13 +34,56 @@ android {
        jniLibs.useLegacyPackaging = true
    }

+    val abiList = qtTargetAbiList.split(",")
+
    defaultConfig {
        applicationId = "org.amnezia.vpn"
        targetSdk = qtTargetSdkVersion.toInt()

        // keeps language resources for only the locales specified below
        resourceConfigurations += listOf("en", "ru", "b+zh+Hans")
-        ndk.abiFilters += qtTargetAbiList.split(",")
+        // ndk.abiFilters is only used for single-ABI builds; multi-ABI uses splits below
+        if (abiList.size == 1) {
+            ndk.abiFilters += abiList
+        }
+    }
+
+    signingConfigs {
+        register("release") {
+            storeFile = providers.environmentVariable("QT_ANDROID_KEYSTORE_PATH").orNull?.let { file(it) }
+            storePassword = providers.environmentVariable("QT_ANDROID_KEYSTORE_STORE_PASS").orNull
+            keyAlias = providers.environmentVariable("QT_ANDROID_KEYSTORE_ALIAS").orNull
+            keyPassword = providers.environmentVariable("QT_ANDROID_KEYSTORE_STORE_PASS").orNull
+        }
+    }
+
+    buildTypes {
+        release {
+            // exclude coroutine debug resource from release build
+            packaging {
+                resources.excludes += "DebugProbesKt.bin"
+            }
+            signingConfig = signingConfigs["release"]
+        }
+
+        create("fdroid") {
+            initWith(getByName("release"))
+            signingConfig = null
+            matchingFallbacks += "release"
+        }
+    }
+
+    flavorDimensions += "billing"
+
+    productFlavors {
+        create("oss") {
+            dimension = "billing"
+            buildConfigField("boolean", "IS_PLAY_BUILD", "false")
+        }
+        create("play") {
+            dimension = "billing"
+            buildConfigField("boolean", "IS_PLAY_BUILD", "true")
+        }
    }

    sourceSets {
@@ -51,13 +95,74 @@ android {
            assets.setSrcDirs(listOf("assets"))
            jniLibs.setSrcDirs(listOf("libs"))
        }
+
+        getByName("oss") {
+            java.setSrcDirs(listOf("oss"))
+        }
+
+        getByName("play") {
+            java.setSrcDirs(listOf("play"))
+        }
    }

-    buildTypes {
-        release {
-            // exclude coroutine debug resource from release build
-            packaging {
-                resources.excludes += "DebugProbesKt.bin"
+    splits {
+        abi {
+            // splits only make sense for multi-ABI builds; single-ABI uses ndk.abiFilters
+            isEnable = abiList.size > 1
+            reset()
+            include(*abiList.toTypedArray())
+            isUniversalApk = false
+        }
+    }
+
+    // fix for Qt Creator to allow deploying the application to a device
+    // to enable this fix, add the line outputBaseName=android-build to local.properties
+    if (outputBaseName.isNotEmpty()) {
+        applicationVariants.all {
+            outputs.map { it as BaseVariantOutputImpl }
+                .forEach { output ->
+                    if (output.outputFileName.endsWith(".apk")) {
+                        output.outputFileName = "$outputBaseName-${buildType.name}.apk"
+                    }
+                }
+        }
+    }
+
+    // androiddeployqt expects:
+    //   APK: build/outputs/apk/{base}-{buildType}[-unsigned].apk  (no flavor subdir)
+    //   AAB: build/outputs/bundle/{buildType}/{base}-{buildType}.aab (no flavor subdir)
+    // where {base} = outputBaseName (set by Qt Creator) or "android-build" (CI fallback).
+    // Release APK gets -unsigned suffix (Qt cmake signs it); debug does not.
+    // Copy only oss flavor to the flat output dir that androiddeployqt/Qt Creator expect.
+    // Play flavor is built via android_play_apk/android_play_aab cmake targets and uses
+    // its native Gradle output paths directly.
+    applicationVariants.all {
+        val flavorName = productFlavors.firstOrNull()?.name ?: ""
+        val buildTypeName = buildType.name
+        if (flavorName == "oss") {
+            val base = outputBaseName.ifEmpty { "android-build" }
+            val unsignedSuffix = if (buildTypeName == "release") "-unsigned" else ""
+
+            packageApplicationProvider.configure {
+                doLast {
+                    val srcDir = layout.buildDirectory.dir("outputs/apk/oss/$buildTypeName").get().asFile
+                    val dstDir = layout.buildDirectory.dir("outputs/apk").get().asFile
+                    dstDir.mkdirs()
+                    srcDir.listFiles()?.filter { it.name.endsWith(".apk") }?.forEach { apk ->
+                        apk.copyTo(File(dstDir, "$base-$buildTypeName$unsignedSuffix.apk"), overwrite = true)
+                    }
+                }
+            }
+
+            tasks.named("bundle${name.replaceFirstChar { it.uppercase() }}") {
+                doLast {
+                    val srcDir = layout.buildDirectory.dir("outputs/bundle/ossRelease").get().asFile
+                    val dstDir = layout.buildDirectory.dir("outputs/bundle/$buildTypeName").get().asFile
+                    dstDir.mkdirs()
+                    srcDir.listFiles()?.filter { it.name.endsWith(".aab") }?.forEach { aab ->
+                        aab.copyTo(File(dstDir, "$base-$buildTypeName.aab"), overwrite = true)
+                    }
+                }
            }
        }
    }
@@ -84,4 +189,9 @@ dependencies {
    implementation(libs.google.mlkit)
    implementation(libs.androidx.datastore)
    implementation(libs.androidx.biometric)
+
+    playImplementation(project(":billing"))
 }
+
+fun DependencyHandler.playImplementation(dependency: Any): Dependency? =
+    add("playImplementation", dependency)
--- a/client/android/gradle/libs.versions.toml
+++ b/client/android/gradle/libs.versions.toml
@@ -1,6 +1,7 @@
 [versions]
 agp = "8.6.1"
 kotlin = "1.9.24"
+android-billing = "7.0.0"
 androidx-core = "1.13.1"
 androidx-activity = "1.9.1"
 androidx-annotation = "1.8.2"
@@ -14,6 +15,7 @@ kotlinx-serialization = "1.6.3"
 google-mlkit = "17.3.0"

 [libraries]
+android-billing = { module = "com.android.billingclient:billing-ktx", version.ref = "android-billing" }
 androidx-core = { module = "androidx.core:core-ktx", version.ref = "androidx-core" }
 androidx-activity = { module = "androidx.activity:activity-ktx", version.ref = "androidx-activity" }
 androidx-annotation = { module = "androidx.annotation:annotation", version.ref = "androidx-annotation" }
--- a/client/android/oss/org/amnezia/vpn/BillingPaymentRepository.kt
+++ b/client/android/oss/org/amnezia/vpn/BillingPaymentRepository.kt
@@ -0,0 +1,13 @@
+package org.amnezia.vpn
+
+import android.app.Activity
+import android.content.Context
+
+class BillingPaymentRepository(@Suppress("UNUSED_PARAMETER") context: Context) : BillingRepository {
+    override suspend fun getCountryCode(): String = ""
+    override suspend fun getSubscriptionPlans(): String = ""
+    override suspend fun purchaseSubscription(activity: Activity, offerToken: String): String = ""
+    override suspend fun upgradeSubscription(activity: Activity, offerToken: String, oldPurchaseToken: String): String = ""
+    override suspend fun acknowledge(purchaseToken: String): String = ""
+    override suspend fun queryPurchases(): String = ""
+}
--- a/client/android/play/org/amnezia/vpn/BillingPaymentRepository.kt
+++ b/client/android/play/org/amnezia/vpn/BillingPaymentRepository.kt
@@ -0,0 +1,34 @@
+package org.amnezia.vpn
+
+import android.app.Activity
+import android.content.Context
+import BillingProvider.Companion.withBillingProvider
+
+class BillingPaymentRepository(private val context: Context) : BillingRepository {
+
+    override suspend fun getCountryCode(): String = withBillingProvider(context) {
+        getCustomerCountryCode()
+    }
+
+    override suspend fun getSubscriptionPlans(): String = withBillingProvider(context) {
+        getSubscriptionPlans()
+    }
+
+    override suspend fun purchaseSubscription(activity: Activity, offerToken: String): String =
+        withBillingProvider(context) {
+            purchaseSubscription(activity, offerToken)
+    }
+
+    override suspend fun upgradeSubscription(activity: Activity, offerToken: String, oldPurchaseToken: String): String =
+        withBillingProvider(context) {
+            purchaseSubscription(activity, offerToken, oldPurchaseToken)
+        }
+
+    override suspend fun acknowledge(purchaseToken: String): String = withBillingProvider(context) {
+        acknowledge(purchaseToken)
+    }
+
+    override suspend fun queryPurchases(): String = withBillingProvider(context) {
+        getPurchases()
+    }
+}
--- a/client/android/settings.gradle.kts
+++ b/client/android/settings.gradle.kts
@@ -30,6 +30,7 @@ rootProject.buildFileName = "build.gradle.kts"

 include(":qt")
 include(":utils")
+include(":billing")
 include(":protocolApi")
 include(":wireguard")
 include(":awg")
--- a/client/android/src/org/amnezia/vpn/AmneziaActivity.kt
+++ b/client/android/src/org/amnezia/vpn/AmneziaActivity.kt
@@ -56,7 +56,6 @@ import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withContext
 import org.amnezia.vpn.protocol.getStatistics
 import org.amnezia.vpn.protocol.getStatus
 import org.amnezia.vpn.qt.QtAndroidController
@@ -90,6 +89,7 @@ class AmneziaActivity : QtActivity() {
    private var notificationStateReceiver: BroadcastReceiver? = null
    private lateinit var vpnServiceMessenger: IpcMessenger
    private var pfd: ParcelFileDescriptor? = null
+    private lateinit var billingRepository: BillingRepository

    private val actionResultHandlers = mutableMapOf<Int, ActivityResultHandler>()
    private val permissionRequestHandlers = mutableMapOf<Int, PermissionRequestHandler>()
@@ -206,6 +206,7 @@ class AmneziaActivity : QtActivity() {
        registerBroadcastReceivers()
        intent?.let(::processIntent)
        runBlocking { vpnProto = proto.await() }
+        billingRepository = BillingPaymentRepository(applicationContext)
    }

    override fun onSaveInstanceState(outState: Bundle) {
@@ -999,15 +1000,9 @@ class AmneziaActivity : QtActivity() {
    @Suppress("unused")
    fun getAppList(): String {
        Log.v(TAG, "Get app list")
-        var appList = ""
-        runBlocking {
-            mainScope.launch {
-                withContext(Dispatchers.IO) {
-                    appList = AppListProvider.getAppList(packageManager, packageName)
-                }
-            }.join()
+        return blockingCall(Dispatchers.IO) {
+            AppListProvider.getAppList(packageManager, packageName)
        }
-        return appList
    }

    @Suppress("unused")
@@ -1176,11 +1171,59 @@ class AmneziaActivity : QtActivity() {
        return super.dispatchTrackballEvent(ev)
    }

+    @Suppress("unused")
+    fun isPlay(): Boolean = BuildConfig.FLAVOR == "play"
+
+    @Suppress("unused")
+    fun isTestPurchaseEnvironment(): Boolean {
+        if (BuildConfig.DEBUG) return true
+        val appInfo = packageManager.getApplicationInfo(packageName, 0)
+        return (appInfo.flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0
+    }
+
+    @Suppress("unused")
+    fun getCountryCode(): String {
+        Log.v(TAG, "Get country code")
+        return blockingCall { billingRepository.getCountryCode() }
+    }
+
+    @Suppress("unused")
+    fun getSubscriptionPlans(): String {
+        Log.v(TAG, "Get subscription plans")
+        return blockingCall { billingRepository.getSubscriptionPlans() }
+    }
+
+    @Suppress("unused")
+    fun purchaseSubscription(offerToken: String): String {
+        Log.v(TAG, "Purchase subscription")
+        return blockingCall { billingRepository.purchaseSubscription(this@AmneziaActivity, offerToken) }
+    }
+
+    @Suppress("unused")
+    fun upgradeSubscription(offerToken: String, oldPurchaseToken: String): String {
+        Log.v(TAG, "Upgrade subscription")
+        return blockingCall {
+            billingRepository.upgradeSubscription(this@AmneziaActivity, offerToken, oldPurchaseToken)
+        }
+    }
+
+    @Suppress("unused")
+    fun acknowledgePurchase(purchaseToken: String): String {
+        Log.v(TAG, "Acknowledge purchase")
+        return blockingCall { billingRepository.acknowledge(purchaseToken) }
+    }
+
+    @Suppress("unused")
+    fun queryPurchases(): String {
+        Log.v(TAG, "Query purchases")
+        return blockingCall { billingRepository.queryPurchases() }
+    }
+
    /**
     * Utils methods
     */
    private fun <T> blockingCall(
-        context: CoroutineContext = Dispatchers.Main.immediate,
+        context: CoroutineContext = Dispatchers.Default,
        block: suspend () -> T
    ) = runBlocking {
        mainScope.async(context) { block() }.await()
--- a/client/android/src/org/amnezia/vpn/AmneziaApplication.kt
+++ b/client/android/src/org/amnezia/vpn/AmneziaApplication.kt
@@ -1,5 +1,6 @@
 package org.amnezia.vpn

+import android.system.Os
 import androidx.camera.camera2.Camera2Config
 import androidx.camera.core.CameraSelector
 import androidx.camera.core.CameraXConfig
@@ -12,6 +13,9 @@ private const val TAG = "AmneziaApplication"
 class AmneziaApplication : QtApplication(), CameraXConfig.Provider {

    override fun onCreate() {
+        if (BuildConfig.DEBUG) {
+            Os.setenv("QT_ANDROID_DEBUGGER_MAIN_THREAD_SLEEP_MS", "0", true)
+        }
        super.onCreate()
        Prefs.init(this)
        Log.init(this)
--- a/client/android/src/org/amnezia/vpn/BillingRepository.kt
+++ b/client/android/src/org/amnezia/vpn/BillingRepository.kt
@@ -0,0 +1,12 @@
+package org.amnezia.vpn
+
+import android.app.Activity
+
+interface BillingRepository {
+    suspend fun getCountryCode(): String
+    suspend fun getSubscriptionPlans(): String
+    suspend fun purchaseSubscription(activity: Activity, offerToken: String): String
+    suspend fun upgradeSubscription(activity: Activity, offerToken: String, oldPurchaseToken: String): String
+    suspend fun acknowledge(purchaseToken: String): String
+    suspend fun queryPurchases(): String
+}
--- a/client/android/utils/src/main/kotlin/ErrorCode.kt
+++ b/client/android/utils/src/main/kotlin/ErrorCode.kt
@@ -0,0 +1,14 @@
+package org.amnezia.vpn.util
+
+// keep synchronized with client/core/defs.h error_code_ns::ErrorCode
+object ErrorCode {
+    const val NoError = 0
+
+    const val BillingCanceled = 1300
+    const val BillingError = 1301
+    const val BillingGooglePlayError = 1302
+    const val BillingUnavailable = 1303
+    const val SubscriptionAlreadyOwned = 1304
+    const val SubscriptionUnavailable = 1305
+    const val BillingNetworkError = 1306
+}
--- a/client/cmake/android.cmake
+++ b/client/cmake/android.cmake
@@ -1,5 +1,9 @@
 message("Client android ${CMAKE_ANDROID_ARCH_ABI} build")

+# Option to build Play variant (with Google Play Billing) instead of OSS
+# When ON, adds target android_play_apk: cmake --build . --target android_play_apk
+option(ANDROID_BUILD_PLAY "Add android_play_apk target for Google Play Billing build" OFF)
+
 set(APP_ANDROID_MIN_SDK 28)
 set(ANDROID_PLATFORM "android-${APP_ANDROID_MIN_SDK}" CACHE STRING
    "The minimum API level supported by the application or library" FORCE)
@@ -53,3 +57,43 @@ file(COPY ${AMNEZIA_LIBXRAY_PATH} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/androi
 find_package(openvpn-pt-android REQUIRED)
 set(LIBS ${LIBS} amnezia::openvpn-pt-android)
 set_property(TARGET ${PROJECT} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS ${OPENVPN_PT_ANDROID_LIBCK_OVPN_PLUGIN_PATH})
+
+if(QT_USE_TARGET_ANDROID_BUILD_DIR)
+    set(_android_build_dir "${CMAKE_CURRENT_BINARY_DIR}/android-build-${PROJECT}")
+else()
+    set(_android_build_dir "${CMAKE_CURRENT_BINARY_DIR}/android-build")
+endif()
+
+add_custom_target(android_gradle_clean
+    COMMAND ./gradlew clean
+    WORKING_DIRECTORY "${_android_build_dir}"
+    COMMENT "Cleaning Android Gradle build cache"
+)
+
+# Always-available debug target: build Play Debug APK and copy to standard output path
+# so Qt Creator's deploy step picks it up automatically
+add_custom_target(android_play_debug_install
+    COMMAND ./gradlew assemblePlayDebug
+    COMMAND sh -c "cp build/outputs/apk/play/debug/*.apk build/outputs/apk/android-build-${PROJECT}-debug.apk"
+    WORKING_DIRECTORY "${_android_build_dir}"
+    COMMENT "Building Android Play Debug APK and copying to deploy path"
+    DEPENDS ${PROJECT}
+)
+
+if(ANDROID_BUILD_PLAY)
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(_gradle_suffix "Debug")
+    else()
+        set(_gradle_suffix "Release")
+    endif()
+    add_custom_target(android_play_apk
+        COMMAND ./gradlew assemblePlay${_gradle_suffix}         WORKING_DIRECTORY "${_android_build_dir}"
+        COMMENT "Building Android Play APK (assemblePlay${_gradle_suffix})"
+        DEPENDS ${PROJECT}
+    )
+    add_custom_target(android_play_aab
+        COMMAND ./gradlew bundlePlay${_gradle_suffix}         WORKING_DIRECTORY "${_android_build_dir}"
+        COMMENT "Building Android Play AAB (bundlePlay${_gradle_suffix})"
+        DEPENDS ${PROJECT}
+    )
+endif()
--- a/client/cmake/ios.cmake
+++ b/client/cmake/ios.cmake
@@ -121,6 +121,11 @@ target_sources(${PROJECT} PRIVATE
    ${CLIENT_ROOT_DIR}/platforms/ios/StoreKit2Helper.swift
 )

+set_source_files_properties(
+    ${CMAKE_CURRENT_SOURCE_DIR}/ios/app/Media.xcassets
+    PROPERTIES MACOSX_PACKAGE_LOCATION Resources
+)
+
 target_sources(${PROJECT} PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/ios/app/AmneziaVPNLaunchScreen.storyboard
    ${CMAKE_CURRENT_SOURCE_DIR}/ios/app/Media.xcassets
--- a/client/core/controllers/api/servicesCatalogController.cpp
+++ b/client/core/controllers/api/servicesCatalogController.cpp
@@ -220,6 +220,8 @@ ErrorCode ServicesCatalogController::fillAvailableServices(QJsonObject &services

    QByteArray responseBody;
    ErrorCode errorCode = executeRequest(QString("%1v1/services"), apiPayload, responseBody);
+    qWarning() << "[ServicesCatalog] errorCode:" << static_cast<int>(errorCode)
+               << "response:" << QString::fromLocal8Bit(responseBody);
    if (errorCode == ErrorCode::NoError) {
        if (!responseBody.contains(apiDefs::key::services.data())) {
            errorCode = ErrorCode::ApiServicesMissingError;
@@ -241,7 +243,10 @@ ErrorCode ServicesCatalogController::fillAvailableServices(QJsonObject &services

 ErrorCode ServicesCatalogController::executeRequest(const QString &endpoint, const QJsonObject &apiPayload, QByteArray &responseBody)
 {
-    GatewayController gatewayController(m_appSettingsRepository->getGatewayEndpoint(), m_appSettingsRepository->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs,
+    QString gatewayEndpoint = m_appSettingsRepository->getGatewayEndpoint();
+    qWarning() << "[ServicesCatalog] request URL:" << endpoint.arg(gatewayEndpoint)
+              << "isDevEnv:" << m_appSettingsRepository->isDevGatewayEnv();
+    GatewayController gatewayController(gatewayEndpoint, m_appSettingsRepository->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs,
                                        m_appSettingsRepository->isStrictKillSwitchEnabled(), m_appSettingsRepository);
    return gatewayController.post(endpoint, apiPayload, responseBody);
 }
--- a/client/core/controllers/api/subscriptionController.cpp
+++ b/client/core/controllers/api/subscriptionController.cpp
@@ -33,6 +33,9 @@
 #if defined(Q_OS_IOS) || defined(MACOS_NE)
    #include "platforms/ios/ios_controller.h"
    #include <AmneziaVPN-Swift.h>
+#elif defined(Q_OS_ANDROID)
+    #include "platforms/android/android_controller.h"
+    #include <QtConcurrent>
 #endif

 using namespace amnezia;
@@ -95,6 +98,9 @@ QJsonObject SubscriptionController::GatewayRequestData::toJsonObject() const
    if (!authData.isEmpty()) {
        obj[apiDefs::key::authData] = authData;
    }
+    if (!transactionId.isEmpty()) {
+        obj[apiDefs::key::transactionId] = transactionId;
+    }
    return obj;
 }

@@ -121,7 +127,7 @@ void SubscriptionController::appendProtocolDataToApiPayload(const QString &proto
    }
 }

-ErrorCode SubscriptionController::extractServerConfigJsonFromResponse(const QByteArray &apiResponseBody, const QString &protocol, 
+ErrorCode SubscriptionController::extractServerConfigJsonFromResponse(const QByteArray &apiResponseBody, const QString &protocol,
                                                                        const ProtocolData &protocolData, QJsonObject &serverConfigJson)
 {
    QString data = QJsonDocument::fromJson(apiResponseBody).object().value(configKey::config).toString();
@@ -186,16 +192,16 @@ ErrorCode SubscriptionController::extractServerConfigJsonFromResponse(const QByt
    return ErrorCode::NoError;
 }

-void SubscriptionController::updateApiConfigInJson(QJsonObject &serverConfigJson, const QString &serviceType, 
+void SubscriptionController::updateApiConfigInJson(QJsonObject &serverConfigJson, const QString &serviceType,
                                                    const QString &serviceProtocol, const QString &userCountryCode,
                                                    const QByteArray &apiResponseBody)
 {
    QJsonObject apiConfig = serverConfigJson.value(apiDefs::key::apiConfig).toObject();
-    
+
    apiConfig[apiDefs::key::serviceType] = serviceType;
    apiConfig[apiDefs::key::serviceProtocol] = serviceProtocol;
    apiConfig[apiDefs::key::userCountryCode] = userCountryCode;
-    
+
    if (serverConfigJson.value(configKey::configVersion).toInt() == serverConfigUtils::ConfigSource::AmneziaGateway) {
        QJsonObject responseObj = QJsonDocument::fromJson(apiResponseBody).object();
        if (responseObj.contains(apiDefs::key::supportedProtocols)) {
@@ -205,7 +211,7 @@ void SubscriptionController::updateApiConfigInJson(QJsonObject &serverConfigJson
            apiConfig.insert(apiDefs::key::serviceInfo, responseObj.value(apiDefs::key::serviceInfo).toObject());
        }
    }
-    
+
    serverConfigJson[apiDefs::key::apiConfig] = apiConfig;
 }

@@ -216,6 +222,26 @@ ErrorCode SubscriptionController::executeRequest(const QString &endpoint, const
    return gatewayController.post(endpoint, apiPayload, responseBody);
 }

+ErrorCode SubscriptionController::getSubscriptionInfo(const QString &userCountryCode, const QString &serviceType,
+                                                       const QString &serviceProtocol, const QString &purchaseToken,
+                                                       QByteArray &responseBody)
+{
+    GatewayRequestData gatewayRequestData { QSysInfo::productType(),
+                                            QString(APP_VERSION),
+                                            m_appSettingsRepository->getAppLanguage().name().split("_").first(),
+                                            m_appSettingsRepository->getInstallationUuid(true),
+                                            userCountryCode,
+                                            "",
+                                            serviceType,
+                                            serviceProtocol,
+                                            QJsonObject(),
+                                            purchaseToken };
+
+    QJsonObject apiPayload = gatewayRequestData.toJsonObject();
+    qWarning() << "[Billing][getSubscriptionInfo] request:" << QJsonDocument(apiPayload).toJson(QJsonDocument::Compact);
+    return executeRequest(QString("%1v1/get_subscription_info"), apiPayload, responseBody, false);
+}
+
 ErrorCode SubscriptionController::importServiceFromGateway(const QString &userCountryCode, const QString &serviceType,
                                                            const QString &serviceProtocol, const ProtocolData &protocolData,
                                                            CaptchaInfo &captchaInfo)
@@ -327,10 +353,10 @@ ErrorCode SubscriptionController::importTrialFromGateway(const QString &userCoun
    return ErrorCode::NoError;
 }

-ErrorCode SubscriptionController::importServiceFromAppStore(const QString &userCountryCode, const QString &serviceType,
+ErrorCode SubscriptionController::importServiceFromMarket(const QString &userCountryCode, const QString &serviceType,
                                                            const QString &serviceProtocol, const ProtocolData &protocolData,
                                                            const QString &transactionId, bool isTestPurchase,
-                                                            int *duplicateServerIndex)
+                                                            int *duplicateServerIndex, const QString &endpoint)
 {
    GatewayRequestData gatewayRequestData { QSysInfo::productType(),
                                            QString(APP_VERSION),
@@ -340,14 +366,16 @@ ErrorCode SubscriptionController::importServiceFromAppStore(const QString &userC
                                            "",
                                            serviceType,
                                            serviceProtocol,
-                                            QJsonObject() };
+                                            QJsonObject(),
+                                            transactionId};

    QJsonObject apiPayload = gatewayRequestData.toJsonObject();
    appendProtocolDataToApiPayload(serviceProtocol, protocolData, apiPayload);
-    apiPayload[apiDefs::key::transactionId] = transactionId;

    QByteArray responseBody;
-    ErrorCode errorCode = executeRequest(QString("%1v1/subscriptions"), apiPayload, responseBody, isTestPurchase);
+    qWarning() << "[Billing][importServiceFromMarket] endpoint:" << endpoint << "isTestPurchase:" << isTestPurchase;
+    ErrorCode errorCode = executeRequest(QString("%1") + endpoint, apiPayload, responseBody, isTestPurchase);
+    qWarning() << "[Billing][importServiceFromMarket] errorCode:" << static_cast<int>(errorCode) << "response:" << responseBody;
    if (errorCode != ErrorCode::NoError) {
        return errorCode;
    }
@@ -391,7 +419,7 @@ ErrorCode SubscriptionController::importServiceFromAppStore(const QString &userC
    QJsonObject configObject = QJsonDocument::fromJson(configString).object();

    quint16 crc = qChecksum(QJsonDocument(configObject).toJson());
-    
+
    if (configObject.value(configKey::configVersion).toInt() != serverConfigUtils::ConfigSource::AmneziaGateway) {
        return ErrorCode::InternalError;
    }
@@ -419,7 +447,7 @@ ErrorCode SubscriptionController::updateServiceFromGateway(const QString &server
    const bool isTestPurchase = apiV2->apiConfig.isTestPurchase;
    QString serviceProtocol = apiV2->serviceProtocol();
    ProtocolData protocolData = generateProtocolData(serviceProtocol);
-    
+
    QJsonObject authDataJson = apiV2->authData.toJson();
    GatewayRequestData gatewayRequestData { QSysInfo::productType(),
                                            QString(APP_VERSION),
@@ -455,24 +483,24 @@ ErrorCode SubscriptionController::updateServiceFromGateway(const QString &server
    if (errorCode != ErrorCode::NoError) {
        return errorCode;
    }
-    
+
    updateApiConfigInJson(serverConfigJson, apiV2->apiConfig.serviceType, serviceProtocol, apiV2->apiConfig.userCountryCode, responseBody);
-    
+
    if (serverConfigJson.value(configKey::configVersion).toInt() != serverConfigUtils::ConfigSource::AmneziaGateway) {
        return ErrorCode::InternalError;
    }

    ApiV2ServerConfig newApiV2Config = ApiV2ServerConfig::fromJson(serverConfigJson);
    ApiV2ServerConfig* newApiV2 = &newApiV2Config;
-    
+
    newApiV2->apiConfig.vpnKey = apiV2->apiConfig.vpnKey;
    newApiV2->apiConfig.isTestPurchase = apiV2->apiConfig.isTestPurchase;
    newApiV2->apiConfig.isInAppPurchase = apiV2->apiConfig.isInAppPurchase;
    newApiV2->apiConfig.subscriptionExpiredByServer = false;
-    
+
    newApiV2->authData = apiV2->authData;
    newApiV2->crc = apiV2->crc;
-    
+
    if (apiV2->nameOverriddenByUser) {
        newApiV2->name = apiV2->name;
        newApiV2->displayName = apiV2->displayName;
@@ -490,7 +518,7 @@ ErrorCode SubscriptionController::deactivateDevice(const QString &serverId)
    if (!apiV2.has_value()) {
        return ErrorCode::NoError;
    }
-    
+
    if (!apiV2->isPremium() && !apiV2->isExternalPremium()) {
        return ErrorCode::NoError;
    }
@@ -527,7 +555,7 @@ ErrorCode SubscriptionController::deactivateExternalDevice(const QString &server
    if (!apiV2.has_value()) {
        return ErrorCode::NoError;
    }
-    
+
    if (!apiV2->isPremium() && !apiV2->isExternalPremium()) {
        return ErrorCode::NoError;
    }
@@ -723,7 +751,7 @@ bool SubscriptionController::isApiKeyExpired(const QString &serverId) const
        return false;
    }
    const QString expiresAt = apiV2->apiConfig.publicKey.expiresAt;
-    
+
    if (expiresAt.isEmpty()) {
        return false;
    }
@@ -732,7 +760,7 @@ bool SubscriptionController::isApiKeyExpired(const QString &serverId) const
    if (expiresAtDateTime < QDateTime::currentDateTimeUtc()) {
        return true;
    }
-    
+
    return false;
 }

@@ -786,8 +814,123 @@ ErrorCode SubscriptionController::processAppStorePurchase(const QString &userCou
    bool isTestPurchase = IosController::Instance()->isTestFlight();

    ProtocolData protocolData = generateProtocolData(serviceProtocol);
-    return importServiceFromAppStore(userCountryCode, serviceType, serviceProtocol, protocolData,
-                                     originalTransactionId, isTestPurchase, duplicateServerIndex);
+    return importServiceFromMarket(userCountryCode, serviceType, serviceProtocol, protocolData,
+                                     originalTransactionId, isTestPurchase, duplicateServerIndex,
+                                     QStringLiteral("v1/subscriptions"));
+#else
+    Q_UNUSED(userCountryCode);
+    Q_UNUSED(serviceType);
+    Q_UNUSED(serviceProtocol);
+    Q_UNUSED(productId);
+    return ErrorCode::ApiPurchaseError;
+#endif
+}
+
+ErrorCode SubscriptionController::processPlayMarketPurchase(const QString &userCountryCode, const QString &serviceType,
+                                                             const QString &serviceProtocol, const QString &productId,
+                                                             int *duplicateServerIndex)
+{
+#if defined(Q_OS_ANDROID)
+    auto androidController = AndroidController::instance();
+    QString purchaseToken;
+    bool purchaseOk = false;
+
+    QFutureWatcher<QPair<bool, QString>> watcher;
+    QEventLoop waitLoop;
+    QObject::connect(&watcher, &QFutureWatcher<QPair<bool, QString>>::finished, &waitLoop, &QEventLoop::quit);
+
+    QFuture<QPair<bool, QString>> future = QtConcurrent::run([androidController, productId]() {
+        QJsonObject plansResult = androidController->getSubscriptionPlans();
+        int responseCode = plansResult.value("responseCode").toInt(-1);
+        if (responseCode != 0) {
+            qWarning() << "[Billing] Failed to get subscription plans, responseCode:" << responseCode;
+            return qMakePair(false, QString());
+        }
+        QJsonArray products = plansResult.value("products").toArray();
+        QString offerToken;
+        for (const QJsonValue &productValue : products) {
+            QJsonObject product = productValue.toObject();
+            QJsonArray offers = product.value("offers").toArray();
+            for (const QJsonValue &offerValue : offers) {
+                QJsonObject offer = offerValue.toObject();
+                if (offer.value("basePlanId").toString() == productId) {
+                    offerToken = offer.value("offerToken").toString();
+                    qInfo() << "[Billing] Found offer token for basePlanId:" << productId;
+                    break;
+                }
+            }
+            if (!offerToken.isEmpty()) break;
+        }
+        if (offerToken.isEmpty()) {
+            qWarning() << "[Billing] No offer token found for basePlanId:" << productId;
+            return qMakePair(false, QString());
+        }
+        QJsonObject purchaseResult = androidController->purchaseSubscription(offerToken);
+        responseCode = purchaseResult.value("responseCode").toInt(-1);
+        if (responseCode != 0) {
+            qWarning() << "[Billing] Purchase failed, responseCode:" << responseCode;
+            return qMakePair(false, QString());
+        }
+        QJsonArray purchases = purchaseResult.value("purchases").toArray();
+        if (purchases.isEmpty()) {
+            qWarning() << "[Billing] Purchase succeeded but no purchases returned";
+            return qMakePair(false, QString());
+        }
+        QJsonObject purchase = purchases.at(0).toObject();
+        QString token = purchase.value("purchaseToken").toString();
+        bool isAcknowledged = purchase.value("isAcknowledged").toBool();
+        int purchaseState = purchase.value("purchaseState").toInt(-1);
+        qInfo() << "[Billing] Purchase success. purchaseToken:" << token << "isAcknowledged:" << isAcknowledged << "purchaseState:" << purchaseState;
+        // purchaseState 1 = PURCHASED, 0 = PENDING (user must confirm payment in Google Play)
+        if (purchaseState != 1) {
+            qWarning() << "[Billing] Purchase is in PENDING state, waiting for user to confirm payment";
+            return qMakePair(false, QStringLiteral("pending"));
+        }
+        if (!isAcknowledged) {
+            QJsonObject ackResult = androidController->acknowledgePurchase(token);
+            if (ackResult.value("responseCode").toInt(-1) != 0) {
+                qWarning() << "[Billing] Acknowledge failed";
+            } else {
+                qInfo() << "[Billing] Purchase acknowledged successfully";
+            }
+        }
+        return qMakePair(true, token);
+    });
+
+    watcher.setFuture(future);
+    waitLoop.exec();
+
+    purchaseOk = watcher.result().first;
+    purchaseToken = watcher.result().second;
+
+    if (!purchaseOk) {
+        if (purchaseToken == QStringLiteral("pending")) {
+            return ErrorCode::ApiPurchasePendingError;
+        }
+        return ErrorCode::ApiPurchaseError;
+    }
+    if (purchaseToken.isEmpty()) {
+        return ErrorCode::ApiPurchaseError;
+    }
+
+    // First call: determine if this is a test purchase
+    QByteArray checkResponse;
+    ErrorCode checkError = getSubscriptionInfo(userCountryCode, serviceType, serviceProtocol, purchaseToken, checkResponse);
+    qWarning() << "[Billing][processPlayMarketPurchase] getSubscriptionInfo errorCode:" << static_cast<int>(checkError) << "response:" << checkResponse;
+    if (checkError != ErrorCode::NoError) {
+        qWarning().noquote() << "[Billing] Initial subscriptions check failed:" << static_cast<int>(checkError);
+        return checkError;
+    }
+
+    QJsonObject checkObject = QJsonDocument::fromJson(checkResponse).object();
+    bool isTestPurchase = checkObject.value(apiDefs::key::isTestPurchase).toBool(false);
+    qInfo().noquote() << "[Billing] Purchase isTestPurchase =" << isTestPurchase;
+
+    // Second call: import service with correct isTestPurchase flag
+    ProtocolData protocolData = generateProtocolData(serviceProtocol);
+    return importServiceFromMarket(userCountryCode, serviceType, serviceProtocol, protocolData,
+                                     purchaseToken, isTestPurchase, duplicateServerIndex,
+                                     QStringLiteral("v1/subscriptions"));
 #else
    Q_UNUSED(userCountryCode);
    Q_UNUSED(serviceType);
@@ -808,6 +951,9 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
    QString restoreError;
    QEventLoop waitRestore;

+    qInfo().noquote() << "[IAP][processAppStoreRestore] Starting restore. userCountryCode=" << userCountryCode
+                      << "serviceType=" << serviceType << "serviceProtocol=" << serviceProtocol;
+
    IosController::Instance()->restorePurchases([&](bool success, const QList<QVariantMap> &transactions, const QString &errorString) {
        restoreSuccess = success;
        restoredTransactions = transactions;
@@ -816,6 +962,10 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
    });
    waitRestore.exec();

+    qInfo().noquote() << "[IAP][processAppStoreRestore] restorePurchases result: success=" << restoreSuccess
+                      << "transactions count=" << restoredTransactions.size()
+                      << "error=" << restoreError;
+
    if (!restoreSuccess) {
        qWarning().noquote() << "[IAP] Restore failed:" << restoreError;
        result.errorCode = ErrorCode::ApiPurchaseError;
@@ -829,6 +979,7 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
    }

    bool isTestPurchase = IosController::Instance()->isTestFlight();
+    qInfo().noquote() << "[IAP][processAppStoreRestore] isTestFlight=" << isTestPurchase;
    QSet<QString> processedTransactions;

    for (const QVariantMap &transaction : restoredTransactions) {
@@ -836,6 +987,9 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
        const QString transactionId = transaction.value(QStringLiteral("transactionId")).toString();
        const QString transactionProductId = transaction.value(QStringLiteral("productId")).toString();

+        qInfo().noquote() << "[IAP][processAppStoreRestore] Processing transaction: transactionId=" << transactionId
+                          << "originalTransactionId=" << originalTransactionId << "productId=" << transactionProductId;
+
        if (originalTransactionId.isEmpty()) {
            qWarning().noquote() << "[IAP] Skipping restored transaction without originalTransactionId" << transactionId;
            continue;
@@ -843,6 +997,7 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp

        if (processedTransactions.contains(originalTransactionId)) {
            result.duplicateCount++;
+            qInfo().noquote() << "[IAP][processAppStoreRestore] Skipping duplicate originalTransactionId=" << originalTransactionId;
            continue;
        }
        processedTransactions.insert(originalTransactionId);
@@ -852,9 +1007,13 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp

        ProtocolData protocolData = generateProtocolData(serviceProtocol);
        int currentDuplicateServerIndex = -1;
-        ErrorCode errorCode = importServiceFromAppStore(userCountryCode, serviceType, serviceProtocol, protocolData,
+        ErrorCode errorCode = importServiceFromMarket(userCountryCode, serviceType, serviceProtocol, protocolData,
                                                        originalTransactionId, isTestPurchase,
-                                                        &currentDuplicateServerIndex);
+                                                        &currentDuplicateServerIndex,
+                                                        QStringLiteral("v1/restore_subscription"));
+
+        qInfo().noquote() << "[IAP][processAppStoreRestore] importServiceFromMarket errorCode=" << static_cast<int>(errorCode)
+                          << "for originalTransactionId=" << originalTransactionId;

        if (errorCode == ErrorCode::ApiConfigAlreadyAdded) {
            result.duplicateConfigAlreadyPresent = true;
@@ -864,7 +1023,8 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
            qInfo().noquote() << "[IAP] Skipping restored transaction" << originalTransactionId
                              << "because subscription config with the same vpn_key already exists";
        } else if (errorCode != ErrorCode::NoError) {
-            qWarning().noquote() << "[IAP] Failed to process restored subscription response for transaction" << originalTransactionId;
+            qWarning().noquote() << "[IAP] Failed to process restored subscription response for transaction" << originalTransactionId
+                                 << "errorCode=" << static_cast<int>(errorCode);
            result.errorCode = errorCode;
        } else {
            result.hasInstalledConfig = true;
@@ -875,6 +1035,132 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp
        result.errorCode = result.duplicateConfigAlreadyPresent ? ErrorCode::ApiConfigAlreadyAdded : ErrorCode::ApiPurchaseError;
    }

+    qInfo().noquote() << "[IAP][processAppStoreRestore] Done. hasInstalledConfig=" << result.hasInstalledConfig
+                      << "duplicateConfigAlreadyPresent=" << result.duplicateConfigAlreadyPresent
+                      << "duplicateCount=" << result.duplicateCount
+                      << "errorCode=" << static_cast<int>(result.errorCode);
+
+    return result;
+#else
+    Q_UNUSED(userCountryCode);
+    Q_UNUSED(serviceType);
+    Q_UNUSED(serviceProtocol);
+    result.errorCode = ErrorCode::ApiPurchaseError;
+    return result;
+#endif
+}
+
+SubscriptionController::PlayMarketRestoreResult SubscriptionController::processPlayMarketRestore(const QString &userCountryCode, const QString &serviceType,
+                                                                                                  const QString &serviceProtocol)
+{
+    PlayMarketRestoreResult result;
+
+#if defined(Q_OS_ANDROID)
+    auto androidController = AndroidController::instance();
+
+    QJsonObject purchasesResult;
+    {
+        QFutureWatcher<QJsonObject> queryWatcher;
+        QEventLoop queryLoop;
+        QObject::connect(&queryWatcher, &QFutureWatcher<QJsonObject>::finished, &queryLoop, &QEventLoop::quit);
+        QFuture<QJsonObject> queryFuture = QtConcurrent::run([androidController]() {
+            return androidController->queryPurchases();
+        });
+        queryWatcher.setFuture(queryFuture);
+        queryLoop.exec();
+        purchasesResult = queryWatcher.result();
+    }
+
+    int responseCode = purchasesResult.value("responseCode").toInt(-1);
+    if (responseCode != 0) {
+        qWarning().noquote() << "[Billing] queryPurchases failed, responseCode =" << responseCode;
+        result.errorCode = ErrorCode::ApiPurchaseError;
+        return result;
+    }
+
+    QJsonArray purchases = purchasesResult.value("purchases").toArray();
+    if (purchases.isEmpty()) {
+        qInfo().noquote() << "[Billing] Restore completed, but no purchases were found";
+        result.errorCode = ErrorCode::ApiNoPurchasesToRestore;
+        return result;
+    }
+
+    QSet<QString> processedTokens;
+    for (const QJsonValue &purchaseValue : std::as_const(purchases)) {
+        const QJsonObject purchaseObj = purchaseValue.toObject();
+        const QString purchaseToken = purchaseObj.value("purchaseToken").toString();
+
+        if (purchaseToken.isEmpty()) {
+            qWarning().noquote() << "[Billing] Skipping purchase without purchaseToken";
+            continue;
+        }
+
+        if (processedTokens.contains(purchaseToken)) {
+            result.duplicateCount++;
+            continue;
+        }
+        processedTokens.insert(purchaseToken);
+
+        qInfo().noquote() << "[Billing] Restoring subscription with purchaseToken =" << purchaseToken;
+
+        {
+            QFutureWatcher<QJsonObject> ackWatcher;
+            QEventLoop ackLoop;
+            QObject::connect(&ackWatcher, &QFutureWatcher<QJsonObject>::finished, &ackLoop, &QEventLoop::quit);
+            QFuture<QJsonObject> ackFuture = QtConcurrent::run([androidController, purchaseToken]() {
+                return androidController->acknowledgePurchase(purchaseToken);
+            });
+            ackWatcher.setFuture(ackFuture);
+            ackLoop.exec();
+            QJsonObject ackResult = ackWatcher.result();
+            int ackCode = ackResult.value("responseCode").toInt(-1);
+            if (ackCode != 0) {
+                qWarning().noquote() << "[Billing] acknowledgePurchase failed, responseCode =" << ackCode;
+            } else {
+                qInfo().noquote() << "[Billing] Purchase acknowledged successfully";
+            }
+        }
+
+        QByteArray checkResponse;
+        ErrorCode checkError = getSubscriptionInfo(userCountryCode, serviceType, serviceProtocol, purchaseToken, checkResponse);
+        qWarning() << "[Billing][processPlayMarketRestore] getSubscriptionInfo errorCode:" << static_cast<int>(checkError) << "response:" << checkResponse;
+        if (checkError != ErrorCode::NoError) {
+            qWarning().noquote() << "[Billing] Initial subscriptions check failed:" << static_cast<int>(checkError);
+            result.errorCode = checkError;
+            continue;
+        }
+
+        QJsonObject checkObject = QJsonDocument::fromJson(checkResponse).object();
+        bool isTestPurchase = checkObject.value(apiDefs::key::isTestPurchase).toBool(false);
+        qInfo().noquote() << "[Billing] Purchase isTestPurchase =" << isTestPurchase;
+
+        ProtocolData protocolData = generateProtocolData(serviceProtocol);
+        int currentDuplicateServerIndex = -1;
+        ErrorCode errorCode = importServiceFromMarket(userCountryCode, serviceType, serviceProtocol, protocolData,
+                                                        purchaseToken, isTestPurchase,
+                                                        &currentDuplicateServerIndex,
+                                                        QStringLiteral("v1/restore_subscription"));
+
+        if (errorCode == ErrorCode::ApiConfigAlreadyAdded) {
+            result.duplicateConfigAlreadyPresent = true;
+            if (result.duplicateServerIndex < 0) {
+                result.duplicateServerIndex = currentDuplicateServerIndex;
+            }
+            qInfo().noquote() << "[Billing] Skipping purchase" << purchaseToken
+                              << "because subscription config with the same vpn_key already exists";
+        } else if (errorCode != ErrorCode::NoError) {
+            qWarning().noquote() << "[Billing] Failed to process restored subscription for purchaseToken =" << purchaseToken
+                                 << "errorCode =" << static_cast<int>(errorCode);
+            result.errorCode = errorCode;
+        } else {
+            result.hasInstalledConfig = true;
+        }
+    }
+
+    if (!result.hasInstalledConfig) {
+        result.errorCode = result.duplicateConfigAlreadyPresent ? ErrorCode::ApiConfigAlreadyAdded : ErrorCode::ApiNoPurchasesToRestore;
+    }
+
    return result;
 #else
    Q_UNUSED(userCountryCode);
@@ -887,12 +1173,14 @@ SubscriptionController::AppStoreRestoreResult SubscriptionController::processApp

 ErrorCode SubscriptionController::getAccountInfo(const QString &serverId, QJsonObject &accountInfo)
 {
-    auto apiV2 = m_serversRepository->apiV2Config(serverId);
-    if (!apiV2.has_value()) {
+    auto apiV2Opt = m_serversRepository->apiV2Config(serverId);
+    if (!apiV2Opt.has_value()) {
        return ErrorCode::InternalError;
    }
+
+    const ApiV2ServerConfig* apiV2 = &apiV2Opt.value();
    bool isTestPurchase = apiV2->apiConfig.isTestPurchase;
-    
+
    QJsonObject authDataJson = apiV2->authData.toJson();
    GatewayRequestData gatewayRequestData { QSysInfo::productType(),
                                            QString(APP_VERSION),
--- a/client/core/controllers/api/subscriptionController.h
+++ b/client/core/controllers/api/subscriptionController.h
@@ -38,6 +38,7 @@ public:
        QString serviceType;
        QString serviceProtocol;
        QJsonObject authData;
+        QString transactionId;

        QJsonObject toJsonObject() const;
    };
@@ -61,10 +62,15 @@ public:
    ErrorCode importTrialFromGateway(const QString &userCountryCode, const QString &serviceType,
                                     const QString &serviceProtocol, const QString &email);

-    ErrorCode importServiceFromAppStore(const QString &userCountryCode, const QString &serviceType,
+    ErrorCode importServiceFromMarket(const QString &userCountryCode, const QString &serviceType,
                                        const QString &serviceProtocol, const ProtocolData &protocolData,
                                        const QString &transactionId, bool isTestPurchase,
-                                        int *duplicateServerIndex = nullptr);
+                                        int *duplicateServerIndex,
+                                        const QString &endpoint);
+
+    ErrorCode getSubscriptionInfo(const QString &userCountryCode, const QString &serviceType,
+                                  const QString &serviceProtocol, const QString &purchaseToken,
+                                  QByteArray &responseBody);

    ErrorCode updateServiceFromGateway(const QString &serverId, const QString &newCountryCode, bool isConnectEvent);

@@ -99,10 +105,23 @@ public:
        ErrorCode errorCode = ErrorCode::NoError;
    };

+    struct PlayMarketRestoreResult
+    {
+        bool hasInstalledConfig = false;
+        bool duplicateConfigAlreadyPresent = false;
+        int duplicateCount = 0;
+        int duplicateServerIndex = -1;
+        ErrorCode errorCode = ErrorCode::NoError;
+    };
+
    ErrorCode processAppStorePurchase(const QString &userCountryCode, const QString &serviceType,
                                     const QString &serviceProtocol, const QString &productId,
                                     int *duplicateServerIndex = nullptr);

+    ErrorCode processPlayMarketPurchase(const QString &userCountryCode, const QString &serviceType,
+                                        const QString &serviceProtocol, const QString &productId,
+                                        int *duplicateServerIndex = nullptr);
+
    AppStoreRestoreResult processAppStoreRestore(const QString &userCountryCode, const QString &serviceType,
                                                  const QString &serviceProtocol);

@@ -111,6 +130,9 @@ public:
                                          const QString &captchaId, const QString &captchaSolution,
                                          CaptchaInfo *retryCaptchaOut = nullptr);

+    PlayMarketRestoreResult processPlayMarketRestore(const QString &userCountryCode, const QString &serviceType,
+                                                     const QString &serviceProtocol);
+
 private:
    ErrorCode executeRequest(const QString &endpoint, const QJsonObject &apiPayload, QByteArray &responseBody, bool isTestPurchase = false);
    bool isApiKeyExpired(const QString &serverId) const;
--- a/client/core/utils/errorCodes.h
+++ b/client/core/utils/errorCodes.h
@@ -108,6 +108,8 @@ namespace amnezia
        ApiCaptchaInvalidError = 1118,
        ApiCaptchaRefreshError = 1119,
        ApiRateLimitError = 1120,
+        ApiNoPurchasesToRestore = 1121,
+        ApiPurchasePendingError = 1122,

        // QFile errors
        OpenError = 1200,
@@ -115,7 +117,16 @@ namespace amnezia
        PermissionsError = 1202,
        UnspecifiedError = 1203,
        FatalError = 1204,
-        AbortError = 1205
+        AbortError = 1205,
+
+        // Billing errors
+        BillingCanceled = 1300,
+        BillingError = 1301,
+        BillingGooglePlayError = 1302,
+        BillingUnavailable = 1303,
+        SubscriptionAlreadyOwned = 1304,
+        SubscriptionUnavailable = 1305,
+        BillingNetworkError = 1306,
      };
      Q_ENUM_NS(ErrorCode)
    }
--- a/client/core/utils/errorStrings.cpp
+++ b/client/core/utils/errorStrings.cpp
@@ -100,6 +100,16 @@ QString errorString(ErrorCode code) {
    case (ErrorCode::ApiCaptchaInvalidError): errorMessage = QObject::tr("CAPTCHA was incorrect. Please try again"); break;
    case (ErrorCode::ApiCaptchaRefreshError): errorMessage = QObject::tr("CAPTCHA refreshed. Please try again"); break;
    case (ErrorCode::ApiRateLimitError): errorMessage = QObject::tr("Too many requests. Please try again later"); break;
+    case (ErrorCode::ApiPurchasePendingError): errorMessage = QObject::tr("Your payment is pending confirmation in Google Play. Please complete the payment and then restore your subscription."); break;
+    case (ErrorCode::ApiNoPurchasesToRestore):
+#if defined(Q_OS_ANDROID)
+        errorMessage = QObject::tr("No purchases to restore. If you have an active subscription, make sure you're signed in with the same Google account used for the purchase.");
+#elif defined(Q_OS_IOS) || defined(MACOS_NE)
+        errorMessage = QObject::tr("No purchases to restore. If you have an active subscription, make sure you're signed in with the same Apple ID used for the purchase.");
+#else
+        errorMessage = QObject::tr("No purchases to restore. If you have an active subscription, make sure you're signed in with the same account used for the purchase.");
+#endif
+        break;

    // QFile errors
    case(ErrorCode::OpenError): errorMessage = QObject::tr("QFile error: The file could not be opened"); break;
@@ -109,6 +119,15 @@ QString errorString(ErrorCode code) {
    case(ErrorCode::FatalError): errorMessage =  QObject::tr("QFile error: A fatal error occurred"); break;
    case(ErrorCode::AbortError): errorMessage =  QObject::tr("QFile error: The operation was aborted"); break;

+    // Billing errors
+    case(ErrorCode::BillingCanceled): errorMessage = QObject::tr("Transaction was canceled by the user"); break;
+    case(ErrorCode::BillingError): errorMessage = QObject::tr("Billing error"); break;
+    case(ErrorCode::BillingGooglePlayError): errorMessage = QObject::tr("Internal Google Play error, please try again later"); break;
+    case(ErrorCode::BillingUnavailable): errorMessage = QObject::tr("Billing is unavailable, please try again later"); break;
+    case(ErrorCode::SubscriptionAlreadyOwned): errorMessage = QObject::tr("You already own this subscription"); break;
+    case(ErrorCode::SubscriptionUnavailable): errorMessage = QObject::tr("The requested subscription is not available for purchase"); break;
+    case(ErrorCode::BillingNetworkError): errorMessage = QObject::tr("A network error occurred during the operation, please check the Internet connection"); break;
+
    case(ErrorCode::InternalError):
    default:
        errorMessage = QObject::tr("Internal error"); break;
--- a/client/core/utils/serialization/vmess.cpp
+++ b/client/core/utils/serialization/vmess.cpp
@@ -170,7 +170,7 @@ QJsonObject Deserialize(const QString &vmessStr, QString *alias, QString *errMes
    //   - It can be empty, if so,           if the key is not in the JSON, or the value is empty,  report an error.
    //   - Else if it contains one thing.    if the key is not in the JSON, or the value is empty,  use that one.
    //   - Else if it contains many things,  when the key IS in the JSON but not within the THINGS, use the first in the THINGS
-    //   - Else -------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  use the JSON value
+    //   - Else -------------------------------------------- use the JSON value
    //
 #define __vmess_checker__func(key, values)                                                                                                               \
    {                                                                                                                                                    \
--- a/client/ios/app/Info.plist.in
+++ b/client/ios/app/Info.plist.in
@@ -82,10 +82,32 @@
 		<key>NSAllowsLocalNetworking</key>
 		<true/>
 	</dict>
+	<key>CFBundleIconName</key>
+	<string>AppIcon</string>
 	<key>CFBundleIcons</key>
-        <dict/>
-        <key>CFBundleIcons~ipad</key>
-        <dict/>
+	<dict>
+		<key>CFBundlePrimaryIcon</key>
+		<dict>
+			<key>CFBundleIconFiles</key>
+			<array>
+				<string>AppIcon</string>
+			</array>
+			<key>CFBundleIconName</key>
+			<string>AppIcon</string>
+		</dict>
+	</dict>
+	<key>CFBundleIcons~ipad</key>
+	<dict>
+		<key>CFBundlePrimaryIcon</key>
+		<dict>
+			<key>CFBundleIconFiles</key>
+			<array>
+				<string>AppIcon</string>
+			</array>
+			<key>CFBundleIconName</key>
+			<string>AppIcon</string>
+		</dict>
+	</dict>
 	<key>UTImportedTypeDeclarations</key>
 	<array>
 		<dict>
--- a/client/platforms/android/android_controller.cpp
+++ b/client/platforms/android/android_controller.cpp
@@ -328,6 +328,57 @@ void AndroidController::sendTouch(float x, float y)
    callActivityMethod("sendTouch", "(FF)V", x, y);
 }

+
+bool AndroidController::isPlay()
+{
+    return callActivityMethod<jboolean>("isPlay", "()Z");
+}
+
+bool AndroidController::isTestPurchaseEnvironment()
+{
+    return callActivityMethod<jboolean>("isTestPurchaseEnvironment", "()Z");
+}
+
+QJsonObject AndroidController::getSubscriptionPlans()
+{
+    QJniObject subscriptionPlans = callActivityMethod<jstring>("getSubscriptionPlans", "()Ljava/lang/String;");
+    QJsonObject json = QJsonDocument::fromJson(subscriptionPlans.toString().toUtf8()).object();
+    return json;
+}
+
+QJsonObject AndroidController::purchaseSubscription(const QString &offerToken)
+{
+    QJniObject result = callActivityMethod<jstring, jstring>("purchaseSubscription", "(Ljava/lang/String;)Ljava/lang/String;",
+                                                    QJniObject::fromString(offerToken).object<jstring>());
+    QJsonObject json = QJsonDocument::fromJson(result.toString().toUtf8()).object();
+    return json;
+}
+
+QJsonObject AndroidController::upgradeSubscription(const QString &offerToken, const QString &oldPurchaseToken)
+{
+    QJniObject result = callActivityMethod<jstring, jstring, jstring>("upgradeSubscription",
+                                                                      "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+                                                                      QJniObject::fromString(offerToken).object<jstring>(),
+                                                                      QJniObject::fromString(oldPurchaseToken).object<jstring>());
+    QJsonObject json = QJsonDocument::fromJson(result.toString().toUtf8()).object();
+    return json;
+}
+
+QJsonObject AndroidController::acknowledgePurchase(const QString &purchaseToken)
+{
+    QJniObject result = callActivityMethod<jstring, jstring>("acknowledgePurchase", "(Ljava/lang/String;)Ljava/lang/String;",
+                                                             QJniObject::fromString(purchaseToken).object<jstring>());
+    QJsonObject json = QJsonDocument::fromJson(result.toString().toUtf8()).object();
+    return json;
+}
+
+QJsonObject AndroidController::queryPurchases()
+{
+    QJniObject result = callActivityMethod<jstring>("queryPurchases", "()Ljava/lang/String;");
+    QJsonObject json = QJsonDocument::fromJson(result.toString().toUtf8()).object();
+    return json;
+}
+
 // Moving log processing to the Android side
 jclass AndroidController::log;
 jmethodID AndroidController::logDebug;
--- a/client/platforms/android/android_controller.h
+++ b/client/platforms/android/android_controller.h
@@ -55,6 +55,13 @@ public:
    void requestNotificationPermission();
    bool requestAuthentication();
    void sendTouch(float x, float y);
+    bool isPlay();
+    bool isTestPurchaseEnvironment();
+    QJsonObject getSubscriptionPlans();
+    QJsonObject purchaseSubscription(const QString &offerToken);
+    QJsonObject upgradeSubscription(const QString &offerToken, const QString &oldPurchaseToken);
+    QJsonObject acknowledgePurchase(const QString &purchaseToken);
+    QJsonObject queryPurchases();

    static bool initLogging();
    static void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &message);
--- a/client/ui/controllers/api/subscriptionUiController.cpp
+++ b/client/ui/controllers/api/subscriptionUiController.cpp
@@ -227,6 +227,36 @@ bool SubscriptionUiController::importPremiumFromAppStore(const QString &storePro
    return true;
 }

+bool SubscriptionUiController::importPremiumFromPlayMarket(const QString &storeProductId)
+{
+#if defined(Q_OS_ANDROID)
+    QString productId = storeProductId.trimmed();
+    if (productId.isEmpty()) {
+        productId = QStringLiteral("premium");
+    }
+
+    int duplicateServerIndex = -1;
+    ErrorCode errorCode = m_subscriptionController->processPlayMarketPurchase(
+        m_apiServicesModel->getCountryCode(),
+        m_apiServicesModel->getSelectedServiceType(),
+        m_apiServicesModel->getSelectedServiceProtocol(),
+        productId,
+        &duplicateServerIndex);
+
+    if (errorCode != ErrorCode::NoError) {
+        if (errorCode == ErrorCode::ApiConfigAlreadyAdded) {
+            emit installServerFromApiFinished(tr("This subscription has already been added"), duplicateServerIndex);
+            return true;
+        }
+        emit errorOccurred(errorCode);
+        return false;
+    }
+
+    emit installServerFromApiFinished(tr("%1 has been added to the app").arg(m_apiServicesModel->getSelectedServiceName()));
+#endif
+    return true;
+}
+
 bool SubscriptionUiController::restoreServiceFromAppStore()
 {
 #if defined(Q_OS_IOS) || defined(MACOS_NE)
@@ -281,6 +311,59 @@ bool SubscriptionUiController::restoreServiceFromAppStore()
    return true;
 }

+bool SubscriptionUiController::restoreServiceFromPlayMarket()
+{
+#if defined(Q_OS_ANDROID)
+    const QString premiumServiceType = QStringLiteral("amnezia-premium");
+
+    if (!fillAvailableServices()) {
+        qWarning().noquote() << "[Billing] Unable to fetch services list before restore";
+        emit errorOccurred(ErrorCode::ApiServicesMissingError);
+        return false;
+    }
+
+    if (m_apiServicesModel->rowCount() <= 0) {
+        emit errorOccurred(ErrorCode::ApiServicesMissingError);
+        return false;
+    }
+
+    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) {
+        emit errorOccurred(ErrorCode::ApiServicesMissingError);
+        return false;
+    }
+
+    SubscriptionController::PlayMarketRestoreResult result = m_subscriptionController->processPlayMarketRestore(
+        m_apiServicesModel->getCountryCode(),
+        m_apiServicesModel->getSelectedServiceType(),
+        m_apiServicesModel->getSelectedServiceProtocol());
+
+    if (!result.hasInstalledConfig) {
+        if (result.duplicateConfigAlreadyPresent) {
+            emit installServerFromApiFinished(tr("This subscription has already been added"), result.duplicateServerIndex);
+            return true;
+        }
+        emit errorOccurred(result.errorCode);
+        return false;
+    }
+
+    emit installServerFromApiFinished(tr("Subscription restored successfully."));
+    if (result.duplicateCount > 0) {
+        qInfo().noquote() << "[Billing] Skipped" << result.duplicateCount
+                          << "duplicate restored purchases for tokens already processed";
+    }
+#endif
+    return true;
+}
+
 bool SubscriptionUiController::importFreeFromGateway()
 {
    QString userCountryCode = m_apiServicesModel->getCountryCode();
--- a/client/ui/controllers/api/subscriptionUiController.h
+++ b/client/ui/controllers/api/subscriptionUiController.h
@@ -45,8 +45,10 @@ public slots:

    bool fillAvailableServices();
    bool importPremiumFromAppStore(const QString &storeProductId);
+    bool importPremiumFromPlayMarket(const QString &storeProductId);
    bool importFreeFromGateway();
    bool restoreServiceFromAppStore();
+    bool restoreServiceFromPlayMarket();
    bool importTrialFromGateway(const QString &email);
    bool updateServiceFromGateway(const QString &serverId, const QString &newCountryCode, const QString &newCountryName,
                                  bool reloadServiceConfig = false);
--- a/client/ui/qml/Pages2/PageSetupWizardApiPremiumInfo.qml
+++ b/client/ui/qml/Pages2/PageSetupWizardApiPremiumInfo.qml
@@ -187,6 +187,13 @@ PageType {
                PageController.showBusyIndicator(false)
                return
            }
+            if (Qt.platform.os === "android") {
+                PageController.showBusyIndicator(true)
+                var androidStoreId = plan.storeProductId !== undefined ? String(plan.storeProductId) : ""
+                SubscriptionUiController.importPremiumFromPlayMarket(androidStoreId)
+                PageController.showBusyIndicator(false)
+                return
+            }
            if (plan.checkoutUrl) {
                Qt.openUrlExternally(plan.checkoutUrl)
                PageController.closePage()
--- a/client/ui/qml/Pages2/PageSetupWizardConfigSource.qml
+++ b/client/ui/qml/Pages2/PageSetupWizardConfigSource.qml
@@ -377,10 +377,14 @@ PageType {
        property string title: qsTr("Restore purchases")
        property string description: qsTr("")
        property string imageSource: "qrc:/images/controls/refresh-cw.svg"
-        property bool isVisible: Qt.platform.os === "ios" || IsMacOsNeBuild
+        property bool isVisible: Qt.platform.os === "ios" || IsMacOsNeBuild || IsPlayBuild
        property var handler: function() {
            PageController.showBusyIndicator(true)
-            SubscriptionUiController.restoreServiceFromAppStore()
+            if (Qt.platform.os === "android") {
+                SubscriptionUiController.restoreServiceFromPlayMarket()
+            } else {
+                SubscriptionUiController.restoreServiceFromAppStore()
+            }
            PageController.showBusyIndicator(false)
        }
    }
--- a/deploy/build.sh
+++ b/deploy/build.sh
@@ -33,6 +33,8 @@ while [[ $# -gt 0 ]]; do
        --abi)              abis+=("$2");            shift 2 ;;
        --sign)             : ${SIGN:=true};         shift   ;;
        --aab)              : ${BUILD_AAB=true};     shift   ;;
+        --apk)              : ${BUILD_APK=true};     shift   ;;
+        --play)             : ${BUILD_PLAY=true};    shift   ;;
        --help|-h|?)
            echo "Usage: $0 [options]"
            echo "  Options:"
@@ -45,6 +47,8 @@ while [[ $# -gt 0 ]]; do
            echo "  --abi                     - specify Android ABIs for target to build for. all by default"
            echo "  --sign                    - whether to sign the resulting files. only appicable to Android"
            echo "  --aab                     - whether to build AAB. only applicable to Android"
+            echo "  --apk                     - whether to build APK. use with --play. only applicable to Android"
+            echo "  --play                    - build Play flavor (Google Play Billing). use with --aab or --apk. only applicable to Android"
            exit 0
            ;;
        *) echo "Unknown arg \"$1\". Use $0 -h to get help"; exit 1 ;;
@@ -201,6 +205,7 @@ args=()
 [[ -n "$QT_ANDROID_SIGN_AAB" ]]       && args+=("-DQT_ANDROID_SIGN_AAB=$QT_ANDROID_SIGN_AAB")
 [[ -n "$QT_ANDROID_ABIS" ]]           && args+=("-DQT_ANDROID_ABIS=$QT_ANDROID_ABIS")
 [[ -n "$QT_ANDROID_BUILD_ALL_ABIS" ]] && args+=("-DQT_ANDROID_BUILD_ALL_ABIS=$QT_ANDROID_BUILD_ALL_ABIS")
+[[ -n "$BUILD_PLAY" ]]                && args+=("-DANDROID_BUILD_PLAY=ON")

 if [[ -n "$FORCE" ]]; then
    run_traced rm -rf "$BUILD_PATH"
@@ -209,7 +214,17 @@ fi
 run_traced cmake -S "$SOURCE_PATH" -B "$BUILD_PATH" "${args[@]}"
 run_traced cmake --build "$BUILD_PATH" --config "$CMAKE_BUILD_TYPE"

-[[ -n "$BUILD_AAB" ]] && run_traced cmake --build "$BUILD_PATH" --config "$CMAKE_BUILD_TYPE" -t "aab"
+if [[ -n "$BUILD_AAB" ]]; then
+    if [[ -n "$BUILD_PLAY" ]]; then
+        run_traced cmake --build "$BUILD_PATH" --config "$CMAKE_BUILD_TYPE" -t "android_play_aab"
+    else
+        run_traced cmake --build "$BUILD_PATH" --config "$CMAKE_BUILD_TYPE" -t "aab"
+    fi
+fi
+
+if [[ -n "$BUILD_APK" ]] && [[ -n "$BUILD_PLAY" ]]; then
+    run_traced cmake --build "$BUILD_PATH" --config "$CMAKE_BUILD_TYPE" -t "android_play_apk"
+fi

 if [ -z "$no_installers" ]; then
    for installer in $INSTALLERS; do
--- a/recipes/amnezia-libxray/conanfile.py
+++ b/recipes/amnezia-libxray/conanfile.py
@@ -1,5 +1,5 @@
 from conan import ConanFile
-from conan.tools.files import get, copy
+from conan.tools.files import get, copy, replace_in_file
 from conan.tools.layout import basic_layout
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.env import Environment
@@ -23,7 +23,7 @@ class AmneziaLibxray(ConanFile):

    def build_requirements(self):
        self.tool_requires("go/1.26.0")
-    
+
    def validate(self):
        if self.settings.os != "Android":
            raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
@@ -47,15 +47,28 @@ class AmneziaLibxray(ConanFile):
        build_path = os.path.join(self.build_folder, "build.sh")
        build_stat = os.stat(build_path)
        os.chmod(build_path, build_stat.st_mode | stat.S_IEXEC)
+        replace_in_file(self,
+            build_path,
+            '-ldflags="-w -s -buildid="',
+            '-ldflags="-w -s -buildid= -extldflags=-Wl,-z,max-page-size=16384"',
+        )
+        replace_in_file(self,
+            build_path,
+            "    rm -f go.mod\n    rm -f go.sum\n    go mod init github.com/amnezia-vpn/amnezia-libxray\n    go mod tidy",
+            "    go mod tidy",
+        )

    def build(self):
        self._patch_sources()
-        self.run("./build.sh android")
+        if self.settings_build.os == "Windows":
+            self.run("bash build.sh android")
+        else:
+            self.run("./build.sh android")

    def package(self):
        copy(self, "libxray.aar", src=self.build_folder, dst=os.path.join(self.package_folder, "aar"))

    def package_info(self):
        self.cpp_info.set_property("cmake_extra_variables", {
-            "AMNEZIA_LIBXRAY_PATH": os.path.join(self.package_folder, "aar", "libxray.aar"),
+            "AMNEZIA_LIBXRAY_PATH": Path(self.package_folder, "aar", "libxray.aar").as_posix(),
        })
--- a/recipes/awg-android/conanfile.py
+++ b/recipes/awg-android/conanfile.py
@@ -1,11 +1,13 @@
 from conan import ConanFile
 from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
 from conan.tools.files import copy, replace_in_file
+from conan.tools.env import VirtualBuildEnv, Environment
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.scm import Git

 import os
 import platform
+from pathlib import Path

 class AwgAndroid(ConanFile):
    name = "awg-android"
@@ -21,6 +23,11 @@ class AwgAndroid(ConanFile):

    def build_requirements(self):
        self.tool_requires("cmake/[>=3.4.1 <4]")
+        if platform.system() == "Windows":
+            self.tool_requires("ninja/[*]")
+            self.tool_requires("go/[*]")
+            if not self.conf.get("tools.microsoft.bash:path", check_type=str):
+                self.tool_requires("msys2/cci.latest")

    def validate(self):
        if self.settings.os != "Android":
@@ -35,9 +42,11 @@ class AwgAndroid(ConanFile):
        )

    def generate(self):
+        VirtualBuildEnv(self).generate()
+
        tc = CMakeToolchain(self)
-        tc.variables["GRADLE_USER_HOME"] = os.path.join(self.build_folder, "gradle_user_home")
-        tc.variables["CMAKE_LIBRARY_OUTPUT_DIRECTORY"] = os.path.join(self.build_folder, "out")
+        tc.variables["GRADLE_USER_HOME"] = Path(os.path.join(self.build_folder, "gradle_user_home")).as_posix()
+        tc.variables["CMAKE_LIBRARY_OUTPUT_DIRECTORY"] = Path(os.path.join(self.build_folder, "out")).as_posix()
        # not to warn in case of strtok() usage
        tc.extra_cflags = ["-Wno-deprecated-declarations"]
        tc.generate()
@@ -64,6 +73,31 @@ class AwgAndroid(ConanFile):
                'sha256sum -c',
                'shasum -a 256 -c'
            )
+        elif platform.system() == 'Windows':
+            # elf-cleaner uses sys/mman.h (POSIX only) and cannot be built on Windows;
+            # skip it — DT_FLAGS_1 warnings only affect Android < 6.0
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "CMakeLists.txt"),
+                '# Strip unwanted ELF sections to prevent DT_FLAGS_1 warnings on old Android versions\n'
+                'file(GLOB ELF_CLEANER_SOURCES elf-cleaner/*.c elf-cleaner/*.cpp)\n'
+                'add_custom_target(elf-cleaner COMMENT "Building elf-cleaner" VERBATIM COMMAND cc\n'
+                '        -O2 -DPACKAGE_NAME="elf-cleaner" -DPACKAGE_VERSION="" -DCOPYRIGHT=""\n'
+                '        -o "${CMAKE_CURRENT_BINARY_DIR}/elf-cleaner" ${ELF_CLEANER_SOURCES}\n'
+                ')\n'
+                'add_custom_command(TARGET libwg.so POST_BUILD VERBATIM COMMAND "${CMAKE_CURRENT_BINARY_DIR}/elf-cleaner"\n'
+                '        --api-level "${ANDROID_NATIVE_API_LEVEL}" "$<TARGET_FILE:libwg.so>")\n'
+                'add_dependencies(libwg.so elf-cleaner)\n'
+                'add_custom_command(TARGET libwg-quick.so POST_BUILD VERBATIM COMMAND "${CMAKE_CURRENT_BINARY_DIR}/elf-cleaner"\n'
+                '        --api-level "${ANDROID_NATIVE_API_LEVEL}" "$<TARGET_FILE:libwg-quick.so>")\n'
+                'add_dependencies(libwg-quick.so elf-cleaner)',
+                '',
+            )
+            # patch Makefile: skip Go download, use 'go' already in PATH from tool_requires
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
+                '$(DESTDIR)/libwg-go.so: export PATH := $(BUILDDIR)/go-$(GO_VERSION)/bin/:$(PATH)\n$(DESTDIR)/libwg-go.so: $(BUILDDIR)/go-$(GO_VERSION)/.prepared go.mod',
+                '$(DESTDIR)/libwg-go.so: go.mod',
+            )

    def build(self):
        self._patch_sources()
@@ -81,6 +115,6 @@ class AwgAndroid(ConanFile):
        self.cpp_info.set_property("cmake_target_name", "amnezia::awg-android")
        self.cpp_info.libs = [ "wg-go" ]
        self.cpp_info.set_property("cmake_extra_variables", {
-            "AMNEZIA_ANDROID_LIBWG_PATH": os.path.join(self.package_folder, "bin", "libwg.so"),
-            "AMNEZIA_ANDROID_LIBWG_QUICK_PATH": os.path.join(self.package_folder, "bin", "libwg-quick.so"),
+            "AMNEZIA_ANDROID_LIBWG_PATH": Path(os.path.join(self.package_folder, "bin", "libwg.so")).as_posix(),
+            "AMNEZIA_ANDROID_LIBWG_QUICK_PATH": Path(os.path.join(self.package_folder, "bin", "libwg-quick.so")).as_posix(),
        })
--- a/recipes/openvpn-pt-android/conanfile.py
+++ b/recipes/openvpn-pt-android/conanfile.py
@@ -5,6 +5,7 @@ from conan.tools.scm import Git
 from conan.errors import ConanInvalidConfiguration

 import os
+from pathlib import Path

 class OpenvpnPtAndroid(ConanFile):
    name = "openvpn-pt-android"
@@ -53,5 +54,5 @@ class OpenvpnPtAndroid(ConanFile):
        self.cpp_info.set_property("cmake_target_name", "amnezia::openvpn-pt-android")
        self.cpp_info.libs = [ "ovpn3", "ovpnutil", "rsapss" ]
        self.cpp_info.set_property("cmake_extra_variables", {
-            "OPENVPN_PT_ANDROID_LIBCK_OVPN_PLUGIN_PATH": os.path.join(self.package_folder, "lib", "libck-ovpn-plugin.so")
+            "OPENVPN_PT_ANDROID_LIBCK_OVPN_PLUGIN_PATH": Path(self.package_folder, "lib", "libck-ovpn-plugin.so").as_posix()
        })
Author	SHA1	Message	Date
NickVs2015	2e79186908	fix: keep pinned go.mod when building amnezia-libxray	2026-07-11 11:38:39 +03:00
NickVs2015	eb9dfdaa11	fix: double purchase android	2026-07-10 23:45:58 +03:00
NickVs2015	11f6fed98a	fix: rename restore function, fix icon resource error	2026-07-10 15:30:35 +03:00
NickVs2015	7b3f7e852b	fix: add ios logs	2026-07-08 21:08:40 +03:00
NickVs2015	2b4d9bfbe5	fix: add logs and rename restore func	2026-07-08 20:59:39 +03:00
NickVs2015	f8c4db2f08	fix: update api endpoint and pay logic	2026-07-08 20:59:39 +03:00
NickVs2015	83ab95db7a	fix: add support getSubscriptionInfo and subscriptions/restore	2026-07-08 20:59:16 +03:00
NickVs2015	f42992912e	fix: revert market field, up android GP version, fix subscription plan parser	2026-07-08 20:59:02 +03:00
NickVs2015	f802efb2f4	fix: add support market types, add logs	2026-07-08 20:58:34 +03:00
NickVs2015	88018944ba	fix: add logs billing	2026-07-08 20:58:34 +03:00
NickVs2015	1340679621	fix: add custom target for Play billing	2026-07-08 20:57:50 +03:00
NickVs2015	4e900d4bab	fix: replace in file 16KB size	2026-07-08 20:57:50 +03:00
NickVs2015	c4656ad2e9	fix: support 16 kb page size amnezia-libxray	2026-07-08 20:57:50 +03:00
NickVs2015	24d1ed0333	fix: add play abi	2026-07-08 20:57:50 +03:00
NickVs2015	5b0afa3686	fix: simply build AAB	2026-07-08 20:57:08 +03:00
NickVs2015	4fd6d5f5cd	fix: separate oss/play build	2026-07-08 20:57:08 +03:00
NickVs2015	25bae06cbe	fix: copy apk to right path	2026-07-08 20:57:08 +03:00
NickVs2015	8132a29199	fix: release keystore	2026-07-08 20:57:08 +03:00
NickVs2015	07a11679f5	fix: add check purchase on restore	2026-07-08 20:57:08 +03:00
NickVs2015	ae7edda889	fix: add artifact apk	2026-07-08 20:57:08 +03:00
NickVs2015	62c6723662	fix: split payment to detect payment type	2026-07-08 20:57:08 +03:00
NickVs2015	3d7e9e4333	fix: fix multi-ABI filter	2026-07-08 20:57:08 +03:00
NickVs2015	d57d9ab6a9	fix: add build android via Win	2026-07-08 20:57:08 +03:00
NickVs2015	b52676a20b	fix: build flow for new conan structure	2026-07-08 20:57:07 +03:00
NickVs2015	199fddcd5b	fix: merge with new structure, fix payment flow	2026-07-08 20:57:07 +03:00
NickVs2015	854e95c173	feat: add test purchase android	2026-07-08 20:57:07 +03:00
NickVs2015	c0e13f5959	feat: add purchase to UI	2026-07-08 20:57:07 +03:00
albexk	6a49557852	refactor: modify response json	2026-07-08 20:57:07 +03:00
albexk	4fe8923e0d	Add methods to verify and purchase subscriptions	2026-07-08 20:57:07 +03:00
albexk	1c0a8a7741	Add method to get the list of offers	2026-07-08 20:57:07 +03:00
albexk	27924e996a	Add a method to detect Google Play build	2026-07-08 20:57:07 +03:00
albexk	4f1039926a	Add billing module, provide a separate build for Google Play	2026-07-08 20:57:07 +03:00
albexk	43b85e0e95	Disable Qt debugger sleep	2026-07-08 20:57:07 +03:00
albexk	961782c426	Add Google Play Billing Library	2026-07-08 20:57:07 +03:00