Switch plan: Migrate purchaseHistory to queryPurchasesAsync() (#6900)

Task/Issue URL:
https://app.asana.com/1/137249556945/task/1211320822502370?focus=true

### Description
Add queryPurchasesAsync() API to replace deprecated purchaseHistory
Migrate switch logic to use the new API

### Steps to test this PR

_Switch plan_
- [x] Apply patch on
https://app.asana.com/1/137249556945/project/1209991789468715/task/1210448620621729?focus=true
- [x]  Install from branch
- [x] Make a test purchase
- [x] Go to Settings > Subscriptions Dev Settings
- [x] Scroll down to the new option "Switch Subscription"
- [x] Select another plan to switch, different from the one you
purchased
- [x] Select "Without Proration" Replacement Mode
- [x] Tap "OK"
- [x] Check Google Play bottom sheet appear
- [x] Tap on "Subscribe"
- [x] Check you see the Toast of the successful purchase
- [x] Go to Settings > Subscription Settings
- [x] Check the subscription is changed

### No UI changes

Author: nalcalag

subscriptions/subscriptions-impl/src/main/java/com/duckduckgo/subscriptions/impl/SubscriptionsManager.kt

@@ -405,13 +405,7 @@ class RealSubscriptionsManager @Inject constructor(
                     return@withContext false
                 }
 
-                // fixme: Replace purchaseHistory with queryPurchasesAsync() to fetch the current purchase token.
-                // This aligns with Billing v8 and avoids using the deprecated Purchase History API.
-                val currentPurchaseToken =
-                    playBillingManager.purchaseHistory
-                        .filter { it.products.contains(BASIC_SUBSCRIPTION) }
-                        .maxByOrNull { it.purchaseTime }
-                        ?.purchaseToken
+                val currentPurchaseToken = playBillingManager.getLatestPurchaseToken()
 
                 if (currentPurchaseToken == null) {
                     logcat { "Subs: Cannot switch plan - no current purchase token found" }

subscriptions/subscriptions-impl/src/main/java/com/duckduckgo/subscriptions/impl/billing/BillingClientAdapter.kt

@@ -18,6 +18,7 @@ package com.duckduckgo.subscriptions.impl.billing
 
 import android.app.Activity
 import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
 import com.android.billingclient.api.PurchaseHistoryRecord
 
 interface BillingClientAdapter {
@@ -30,8 +31,14 @@ interface BillingClientAdapter {
 
     suspend fun getSubscriptions(productIds: List<String>): SubscriptionsResult
 
+    @Deprecated(
+        message = "purchaseHistory API is deprecated and removed in the Billing Library v8",
+        replaceWith = ReplaceWith("queryPurchases"),
+    )
     suspend fun getSubscriptionsPurchaseHistory(): SubscriptionsPurchaseHistoryResult
 
+    suspend fun queryPurchases(): QueryPurchasesResult
+
     suspend fun launchBillingFlow(
         activity: Activity,
         productDetails: ProductDetails,
@@ -68,6 +75,14 @@ sealed class SubscriptionsPurchaseHistoryResult {
     data object Failure : SubscriptionsPurchaseHistoryResult()
 }
 
+sealed class QueryPurchasesResult {
+    data class Success(val purchases: List<Purchase>) : QueryPurchasesResult()
+    data class Failure(
+        val billingError: BillingError? = null,
+        val debugMessage: String? = null,
+    ) : QueryPurchasesResult()
+}
+
 sealed class LaunchBillingFlowResult {
     data object Success : LaunchBillingFlowResult()
     data class Failure(val error: BillingError) : LaunchBillingFlowResult()

subscriptions/subscriptions-impl/src/main/java/com/duckduckgo/subscriptions/impl/billing/PlayBillingManager.kt

@@ -20,6 +20,7 @@ import android.app.Activity
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
 import com.android.billingclient.api.PurchaseHistoryRecord
 import com.duckduckgo.app.di.AppCoroutineScope
 import com.duckduckgo.app.lifecycle.MainProcessLifecycleObserver
@@ -65,6 +66,7 @@ interface PlayBillingManager {
     val products: List<ProductDetails>
     val productsFlow: Flow<List<ProductDetails>>
     val purchaseHistory: List<PurchaseHistoryRecord>
+    val purchases: List<Purchase>
     val purchaseState: Flow<PurchaseState>
 
     /**
@@ -92,6 +94,12 @@ interface PlayBillingManager {
         oldPurchaseToken: String,
         replacementMode: SubscriptionReplacementMode,
     )
+
+    /**
+     * Gets the current purchase token from active purchases (queryPurchasesAsync)
+     * This is the preferred method over purchase history for getting current tokens
+     */
+    fun getLatestPurchaseToken(): String?
 }
 
 @SingleInstanceIn(AppScope::class)
@@ -123,8 +131,15 @@ class RealPlayBillingManager @Inject constructor(
         get() = _products.asStateFlow()
 
     // Purchase History
+    @Deprecated(
+        message = "purchaseHistory is deprecated",
+        replaceWith = ReplaceWith("purchases"),
+    )
     override var purchaseHistory = emptyList<PurchaseHistoryRecord>()
 
+    // Active Purchases
+    override var purchases = emptyList<Purchase>()
+
     override fun onCreate(owner: LifecycleOwner) {
         connectAsyncWithRetry()
     }
@@ -136,6 +151,7 @@ class RealPlayBillingManager @Inject constructor(
                 owner.lifecycleScope.launch(dispatcherProvider.io()) {
                     loadProducts()
                     loadPurchaseHistory()
+                    loadPurchases()
                 }
             }
         }
@@ -348,6 +364,36 @@ class RealPlayBillingManager @Inject constructor(
             }
         }
     }
+
+    private suspend fun loadPurchases() {
+        when (val result = billingClient.queryPurchases()) {
+            is QueryPurchasesResult.Success -> {
+                purchases = result.purchases
+                logcat { "Billing: Loaded ${result.purchases.size} active purchases" }
+            }
+            is QueryPurchasesResult.Failure -> {
+                logcat { "Billing: Failed to load purchases: ${result.billingError} - ${result.debugMessage}" }
+            }
+        }
+    }
+
+    override fun getLatestPurchaseToken(): String? {
+        val activePurchases = purchases.filter { purchase: Purchase ->
+            purchase.products.contains(BASIC_SUBSCRIPTION) &&
+                purchase.purchaseState == Purchase.PurchaseState.PURCHASED
+        }
+
+        val latestPurchase = activePurchases.maxByOrNull { it.purchaseTime }
+
+        return if (latestPurchase != null) {
+            val tokenPreview = latestPurchase.purchaseToken.take(10) + "..."
+            logcat { "Billing: Latest active purchase token preview: $tokenPreview" }
+            latestPurchase.purchaseToken
+        } else {
+            logcat { "Billing: No active purchase token found" }
+            null
+        }
+    }
 }
 
 sealed class PurchaseState {

subscriptions/subscriptions-impl/src/main/java/com/duckduckgo/subscriptions/impl/billing/RealBillingClientAdapter.kt

@@ -30,8 +30,10 @@ import com.android.billingclient.api.Purchase.PurchaseState
 import com.android.billingclient.api.QueryProductDetailsParams
 import com.android.billingclient.api.QueryProductDetailsParams.Product
 import com.android.billingclient.api.QueryPurchaseHistoryParams
+import com.android.billingclient.api.QueryPurchasesParams
 import com.android.billingclient.api.queryProductDetails
 import com.android.billingclient.api.queryPurchaseHistory
+import com.android.billingclient.api.queryPurchasesAsync
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.di.scopes.AppScope
 import com.duckduckgo.subscriptions.impl.billing.BillingError.BILLING_CRASH_ERROR
@@ -130,6 +132,7 @@ class RealBillingClientAdapter @Inject constructor(
         }
     }
 
+    @Deprecated(message = "check interface")
     override suspend fun getSubscriptionsPurchaseHistory(): SubscriptionsPurchaseHistoryResult {
         val client = billingClient
         if (client == null || !client.isReady) return SubscriptionsPurchaseHistoryResult.Failure
@@ -146,6 +149,43 @@ class RealBillingClientAdapter @Inject constructor(
         }
     }
 
+    override suspend fun queryPurchases(): QueryPurchasesResult {
+        val client = billingClient
+        if (client == null || !client.isReady) {
+            return QueryPurchasesResult.Failure(
+                billingError = BillingError.SERVICE_DISCONNECTED,
+                debugMessage = "BillingClient is not ready",
+            )
+        }
+
+        return try {
+            val queryParams = QueryPurchasesParams.newBuilder()
+                .setProductType(ProductType.SUBS)
+                .build()
+
+            val (billingResult, purchases) = client.queryPurchasesAsync(queryParams)
+
+            when (billingResult.responseCode) {
+                BillingResponseCode.OK -> {
+                    QueryPurchasesResult.Success(purchases = purchases)
+                }
+                else -> {
+                    val billingError = billingResult.responseCode.toBillingError()
+                    QueryPurchasesResult.Failure(
+                        billingError = billingError,
+                        debugMessage = billingResult.debugMessage,
+                    )
+                }
+            }
+        } catch (e: Exception) {
+            logcat(WARN) { "Error querying purchases: ${e.asLog()}" }
+            QueryPurchasesResult.Failure(
+                billingError = BILLING_CRASH_ERROR,
+                debugMessage = e.message,
+            )
+        }
+    }
+
     override suspend fun launchBillingFlow(
         activity: Activity,
         productDetails: ProductDetails,

subscriptions/subscriptions-impl/src/test/java/com/duckduckgo/subscriptions/impl/billing/RealPlayBillingManagerTest.kt

@@ -7,6 +7,7 @@ import androidx.lifecycle.Lifecycle.State.RESUMED
 import androidx.lifecycle.testing.TestLifecycleOwner
 import app.cash.turbine.test
 import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
 import com.android.billingclient.api.PurchaseHistoryRecord
 import com.duckduckgo.common.test.CoroutineTestRule
 import com.duckduckgo.subscriptions.impl.SubscriptionsConstants.BASIC_SUBSCRIPTION
@@ -21,6 +22,7 @@ import com.duckduckgo.subscriptions.impl.billing.FakeBillingClientAdapter.FakeMe
 import com.duckduckgo.subscriptions.impl.billing.FakeBillingClientAdapter.FakeMethodInvocation.GetSubscriptionsPurchaseHistory
 import com.duckduckgo.subscriptions.impl.billing.FakeBillingClientAdapter.FakeMethodInvocation.LaunchBillingFlow
 import com.duckduckgo.subscriptions.impl.billing.FakeBillingClientAdapter.FakeMethodInvocation.LaunchSubscriptionUpdate
+import com.duckduckgo.subscriptions.impl.billing.FakeBillingClientAdapter.FakeMethodInvocation.QueryPurchases
 import com.duckduckgo.subscriptions.impl.billing.PurchaseState.Canceled
 import com.duckduckgo.subscriptions.impl.billing.PurchaseState.InProgress
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -384,6 +386,7 @@ class FakeBillingClientAdapter : BillingClientAdapter {
     )
 
     var subscriptionsPurchaseHistory: List<PurchaseHistoryRecord> = emptyList()
+    var activePurchases: List<Purchase> = emptyList()
     var launchBillingFlowResult: LaunchBillingFlowResult = LaunchBillingFlowResult.Failure(error = SERVICE_UNAVAILABLE)
     var billingInitResult: BillingInitResult = BillingInitResult.Success
 
@@ -433,6 +436,15 @@ class FakeBillingClientAdapter : BillingClientAdapter {
         }
     }
 
+    override suspend fun queryPurchases(): QueryPurchasesResult {
+        methodInvocations.add(QueryPurchases)
+        return if (ready) {
+            QueryPurchasesResult.Success(activePurchases)
+        } else {
+            QueryPurchasesResult.Failure(BillingError.SERVICE_DISCONNECTED, "Service not connected")
+        }
+    }
+
     override suspend fun launchBillingFlow(
         activity: Activity,
         productDetails: ProductDetails,
@@ -520,6 +532,7 @@ class FakeBillingClientAdapter : BillingClientAdapter {
         data object Connect : FakeMethodInvocation()
         data class GetSubscriptions(val productIds: List<String>) : FakeMethodInvocation()
         data object GetSubscriptionsPurchaseHistory : FakeMethodInvocation()
+        data object QueryPurchases : FakeMethodInvocation()
 
         data class LaunchBillingFlow(
             val productDetails: ProductDetails,