@tinkerlandai/longplay-react-native 0.10.11 → 0.10.14

package/native-sdk/android/java/ai/tinkerland/indiana/FeatureClient.kt

@@ -7,19 +7,54 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
 import org.json.JSONObject
 import java.util.UUID
 
+/**
+ * Readiness and pending calls of one evaluator host, confined to the main thread. Stopping fails every waiter with
+ * its cause: `identity_changed` only for an identity change or close, otherwise the host's actual failure.
+ */
+internal class IndianaFeatureCalls {
+    private val readiness = CompletableDeferred<Unit>()
+    private val pending = mutableMapOf<UUID, CompletableDeferred<Any?>>()
+    var failure: IndianaClientException? = null
+        private set
+    val ready: Boolean get() = readiness.isCompleted && failure == null
+    fun markReady() { failure?.let { throw it }; readiness.complete(Unit) }
+    /** Returns false when already stopped; the first cause wins. */
+    fun stop(cause: IndianaClientException): Boolean {
+        if (failure != null) return false
+        failure = cause; readiness.completeExceptionally(cause)
+        pending.values.forEach { it.completeExceptionally(cause) }; pending.clear(); return true
+    }
+    suspend fun call(send: (UUID) -> Unit): Any? {
+        failure?.let { throw it }
+        withTimeoutOrNull(45_000) { readiness.await() } ?: throw IndianaClientException("temporary_unavailable")
+        failure?.let { throw it }
+        val id = UUID.randomUUID(); val result = CompletableDeferred<Any?>(); pending[id] = result
+        try {
+            send(id)
+            val settled = withTimeoutOrNull(45_000) { arrayOf(result.await()) } ?: throw IndianaClientException("temporary_unavailable")
+            return settled[0]
+        } finally { pending.remove(id) }
+    }
+    fun settle(id: UUID, result: Any?, failed: Boolean) {
+        val response = pending.remove(id) ?: return
+        if (failed) response.completeExceptionally(IndianaClientException("invalid_response")) else response.complete(result)
+    }
+}
+
 /** Customer-scoped GB evaluator using the packaged official engine, without JS credentials. */
 class IndianaFeatureClient internal constructor(private val activity: Activity, private val configuration: IndianaConfiguration, attributes: JSONObject, private val operation: suspend (IndianaCustomerOperation, JSONObject) -> JSONObject) {
     private val attributes = JSONObject(attributes.toString())
     private val work = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
-    private val readiness = CompletableDeferred<Unit>()
-    private val pending = mutableMapOf<UUID, CompletableDeferred<Any?>>()
+    private val calls = IndianaFeatureCalls()
     var onError: ((Exception) -> Unit)? = null
-    private var stopped = false
-    private val host = IndianaBundledWebView(activity, "Longplay Feature evaluator", work, ::dispatch) { error -> if (!readiness.isCompleted) close() else onError?.invoke(error) }
+    private val host = IndianaBundledWebView(activity, "Longplay Feature evaluator", work, ::dispatch) { error ->
+        // Before readiness a host failure ends this client with its actual cause rather than an identity change.
+        if (!calls.ready) stop(error as? IndianaClientException ?: IndianaClientException("renderer_failed")) else onError?.invoke(error)
+    }
     init { host.start() }
     suspend fun evalFeature(key: String): JSONObject {
         val result = call(JSONObject().put("method", "evalFeature").put("key", key)) as? JSONObject ?: throw IndianaClientException("invalid_response")
@@ -31,34 +66,23 @@ class IndianaFeatureClient internal constructor(private val activity: Activity,
     suspend fun setAttributes(attributes: JSONObject) { call(JSONObject().put("method", "setAttributes").put("attributes", JSONObject(attributes.toString()))) }
     suspend fun refresh() { call(JSONObject().put("method", "refresh")) }
     suspend fun flush() { call(JSONObject().put("method", "flush")) }
-    fun close() { activity.runOnUiThread {
-        if (!stopped) {
-            stopped = true; host.destroy()
-            val error = IndianaClientException("identity_changed")
-            readiness.completeExceptionally(error); pending.values.forEach { it.completeExceptionally(error) }; pending.clear(); work.cancel()
-        }
-    } }
+    fun close() { activity.runOnUiThread { stop(IndianaClientException("identity_changed")) } }
+    private fun stop(cause: IndianaClientException) { if (calls.stop(cause)) { host.destroy(); work.cancel() } }
     private suspend fun call(input: JSONObject): Any? = withContext(Dispatchers.Main.immediate) {
-        if (stopped) throw IndianaClientException("identity_changed")
-        withTimeout(45_000) { readiness.await() }
-        if (stopped) throw IndianaClientException("identity_changed")
-        val id = UUID.randomUUID(); val result = CompletableDeferred<Any?>(); pending[id] = result
-        try { host.send(JSONObject().put("event", "feature_call").put("id", id.toString()).put("input", input)); withTimeout(45_000) { result.await() } }
-        finally { pending.remove(id) }
+        calls.call { id -> host.send(JSONObject().put("event", "feature_call").put("id", id.toString()).put("input", input)) }
     }
     private suspend fun dispatch(method: String, raw: Any?): Any? = when (method) {
         "ready" -> { host.send(JSONObject().put("event", "init").put("surface", "features").put("scope", JSONObject().put("projectId", configuration.scope.projectId.toString()).put("environment", configuration.scope.environment.value)).put("apiOrigin", configuration.apiOrigin).put("attributes", attributes)); null }
         "featureOperation" -> {
             val value = raw as? JSONObject ?: throw IndianaClientException("invalid_command")
             val name = value.getString("operation")
-            if (stopped || name !in setOf("getFeatures", "evaluateFeatures", "trackEvents")) throw IndianaClientException("invalid_command")
+            if (calls.failure != null || name !in setOf("getFeatures", "evaluateFeatures", "trackEvents")) throw IndianaClientException("invalid_command")
             operation(IndianaCustomerOperation.valueOf(name), value.getJSONObject("input"))
         }
-        "featuresReady" -> { if (stopped) throw IndianaClientException("identity_changed"); readiness.complete(Unit); null }
+        "featuresReady" -> { calls.markReady(); null }
         "featureResult" -> {
             val value = raw as? JSONObject ?: throw IndianaClientException("invalid_command")
-            val response = pending.remove(UUID.fromString(value.getString("id")))
-            if (value.has("error")) response?.completeExceptionally(IndianaClientException("invalid_response")) else response?.complete(value.opt("result")); null
+            calls.settle(UUID.fromString(value.getString("id")), value.opt("result"), value.has("error")); null
         }
         else -> throw IndianaClientException("invalid_command")
     }

package/native-sdk/android/java/ai/tinkerland/indiana/GoogleStorefront.kt

@@ -73,10 +73,27 @@ data class GoogleStoreTerms(val productKind: String, val offerKind: String, val
 }
 sealed interface GoogleStoreResult {
     data class Purchased(val evidence: GooglePurchaseEvidence): GoogleStoreResult
+    /** The Play flow ended without a purchase: the user dismissed it, or Play refused the payment and showed why. */
     data object Canceled: GoogleStoreResult
     data class Failed(val code: String): GoogleStoreResult
 }
 
+/**
+ * Classifies a Play purchase flow that ended without a purchase. A refused payment ends like a dismissed sheet, as
+ * StoreKit reports it after its own payment sheet. Only lost Play connections and internal errors, whose purchase
+ * state is unknown, report `store_unavailable`.
+ */
+internal fun googleFlowEnded(responseCode: Int, subResponseCode: Int): GoogleStoreResult = when {
+    responseCode == BillingClient.BillingResponseCode.USER_CANCELED -> GoogleStoreResult.Canceled
+    // Google documents BILLING_UNAVAILABLE in a purchase result as a user billing error, including a refused charge.
+    responseCode == BillingClient.BillingResponseCode.BILLING_UNAVAILABLE ||
+        subResponseCode == BillingClient.OnPurchasesUpdatedSubResponseCode.PAYMENT_DECLINED_DUE_TO_INSUFFICIENT_FUNDS ||
+        subResponseCode == BillingClient.OnPurchasesUpdatedSubResponseCode.USER_INELIGIBLE -> GoogleStoreResult.Canceled
+    responseCode == BillingClient.BillingResponseCode.ITEM_UNAVAILABLE -> GoogleStoreResult.Failed("product_unavailable")
+    responseCode in setOf(BillingClient.BillingResponseCode.DEVELOPER_ERROR, BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED, BillingClient.BillingResponseCode.ITEM_NOT_OWNED) -> GoogleStoreResult.Failed("purchase_not_started")
+    else -> GoogleStoreResult.Failed("store_unavailable")
+}
+
 /** The backend owns acknowledge/consume. Purchase callbacks never grant customer access. */
 class GoogleStorefront(context: Context, private val onResult: (GoogleStoreResult) -> Unit) : IndianaGoogleStore {
     private val client = BillingClient.newBuilder(context.applicationContext)
@@ -86,8 +103,7 @@ class GoogleStorefront(context: Context, private val onResult: (GoogleStoreResul
                     if (purchase.products.size != 1 || purchase.quantity != 1 || purchase.purchaseState !in listOf(Purchase.PurchaseState.PURCHASED, Purchase.PurchaseState.PENDING)) onResult(GoogleStoreResult.Failed("unsupported_purchase"))
                     else onResult(GoogleStoreResult.Purchased(GooglePurchaseEvidence(purchase.products.single(),purchase.purchaseToken,purchase.purchaseState == Purchase.PurchaseState.PENDING,purchase.accountIdentifiers?.obfuscatedAccountId,purchase.accountIdentifiers?.obfuscatedProfileId)))
                 }
-                BillingClient.BillingResponseCode.USER_CANCELED -> onResult(GoogleStoreResult.Canceled)
-                else -> onResult(GoogleStoreResult.Failed("store_unavailable"))
+                else -> onResult(googleFlowEnded(result.responseCode, result.onPurchasesUpdatedSubResponseCode))
             }
         }
         .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())

package/native-sdk/android/java/ai/tinkerland/indiana/IndianaClient.kt

@@ -52,7 +52,6 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
     private val closed = AtomicBoolean(false)
     private val storeRestorePending = java.util.concurrent.ConcurrentHashMap<String, Pair<UUID, String>>()
     private val recoveringNative = AtomicBoolean(false)
-    private val nativeReceiptPending = java.util.concurrent.ConcurrentHashMap<UUID, Pair<UUID, String>>()
     fun identify(customerToken: String) = synchronized(identityLock) {
         if (!customerToken.matches(Regex("gg_ct_[A-Za-z0-9_-]{32,128}"))) throw IndianaClientException("unauthenticated")
         installIdentity(customerToken, null)
@@ -63,7 +62,7 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
         val next = Identity(customerToken, UUID.randomUUID())
         val invalidated = { invalidateSession(next.epoch) }
         if (session == null) http.identify(customerToken, invalidated) else http.identify(session, invalidated)
-        pushObservationID = UUID.randomUUID(); nativeReceiptPending.clear(); storeRestorePending.clear(); identity.set(next); funnels.forEach { it.get()?.reset() }; funnels.clear(); paywalls.forEach { it.get()?.close() }; paywalls.clear()
+        pushObservationID = UUID.randomUUID(); storeRestorePending.clear(); identity.set(next); funnels.forEach { it.get()?.reset() }; funnels.clear(); paywalls.forEach { it.get()?.close() }; paywalls.clear()
         contents.forEach { it.get()?.close() }; contents.clear()
         featuresClients.forEach { it.get()?.close() }; featuresClients.clear(); schedulePush()
     }
@@ -83,7 +82,7 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
     private fun clearIdentity() {
         analyticsTimer?.cancel(); analyticsTimer = null; analyticsEvents.clear()
         try { pushIdentity?.reserve(detach = true); pushSynchronizationError = null } catch (_: Exception) { pushSynchronizationError = "protected_storage_unavailable" }
-        pushObservationID = UUID.randomUUID(); pushBindingSequence = 0; nativeReceiptPending.clear(); storeRestorePending.clear(); identity.set(Identity(null, UUID.randomUUID())); funnels.forEach { it.get()?.reset() }; funnels.clear(); paywalls.forEach { it.get()?.close() }; paywalls.clear()
+        pushObservationID = UUID.randomUUID(); pushBindingSequence = 0; storeRestorePending.clear(); identity.set(Identity(null, UUID.randomUUID())); funnels.forEach { it.get()?.reset() }; funnels.clear(); paywalls.forEach { it.get()?.close() }; paywalls.clear()
         contents.forEach { it.get()?.close() }; contents.clear()
         featuresClients.forEach { it.get()?.close() }; featuresClients.clear(); schedulePush()
     }
@@ -94,44 +93,16 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
         http.identify(null)
         clearIdentity()
     }
-    /** Relay attaches the server API key on your backend. No run credential is needed, even after run expiry. */
-    suspend fun recoverNativeOrders(context: Context, relay: suspend (JSONObject) -> JSONObject): List<JSONObject> = recoverOrders(IndianaNativePendingKeystore(context, configuration.scope), GoogleStorefront(context) { }, relay)
-    internal suspend fun recoverOrders(storage: IndianaNativePendingStorage, store: IndianaGoogleStore, relay: suspend (JSONObject) -> JSONObject): List<JSONObject> {
-        checkOpen(); val actor = identity.get(); val token = actor.token ?: throw IndianaClientException("unauthenticated")
-        if (configuration.scope.environment != IndianaEnvironment.SANDBOX || !recoveringNative.compareAndSet(false, true)) throw IndianaClientException("command_pending")
-        try {
-            store.connect(); val records = storage.orders()
-            val purchases = store.scanPurchases(false) + store.scanPurchases(true)
-            val responses = mutableListOf<JSONObject>()
-            for (record in records) {
-                checkOpen(); if (identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
-                val receipt = purchases.singleOrNull { it.productId == record.productId && it.accountBinding == record.accountId && it.intentBinding == record.profileId }
-                val command = nativeReceiptPending[record.orderId] ?: run {
-                    val requestId = UUID.randomUUID()
-                    if (receipt != null && receipt.purchaseToken.toByteArray().size > 16384) throw IndianaClientException("invalid_evidence")
-                    val evidence = receipt?.let { JSONObject().put("provider", "google").put("orderId", record.orderId.toString()).put("receiptId", record.receiptId.toString()).put("purchaseToken", it.purchaseToken) }
-                    requestId to JSONObject().put("operation", "native_receipt").put("requestId", requestId.toString()).put("customerToken", token).put("orderId", record.orderId.toString()).put("receiptId", record.receiptId.toString()).put("nativeEvidence", evidence ?: JSONObject.NULL).toString()
-                }.also { nativeReceiptPending[record.orderId] = it }
-                val credential = http.access()
-                if (identity.get().epoch != actor.epoch || closed.get()) throw IndianaClientException("identity_changed")
-                val outgoing = JSONObject(command.second).put("customerToken", credential)
-                val result = try { relay(outgoing) } catch (error: IndianaClientException) {
-                    if (identity.get().epoch != actor.epoch || closed.get()) throw IndianaClientException("identity_changed")
-                    val status = error.code.removePrefix("request_failed_").toIntOrNull()
-                    if (status != null && status < 500 && status != 425) { nativeReceiptPending.remove(record.orderId); if (status in setOf(403,404)) continue }
-                    throw error
-                }
-                if (identity.get().epoch != actor.epoch || closed.get()) throw IndianaClientException("identity_changed")
-                if (safe { scope(result.getJSONObject("scope")) } != configuration.scope || result.optString("requestId") != command.first.toString() || result.optString("orderId") != record.orderId.toString() || result.optString("receiptId") != record.receiptId.toString() || result.optString("orderStatus") !in setOf("created", "pending", "trialing", "paid", "cancelled", "failed") || result.opt("refunded") !is Boolean) throw IndianaClientException("invalid_response")
-                result.optJSONObject("nativeCompletion")?.let { completion ->
-                    if (completion.optString("orderId") != record.orderId.toString() || completion.optString("receiptId") != record.receiptId.toString() || completion.opt("membership") !is Boolean) throw IndianaClientException("invalid_response")
-                    val ids = completion.getJSONArray("transactionIds"); if (ids.length() !in 1..50 || (0 until ids.length()).any { ids.opt(it) !is String || ids.getString(it).length !in 1..255 } || (0 until ids.length()).map { ids.getString(it) }.distinct().size != ids.length()) throw IndianaClientException("invalid_response")
-                    if (!completion.getBoolean("membership")) storage.remove(record.orderId)
-                }
-                nativeReceiptPending.remove(record.orderId); responses.add(JSONObject(result.toString()))
-            }
-            return responses
-        } finally { store.close(); recoveringNative.set(false) }
+    /**
+     * Play's purchase list is the recovery source: every SDK purchase carries its order binding and Play lists it until
+     * the server consumes it or the subscription ends, so [restorePurchases] and a retried [purchaseSubscription] recover it.
+     * No local order journal exists; this compatibility entry relays nothing and returns no orders.
+     */
+    @Deprecated("Play's purchase list is the recovery source; call restorePurchases(context).")
+    @Suppress("UNUSED_PARAMETER")
+    suspend fun recoverNativeOrders(context: Context, relay: suspend (JSONObject) -> JSONObject): List<JSONObject> {
+        checkOpen(); if (identity.get().token == null) throw IndianaClientException("unauthenticated")
+        return emptyList()
     }
     /** Reinstall and device-change recovery uses the store's current transactions, never a local order journal. */
     suspend fun restorePurchases(context: Context): List<JSONObject> = restoreStorePurchases(GoogleStorefront(context) {})
@@ -145,10 +116,24 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
                 if (identity.get().epoch != actor.epoch || closed.get()) throw IndianaClientException("identity_changed")
                 val intent = purchase.intentBinding?.let { runCatching { UUID.fromString(it) }.getOrNull() }
                 // Unbound historical purchases are not automatically transferred to a signed-in app account.
-                intent?.let { submitStorePurchase(purchase,it,actor.epoch) }
+                intent?.let { restoreOne(purchase,it,actor.epoch) }
             }
         } finally { store.close(); recoveringNative.set(false) }
     }
+    /**
+     * The Play account can hold purchases bound to another Customer or scope. Their definite refusal (403/404) skips
+     * that purchase; any other refusal or unknown result ends the restore.
+     */
+    private suspend fun restoreOne(purchase: GooglePurchaseEvidence, intent: UUID, original: UUID): JSONObject? = try {
+        submitStorePurchase(purchase,intent,original)
+    } catch (error: IndianaClientException) {
+        if (identity.get().epoch != original || closed.get()) throw IndianaClientException("identity_changed")
+        val status = error.code.removePrefix("request_failed_").toIntOrNull()
+        // A definite refusal settles that request; a later attempt starts a new one.
+        if (status != null && status < 500 && status != 425) storeRestorePending.remove(purchase.purchaseToken)
+        if (status != 403 && status != 404) throw error
+        null
+    }
     private suspend fun submitStorePurchase(purchase: GooglePurchaseEvidence, intent: UUID, original: UUID): JSONObject {
         if (purchase.purchaseToken.toByteArray().size > 16384) throw IndianaClientException("invalid_evidence")
         val command = storeRestorePending[purchase.purchaseToken] ?: run {
@@ -165,7 +150,12 @@ class IndianaClient internal constructor(private val configuration: IndianaConfi
         }
         storeRestorePending.remove(purchase.purchaseToken); return result
     }
-    /** Uses the fixed server instruction and actual Play quote; the server owns acknowledgement and grants. */
+    /**
+     * Uses the fixed server instruction and actual Play quote; the server owns acknowledgement and grants. A dismissed
+     * sheet or a payment Play refused ends the operation as cancelled. The wait for Play's result follows the user's
+     * sheet and has no deadline: cancel the calling coroutine to stop waiting. The operation then stays pending, and a
+     * retry with the same `operationId` first submits any purchase Play completed.
+     */
     suspend fun purchaseSubscription(activity: Activity, operationId: UUID, confirm: suspend (GoogleQuote) -> Boolean): JSONObject {
         if (!recoveringNative.compareAndSet(false,true)) throw IndianaClientException("command_pending")
         try { return purchaseSubscriptionInternal(activity,operationId,false,confirm) } finally { recoveringNative.set(false) }

package/native-sdk/android/java/ai/tinkerland/indiana/SDKVersion.kt

@@ -2,5 +2,5 @@
 package ai.tinkerland.indiana
 
 object IndianaSDK {
-    const val version = "0.10.11"
+    const val version = "0.10.14"
 }