@purchasely/cordova-plugin-purchasely 5.7.3 → 6.0.0-rc.3

package/src/android/PurchaselyPlugin.kt

@@ -1,7 +1,5 @@
 package cordova.plugin.purchasely
 
-import android.app.Activity
-import android.content.Intent
 import android.net.Uri
 import android.os.Build
 import android.util.Log
@@ -10,28 +8,24 @@ import io.purchasely.ext.Attribute
 import io.purchasely.ext.DistributionType
 import io.purchasely.ext.EventListener
 import io.purchasely.ext.LogLevel
+import io.purchasely.ext.PLYActionInterceptorCallback
 import io.purchasely.ext.PLYAppTechnology
-import io.purchasely.ext.PLYCompletionHandler
 import io.purchasely.ext.PLYDataProcessingLegalBasis
 import io.purchasely.ext.PLYDataProcessingPurpose
 import io.purchasely.ext.PLYEvent
-import io.purchasely.ext.PLYPresentation
-import io.purchasely.ext.PLYPresentationAction
-import io.purchasely.ext.PLYPresentationType
-import io.purchasely.ext.PLYPresentationProperties
-import io.purchasely.ext.PLYProductViewResult
+import io.purchasely.ext.PLYInterceptResult
+import io.purchasely.ext.PLYInterceptorInfo
 import io.purchasely.ext.PLYRunningMode
-import io.purchasely.ext.PLYRunningMode.Full
-import io.purchasely.ext.PLYRunningMode.PaywallObserver
-import io.purchasely.ext.PlanListener
-import io.purchasely.ext.ProductListener
-import io.purchasely.ext.ProductsListener
 import io.purchasely.ext.PurchaseListener
 import io.purchasely.ext.Purchasely
 import io.purchasely.ext.State
 import io.purchasely.ext.StoreType
-import io.purchasely.ext.SubscriptionsListener
 import io.purchasely.ext.UserAttributeListener
+import io.purchasely.ext.presentation.PLYPresentationAction
+import io.purchasely.ext.presentation.PLYPresentationBase
+import io.purchasely.ext.presentation.PLYPresentationOutcome
+import io.purchasely.ext.presentation.display
+import io.purchasely.ext.presentation.preload
 import io.purchasely.storage.userData.PLYUserAttributeSource
 import io.purchasely.storage.userData.PLYUserAttributeType
 import io.purchasely.models.PLYError
@@ -40,26 +34,52 @@ import io.purchasely.models.PLYPresentationPlan
 import io.purchasely.models.PLYProduct
 import io.purchasely.models.PLYSubscriptionData
 import io.purchasely.views.presentation.PLYThemeMode
+import io.purchasely.views.presentation.models.PLYDimensionType
+import io.purchasely.views.presentation.models.PLYTransition
+import io.purchasely.views.presentation.models.PLYTransitionDimension
+import io.purchasely.views.presentation.models.PLYTransitionType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import org.apache.cordova.CallbackContext
-import org.apache.cordova.CordovaInterface
 import org.apache.cordova.CordovaPlugin
 import org.apache.cordova.PluginResult
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
-import java.lang.ref.WeakReference
 import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * This class echoes a string called from JavaScript.
  */
-class PurchaselyPlugin : CordovaPlugin() {
-    private var paywallActionHandler: PLYCompletionHandler? = null
-    private var paywallAction: PLYPresentationAction? = null
+class PurchaselyPlugin : CordovaPlugin(), CoroutineScope {
+
+    private val job = SupervisorJob()
+    override val coroutineContext = job + Dispatchers.Main
+
+    // v6 per-action interceptor state. Each registered action kind keeps its own
+    // Cordova callback (to emit intercept events); each intercepted invocation stashes
+    // its completion under a unique id so concurrent intercepts resolve independently.
+    private val actionInterceptorCallbacks = ConcurrentHashMap<String, CallbackContext>()
+    private val pendingInterceptCompletions = ConcurrentHashMap<String, (PLYInterceptResult) -> Unit>()
+    private var interceptorInvocationCounter = 0
+
+    // Presentation currently displayed (used for back()/close()).
+    private var displayedPresentation: PLYPresentationBase.Loaded? = null
+    // Presentations preloaded by fetchPresentation, keyed by a synthetic handle
+    // (the "id" we send back to JS) so presentPresentation can re-display them.
+    private val loadedPresentations = ConcurrentHashMap<String, PLYPresentationBase.Loaded>()
+
+    override fun onDestroy() {
+        job.cancel()
+        super.onDestroy()
+    }
 
     override fun execute(
         action: String,
@@ -68,16 +88,7 @@ class PurchaselyPlugin : CordovaPlugin() {
     ): Boolean {
         try {
             when (action) {
-                "start" -> start(
-                    getStringFromJson(args.getString(0)),
-                    args.getJSONArray(1),
-                    args.getBoolean(2),
-                    getStringFromJson(args.getString(3)),
-                    args.getInt(4),
-                    args.getInt(5),
-                    getStringFromJson(args.getString(6)),
-                    callbackContext
-                )
+                "start" -> start(args.getJSONObject(0), callbackContext)
 
                 "close" -> close()
                 "addEventsListener" -> addEventsListener(callbackContext)
@@ -91,42 +102,35 @@ class PurchaselyPlugin : CordovaPlugin() {
                 "setLogLevel" -> setLogLevel(args.getInt(0))
                 "setThemeMode" -> setThemeMode(args.getInt(0))
                 "setAttribute" -> setAttribute(args.getInt(0), getStringFromJson(args.getString(1)))
-                "setDefaultPresentationResultHandler" -> setDefaultPresentationResultHandler(
+                "setDefaultPresentationDismissHandler" -> setDefaultPresentationDismissHandler(
                     callbackContext
                 )
+                "removeDefaultPresentationDismissHandler" -> removeDefaultPresentationDismissHandler(callbackContext)
 
                 "purchasedSubscription" -> purchasedSubscription(callbackContext)
-                "readyToOpenDeeplink" -> readyToOpenDeeplink(args.getBoolean(0))
-                "synchronize" -> synchronize()
+                "allowDeeplink" -> allowDeeplink(args.getBoolean(0))
+                "allowCampaigns" -> allowCampaigns(args.getBoolean(0))
+                "synchronize" -> synchronize(callbackContext)
                 "presentPresentationWithIdentifier" -> presentPresentationWithIdentifier(
                     getStringFromJson(args.getString(0)),
                     getStringFromJson(args.getString(1)),
-                    args.getBoolean(2),
+                    args.optJSONObject(2),
                     callbackContext
                 )
 
                 "presentPresentationForPlacement" -> presentPresentationForPlacement(
                     getStringFromJson(args.getString(0)),
                     getStringFromJson(args.getString(1)),
-                    args.getBoolean(2),
+                    args.optJSONObject(2),
                     callbackContext
                 )
 
-                "presentProductWithIdentifier" -> presentProductWithIdentifier(
+                "presentPresentationForDefault" -> presentPresentationForDefault(
                     getStringFromJson(args.getString(0)),
-                    getStringFromJson(args.getString(1)),
-                    getStringFromJson(args.getString(2)),
-                    args.getBoolean(3),
+                    args.optJSONObject(1),
                     callbackContext
                 )
 
-                "presentPlanWithIdentifier" -> presentPlanWithIdentifier(
-                    getStringFromJson(args.getString(0)),
-                    getStringFromJson(args.getString(1)),
-                    getStringFromJson(args.getString(2)),
-                    args.getBoolean(3),
-                    callbackContext
-                )
                 "fetchPresentation" -> fetchPresentation(
                     getStringFromJson(args.getString(0)),
                     getStringFromJson(args.getString(1)),
@@ -135,16 +139,15 @@ class PurchaselyPlugin : CordovaPlugin() {
                 )
                 "presentPresentation" -> presentPresentation(
                     args.getJSONObject(0),
-                    args.getBoolean(1),
+                    args.optJSONObject(1),
                     getStringFromJson(args.getString(2)),
                     callbackContext
                 )
-                "presentSubscriptions" -> presentSubscriptions()
                 "restoreAllProducts" -> restoreAllProducts(callbackContext)
                 "silentRestoreAllProducts" -> restoreAllProducts(callbackContext)
                 "userSubscriptions" -> userSubscriptions(callbackContext)
                 "userSubscriptionsHistory" -> userSubscriptionsHistory(callbackContext)
-                "isDeeplinkHandled" -> isDeeplinkHandled(
+                "handleDeeplink" -> handleDeeplink(
                     getStringFromJson(args.getString(0)),
                     callbackContext
                 )
@@ -166,11 +169,11 @@ class PurchaselyPlugin : CordovaPlugin() {
                     getStringFromJson(args.getString(2)),
                     callbackContext
                 )
-                "setPaywallActionInterceptor" -> setPaywallActionInterceptor(callbackContext)
-                "onProcessAction" -> onProcessAction(args.getBoolean(0))
+                "registerActionInterceptor" -> registerActionInterceptor(getStringFromJson(args.getString(0)), callbackContext)
+                "unregisterActionInterceptor" -> unregisterActionInterceptor(getStringFromJson(args.getString(0)))
+                "completeActionInterceptor" -> completeActionInterceptor(getStringFromJson(args.getString(0)), getStringFromJson(args.getString(1)))
                 "closePresentation" -> closePresentation(callbackContext)
-                "hidePresentation" -> hidePresentation()
-                "showPresentation" -> showPresentation()
+                "backPresentation" -> backPresentation(callbackContext)
                 "userDidConsumeSubscriptionContent" -> userDidConsumeSubscriptionContent()
                 "setUserAttributeWithString" -> setUserAttributeWithString(getStringFromJson(args.getString(0)), getStringFromJson(args.getString(1)), getStringFromJson(args.optString(2)))
                 "setUserAttributeWithBoolean" -> setUserAttributeWithBoolean(getStringFromJson(args.getString(0)), args.getBoolean(1), getStringFromJson(args.optString(2)))
@@ -203,52 +206,83 @@ class PurchaselyPlugin : CordovaPlugin() {
         } else value
     }
 
-    private fun start(
-        apiKey: String?,
-        stores: JSONArray,
-        storeKit1: Boolean,
-        userId: String?,
-        logLevel: Int,
-        runningMode: Int,
-        cordovaSdkVersion: String?,
-        callbackContext: CallbackContext
-    ) {
+    //region start
+    private fun logLevelFrom(raw: Any?): LogLevel {
+        return when (raw) {
+            is Number -> LogLevel.values().getOrElse(raw.toInt()) { LogLevel.ERROR }
+            is String -> LogLevel.values().firstOrNull { it.name.equals(raw, ignoreCase = true) } ?: LogLevel.ERROR
+            else -> LogLevel.ERROR
+        }
+    }
 
-        if(apiKey == null) {
+    // v6: running mode is passed by NAME ("observer"/"full"). The old int mapping is
+    // gone; PLYRunningMode has only Observer (default) and Full.
+    private fun runningModeFrom(raw: Any?): PLYRunningMode {
+        return when (raw) {
+            is Number -> when (raw.toInt()) {
+                1 -> PLYRunningMode.Full
+                else -> PLYRunningMode.Observer
+            }
+            is String -> when (raw.lowercase(Locale.US)) {
+                "full" -> PLYRunningMode.Full
+                else -> PLYRunningMode.Observer
+            }
+            else -> PLYRunningMode.Observer
+        }
+    }
+
+    private fun start(options: JSONObject, callbackContext: CallbackContext) {
+        val apiKey = getStringFromJson(options.optString("apiKey"))
+        if (apiKey == null) {
             callbackContext.error("API Key is null")
             return
         }
 
-        val list = ArrayList<String>()
-        for (i in 0 until stores.length()) {
-            try {
-                list.add(stores.getString(i))
-            } catch (e: JSONException) {
-                Log.e("Purchasely", "Error in store array" + e.message, e)
+        val userId = getStringFromJson(options.optString("appUserId"))
+        val logLevel = logLevelFrom(options.opt("logLevel"))
+        val runningMode = runningModeFrom(options.opt("runningMode"))
+
+        val storesList = ArrayList<String>()
+        options.optJSONArray("stores")?.let { arr ->
+            for (i in 0 until arr.length()) {
+                try {
+                    storesList.add(arr.getString(i))
+                } catch (e: JSONException) {
+                    Log.e("Purchasely", "Error in store array" + e.message, e)
+                }
             }
         }
-        val storesInstances = getStoresInstances(list)
-        var plyRunningMode: PLYRunningMode = Full
-        if (runningMode == runningModePaywallObserver) plyRunningMode = PaywallObserver
+
+        val allowDeeplink = if (options.has("allowDeeplink")) options.optBoolean("allowDeeplink") else null
+        val allowCampaigns = if (options.has("allowCampaigns")) options.optBoolean("allowCampaigns") else null
+        val deeplink = getStringFromJson(options.optString("deeplink"))
+        val sdkVersion = getStringFromJson(options.optString("sdkVersion"))
+
         Purchasely.Builder(cordova.context)
             .apiKey(apiKey)
-            .stores(storesInstances)
+            .stores(getStoresInstances(storesList))
             .userId(userId)
-            .runningMode(plyRunningMode)
-            .logLevel(LogLevel.values()[logLevel])
+            .runningMode(runningMode)
+            .logLevel(logLevel)
+            .apply {
+                allowDeeplink?.let { this.allowDeeplink(it) }
+                allowCampaigns?.let { this.allowCampaigns(it) }
+                // Cold-start deeplink: replayed automatically once started.
+                deeplink?.let { this.handleDeeplink(Uri.parse(it)) }
+            }
             .build()
-        Purchasely.sdkBridgeVersion = cordovaSdkVersion
+
+        Purchasely.sdkBridgeVersion = sdkVersion
         Purchasely.appTechnology = PLYAppTechnology.CORDOVA
-        Purchasely.start { isConfigured: Boolean, error: PLYError? ->
-            if (isConfigured) {
-                callbackContext.success()
+        Purchasely.start { error: PLYError? ->
+            if (error == null) {
+                callbackContext.sendPluginResult(PluginResult(PluginResult.Status.OK, true))
             } else {
-                callbackContext.error(
-                    if (error != null) error.message else "Purchasely SDK not configured"
-                )
+                callbackContext.error(error.message ?: "Purchasely SDK not configured")
             }
         }
     }
+    //endregion
 
     private fun getStoresInstances(stores: List<String>): ArrayList<Store> {
         val result = ArrayList<Store>()
@@ -279,9 +313,12 @@ class PurchaselyPlugin : CordovaPlugin() {
     private fun close() {
         defaultCallback = null
         purchaseCallback = null
-        paywallActionHandler = null
-        productActivity = null
-        Purchasely.close()
+        actionInterceptorCallbacks.clear()
+        pendingInterceptCompletions.clear()
+        displayedPresentation = null
+        // TODO(v6-verify): the global Purchasely.close() teardown was removed/lumped with
+        // presentation close in v6 (Flutter never calls it). Not invoked here to avoid a
+        // reference to a symbol that may no longer exist.
     }
 
     private fun addUserAttributesListener(callbackContext: CallbackContext) {
@@ -358,7 +395,7 @@ class PurchaselyPlugin : CordovaPlugin() {
     }
 
     private fun userLogout() {
-        Purchasely.userLogout()
+        Purchasely.userLogout(true)
     }
 
     private fun setLogLevel(logLevel: Int) {
@@ -373,8 +410,12 @@ class PurchaselyPlugin : CordovaPlugin() {
         }
     }
 
-    private fun readyToOpenDeeplink(isReadyToPurchase: Boolean) {
-        Purchasely.readyToOpenDeeplink = isReadyToPurchase
+    private fun allowDeeplink(allow: Boolean) {
+        Purchasely.allowDeeplink = allow
+    }
+
+    private fun allowCampaigns(allow: Boolean) {
+        Purchasely.allowCampaigns = allow
     }
 
     private fun setThemeMode(mode: Int) {
@@ -414,15 +455,16 @@ class PurchaselyPlugin : CordovaPlugin() {
         }
     }
 
-    private fun setDefaultPresentationResultHandler(callbackContext: CallbackContext) {
+    //region Default presentation dismiss handler
+    private fun setDefaultPresentationDismissHandler(callbackContext: CallbackContext) {
         defaultCallback = callbackContext
-        Purchasely.setDefaultPresentationResultHandler { result: PLYProductViewResult, plan: PLYPlan? ->
-            sendPurchaseResult(
-                result,
-                plan
-            )
+        Purchasely.setDefaultPresentationDismissHandler { outcome: PLYPresentationOutcome ->
+            val pluginResult = PluginResult(PluginResult.Status.OK, JSONObject(outcomeToMap(outcome)))
+            pluginResult.keepCallback = true
+            defaultCallback?.sendPluginResult(pluginResult)
         }
     }
+    //endregion
 
     private fun purchasedSubscription(callbackContext: CallbackContext) {
         Purchasely.purchaseListener = object : PurchaseListener {
@@ -437,72 +479,115 @@ class PurchaselyPlugin : CordovaPlugin() {
         }
     }
 
-    private fun synchronize() {
-        Purchasely.synchronize()
+    private fun synchronize(callbackContext: CallbackContext) {
+        Purchasely.synchronize(
+            onSuccess = {
+                callbackContext.sendPluginResult(PluginResult(PluginResult.Status.OK, true))
+            },
+            onError = { error ->
+                callbackContext.error(error?.message ?: "Synchronization failed")
+            }
+        )
     }
 
     private fun userDidConsumeSubscriptionContent() {
         Purchasely.userDidConsumeSubscriptionContent()
     }
 
+    //region Presentation lifecycle
+    // v6: the presentation activities are gone. A presentation is built via the
+    // builder DSL, preloaded, then displayed. `displayMode` maps to a PLYTransition.
     private fun presentPresentationWithIdentifier(
         presentationVendorId: String?,
         contentId: String?,
-        isFullScreen: Boolean,
+        transition: JSONObject?,
         callbackContext: CallbackContext
     ) {
         purchaseCallback = callbackContext
-        val intent = PLYProductActivity.newIntent(cordova.activity)
-        intent.putExtra("presentationId", presentationVendorId)
-        intent.putExtra("contentId", contentId)
-        intent.putExtra("isFullScreen", isFullScreen)
-        cordova.activity.startActivity(intent)
+        displayPresentation(
+            screenId = presentationVendorId,
+            placementId = null,
+            contentId = contentId,
+            transition = transition,
+            callbackContext = callbackContext
+        )
     }
 
     private fun presentPresentationForPlacement(
         placementVendorId: String?,
         contentId: String?,
-        isFullScreen: Boolean,
+        transition: JSONObject?,
         callbackContext: CallbackContext
     ) {
         purchaseCallback = callbackContext
-        val intent = PLYProductActivity.newIntent(cordova.activity)
-        intent.putExtra("placementId", placementVendorId)
-        intent.putExtra("contentId", contentId)
-        intent.putExtra("isFullScreen", isFullScreen)
-        cordova.activity.startActivity(intent)
+        displayPresentation(
+            screenId = null,
+            placementId = placementVendorId,
+            contentId = contentId,
+            transition = transition,
+            callbackContext = callbackContext
+        )
     }
 
-    private fun presentProductWithIdentifier(
-        productVendorId: String?,
-        presentationVendorId: String?,
+    // v6: present the default (audience-targeted) presentation — no placement/screen id.
+    private fun presentPresentationForDefault(
         contentId: String?,
-        isFullScreen: Boolean,
+        transition: JSONObject?,
         callbackContext: CallbackContext
     ) {
         purchaseCallback = callbackContext
-        val intent = PLYProductActivity.newIntent(cordova.activity)
-        intent.putExtra("presentationId", presentationVendorId)
-        intent.putExtra("productId", productVendorId)
-        intent.putExtra("contentId", contentId)
-        intent.putExtra("isFullScreen", isFullScreen)
-        cordova.activity.startActivity(intent)
+        displayPresentation(
+            screenId = null,
+            placementId = null,
+            contentId = contentId,
+            transition = transition,
+            callbackContext = callbackContext
+        )
     }
 
-    private fun presentPlanWithIdentifier(
-        planVendorId: String?,
-        presentationVendorId: String?,
+    private fun displayPresentation(
+        screenId: String?,
+        placementId: String?,
         contentId: String?,
-        isFullScreen: Boolean,
+        transition: JSONObject?,
         callbackContext: CallbackContext
     ) {
-        purchaseCallback = callbackContext
-        val intent = PLYProductActivity.newIntent(cordova.activity)
-        intent.putExtra("presentationId", presentationVendorId)
-        intent.putExtra("planId", planVendorId)
-        intent.putExtra("contentId", contentId)
-        intent.putExtra("isFullScreen", isFullScreen)
-        cordova.activity.startActivity(intent)
+        launch {
+            try {
+                val builder = PLYPresentationBase.builder().apply {
+                    when {
+                        placementId != null -> this.placementId(placementId)
+                        screenId != null -> this.screenId(screenId)
+                        // else: default (audience-targeted) source — no id
+                    }
+                    contentId(contentId)
+                    // v6: stream the presentation lifecycle to the JS callback via keep-alive
+                    // envelopes; the dismiss outcome is delivered as the final (non-kept)
+                    // result by sendPurchaseResult.
+                    onPresented { presentation, error ->
+                        val env = mutableMapOf<String, Any?>("event" to "presented")
+                        presentation?.let { env["presentation"] = presentationToMap(it) }
+                        error?.let { env["error"] = it.message }
+                        val r = PluginResult(PluginResult.Status.OK, JSONObject(env))
+                        r.keepCallback = true
+                        callbackContext.sendPluginResult(r)
+                    }
+                    onCloseRequested {
+                        val r = PluginResult(PluginResult.Status.OK, JSONObject(mapOf("event" to "closeRequested")))
+                        r.keepCallback = true
+                        callbackContext.sendPluginResult(r)
+                    }
+                }
+                val loaded = builder.build().preload()
+                displayedPresentation = loaded
+                loaded.display(cordova.activity, transitionFromMap(transition)) { outcome ->
+                    sendPurchaseResult(outcome)
+                }
+            } catch (t: Throwable) {
+                if (purchaseCallback === callbackContext) purchaseCallback = null
+                callbackContext.error(t.message ?: "Unable to present presentation")
+            }
+        }
     }
 
     private fun fetchPresentation(
@@ -510,43 +595,31 @@ class PurchaselyPlugin : CordovaPlugin() {
         presentationId: String?,
         contentId: String?,
         callbackContext: CallbackContext) {
-        val properties = PLYPresentationProperties(
-            placementId = placementId,
-            presentationId = presentationId,
-            contentId = contentId)
-
-        Purchasely.fetchPresentation(properties = properties) { presentation: PLYPresentation?, error: PLYError? ->
-            if(presentation != null) {
-                presentationsLoaded.removeAll { it.id == presentation.id && it.placementId == presentation.placementId }
-                presentationsLoaded.add(presentation)
-                val map = presentation.toMap().mapValues {
-                    val value = it.value
-                    if(value is PLYPresentationType) value.ordinal
-                    else value
-                }
-
-                val mutableMap = map.toMutableMap().apply {
-                    //this["metadata"] = presentation.metadata?.toMap()
-                    this["plans"] = (this["plans"] as List<PLYPresentationPlan>).map { it.toMap() }
+        launch {
+            try {
+                val builder = PLYPresentationBase.builder().apply {
+                    when {
+                        placementId != null -> this.placementId(placementId)
+                        presentationId != null -> this.screenId(presentationId)
+                        // else: neither id → the default (audience-targeted) presentation
+                    }
+                    contentId(contentId)
                 }
+                val loaded = builder.build().preload()
+                // Synthetic handle so presentPresentation can re-display this preloaded presentation.
+                val handle = "ply_fetch_${System.nanoTime()}"
+                loadedPresentations[handle] = loaded
+                val map = presentationToMap(loaded).toMutableMap()
+                map["id"] = handle
                 callbackContext.success(JSONObject(map))
+            } catch (t: Throwable) {
+                callbackContext.error(t.message ?: "Unable to fetch presentation")
             }
-            if(error != null) callbackContext.error(error.message ?: "Unable to fetch presentation")
         }
     }
 
-    // Delete when available in Android SDK
-    fun PLYPresentationPlan.toMap() : Map<String, String?> {
-        return mapOf(
-            Pair("planVendorId", planVendorId),
-            Pair("storeProductId", storeProductId),
-            Pair("basePlanId", basePlanId),
-            //Pair("offerId", offerId)
-        )
-    }
-
     private fun presentPresentation(presentationMap: JSONObject?,
-                            isFullScreen: Boolean,
+                            transition: JSONObject?,
                             loadingBackgroundColor: String?,
                             callbackContext: CallbackContext) {
         if (presentationMap == null) {
@@ -554,112 +627,130 @@ class PurchaselyPlugin : CordovaPlugin() {
             return
         }
 
-        val presentation = presentationsLoaded.lastOrNull {
-            it.id == presentationMap.getString("id")
-                    && it.placementId == presentationMap.getString("placementId")
-        }
-        if(presentation == null) {
+        val handle = if (presentationMap.has("id")) presentationMap.optString("id") else null
+        val loaded = handle?.let { loadedPresentations[it] }
+        if (loaded == null) {
             callbackContext.error("presentation cannot be found")
             return
         }
 
         purchaseCallback = callbackContext
-
-        cordova.activity.let { activity ->
-            if (presentation.flowId != null) {
-                presentation.display(activity) { result, plan ->
-                    sendPurchaseResult(result, plan)
-                }
-            } else {
-                // Open legacy Activity for now if not a flow
-                val intent = PLYProductActivity.newIntent(activity, PLYPresentationProperties(), isFullScreen, loadingBackgroundColor).apply {
-                    putExtra("presentation", presentation)
-                }
-                activity.startActivity(intent)
+        displayedPresentation = loaded
+
+        // TODO(v6-verify): loadingBackgroundColor cannot be applied to an already-preloaded
+        // presentation in v6 (colors are builder options set before preload). The re-display
+        // path delivers the dismiss outcome only; onPresented/onCloseRequested are wired on the
+        // direct present* methods (builder-seeded before preload).
+        cordova.activity?.runOnUiThread {
+            loaded.display(cordova.activity, transitionFromMap(transition)) { outcome ->
+                sendPurchaseResult(outcome)
             }
         }
-
     }
 
-    private fun presentSubscriptions() {
-        val intent =
-            Intent(cordova.context, PLYSubscriptionsActivity::class.java)
-        cordova.activity.startActivity(intent)
+    // v6: stop receiving default (campaign/deeplink) presentation dismiss outcomes.
+    private fun removeDefaultPresentationDismissHandler(callbackContext: CallbackContext) {
+        // Android's setter is non-null; install a no-op handler and drop the JS callback
+        // so default (campaign/deeplink) dismiss outcomes are no longer forwarded.
+        Purchasely.setDefaultPresentationDismissHandler { }
+        defaultCallback = null
+        callbackContext.success()
     }
 
-    private fun restoreAllProducts(callbackContext: CallbackContext) {
-        Purchasely.restoreAllProducts({ plyPlan: PLYPlan? ->
-            callbackContext.success(JSONObject(transformPlanToMap(plyPlan)))
-        }) { plyError: PLYError? ->
-            callbackContext.error(plyError?.message)
+    // Maps the JS transition object to a v6 PLYTransition. Shape:
+    //   { type, dismissible?, width?: {type,value}, height?: {type,value} }
+    // width is popin-only; height drives drawer+popin. Null → surface default.
+    private fun transitionFromMap(map: JSONObject?): PLYTransition? {
+        if (map == null) return null
+        val type = when (map.optString("type")) {
+            "fullScreen" -> PLYTransitionType.FULLSCREEN
+            "push" -> PLYTransitionType.PUSH
+            "modal" -> PLYTransitionType.MODAL
+            "drawer" -> PLYTransitionType.DRAWER
+            "popin" -> PLYTransitionType.POPIN
+            "inlinePaywall" -> PLYTransitionType.INLINE_PAYWALL
+            else -> return null
         }
+        return PLYTransition(
+            type = type,
+            width = dimensionFromMap(map.optJSONObject("width")),
+            height = dimensionFromMap(map.optJSONObject("height")),
+            dismissible = map.optBoolean("dismissible", true)
+        )
     }
 
-    private fun userSubscriptions(callbackContext: CallbackContext) {
-        Purchasely.userSubscriptions(
-            false,
-            object : SubscriptionsListener {
-                override fun onSuccess(list: List<PLYSubscriptionData>) {
-                    val result = JSONArray()
-                    for (i in list.indices) {
-                        val data = list[i]
-                        val map = HashMap(data.toMap())
-                        map["plan"] = transformPlanToMap(data.plan)
-                        map["product"] = data.product.toMap()
-                        if (data.data.storeType == StoreType.GOOGLE_PLAY_STORE) {
-                            map["subscriptionSource"] = StoreType.GOOGLE_PLAY_STORE.ordinal
-                        } else if (data.data.storeType == StoreType.AMAZON_APP_STORE) {
-                            map["subscriptionSource"] = StoreType.AMAZON_APP_STORE.ordinal
-                        } else if (data.data.storeType == StoreType.HUAWEI_APP_GALLERY) {
-                            map["subscriptionSource"] = StoreType.HUAWEI_APP_GALLERY.ordinal
-                        } else if (data.data.storeType == StoreType.APPLE_APP_STORE) {
-                            map["subscriptionSource"] = StoreType.APPLE_APP_STORE.ordinal
-                        }
-                        result.put(JSONObject(map))
-                    }
-                    callbackContext.success(result)
-                }
+    // { type: 'pixel'|'percentage', value: Number } → PLYTransitionDimension. Null when absent.
+    private fun dimensionFromMap(map: JSONObject?): PLYTransitionDimension? {
+        if (map == null || !map.has("value")) return null
+        val value = map.optDouble("value").toFloat()
+        val type = if (map.optString("type") == "pixel") PLYDimensionType.PIXEL else PLYDimensionType.PERCENTAGE
+        return PLYTransitionDimension(type, value)
+    }
 
-                override fun onFailure(throwable: Throwable) {
-                    callbackContext.error(throwable.message)
-                }
+    private fun closePresentation(callbackContext: CallbackContext) {
+        Purchasely.closeAllScreens()
+        displayedPresentation = null
+        callbackContext.success()
+    }
+
+    private fun backPresentation(callbackContext: CallbackContext) {
+        cordova.activity?.runOnUiThread { displayedPresentation?.back() }
+        callbackContext.success()
+    }
+    //endregion
+
+    private fun restoreAllProducts(callbackContext: CallbackContext) {
+        Purchasely.restoreAllProducts(
+            onSuccess = {
+                callbackContext.success()
+            },
+            onError = { plyError: PLYError? ->
+                callbackContext.error(plyError?.message)
             }
         )
     }
 
+    private fun userSubscriptions(callbackContext: CallbackContext) {
+        launch {
+            try {
+                val list = Purchasely.userSubscriptions(true)
+                callbackContext.success(transformSubscriptionsToJson(list))
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
+            }
+        }
+    }
+
     private fun userSubscriptionsHistory(callbackContext: CallbackContext) {
-        Purchasely.userSubscriptionsHistory(
-            false,
-            object : SubscriptionsListener {
-                override fun onSuccess(list: List<PLYSubscriptionData>) {
-                    val result = JSONArray()
-                    for (i in list.indices) {
-                        val data = list[i]
-                        val map = HashMap(data.toMap())
-                        map["plan"] = transformPlanToMap(data.plan)
-                        map["product"] = data.product.toMap()
-                        if (data.data.storeType == StoreType.GOOGLE_PLAY_STORE) {
-                            map["subscriptionSource"] = StoreType.GOOGLE_PLAY_STORE.ordinal
-                        } else if (data.data.storeType == StoreType.AMAZON_APP_STORE) {
-                            map["subscriptionSource"] = StoreType.AMAZON_APP_STORE.ordinal
-                        } else if (data.data.storeType == StoreType.HUAWEI_APP_GALLERY) {
-                            map["subscriptionSource"] = StoreType.HUAWEI_APP_GALLERY.ordinal
-                        } else if (data.data.storeType == StoreType.APPLE_APP_STORE) {
-                            map["subscriptionSource"] = StoreType.APPLE_APP_STORE.ordinal
-                        }
-                        result.put(JSONObject(map))
-                    }
-                    callbackContext.success(result)
-                }
+        launch {
+            try {
+                val list = Purchasely.userSubscriptionsHistory(true)
+                callbackContext.success(transformSubscriptionsToJson(list))
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
+            }
+        }
+    }
 
-                override fun onFailure(throwable: Throwable) {
-                    callbackContext.error(throwable.message)
-                }
+    private fun transformSubscriptionsToJson(list: List<PLYSubscriptionData>): JSONArray {
+        val result = JSONArray()
+        for (data in list) {
+            val map = HashMap(data.data.toMap())
+            map["plan"] = transformPlanToMap(data.plan)
+            map["product"] = data.product.toMap()
+            map["subscriptionSource"] = when (data.data.storeType) {
+                StoreType.GOOGLE_PLAY_STORE -> StoreType.GOOGLE_PLAY_STORE.ordinal
+                StoreType.AMAZON_APP_STORE -> StoreType.AMAZON_APP_STORE.ordinal
+                StoreType.HUAWEI_APP_GALLERY -> StoreType.HUAWEI_APP_GALLERY.ordinal
+                StoreType.APPLE_APP_STORE -> StoreType.APPLE_APP_STORE.ordinal
+                else -> null
             }
-        )
+            result.put(JSONObject(map))
+        }
+        return result
     }
 
-    private fun isDeeplinkHandled(deeplink: String?, callbackContext: CallbackContext) {
+    private fun handleDeeplink(deeplink: String?, callbackContext: CallbackContext) {
         if (deeplink == null) {
             callbackContext.error("Deeplink must not be null")
             return
@@ -668,25 +759,24 @@ class PurchaselyPlugin : CordovaPlugin() {
         callbackContext.sendPluginResult(
             PluginResult(
                 PluginResult.Status.OK,
-                Purchasely.isDeeplinkHandled(uri)
+                Purchasely.handleDeeplink(uri, cordova.activity)
             )
         )
     }
 
     private fun allProducts(callbackContext: CallbackContext) {
-        Purchasely.allProducts(object : ProductsListener {
-            override fun onSuccess(list: List<PLYProduct>) {
+        launch {
+            try {
+                val list = Purchasely.allProducts()
                 val result = JSONArray()
-                for (i in list.indices) {
-                    result.put(JSONObject(list[i].toMap()))
+                for (product in list) {
+                    result.put(JSONObject(product.toMap()))
                 }
                 callbackContext.success(result)
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
             }
-
-            override fun onFailure(throwable: Throwable) {
-                callbackContext.error(throwable.message)
-            }
-        })
+        }
     }
 
     private fun productWithIdentifier(vendorId: String?, callbackContext: CallbackContext) {
@@ -694,19 +784,18 @@ class PurchaselyPlugin : CordovaPlugin() {
             callbackContext.error("No product found with $vendorId")
             return
         }
-        Purchasely.product(vendorId, object : ProductListener {
-            override fun onSuccess(product: PLYProduct?) {
+        launch {
+            try {
+                val product: PLYProduct? = Purchasely.product(vendorId)
                 if (product != null) {
                     callbackContext.success(JSONObject(product.toMap()))
                 } else {
                     callbackContext.error("No product found with $vendorId")
                 }
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
             }
-
-            override fun onFailure(throwable: Throwable) {
-                callbackContext.error(throwable.message)
-            }
-        })
+        }
     }
 
     private fun planWithIdentifier(vendorId: String?, callbackContext: CallbackContext) {
@@ -714,19 +803,18 @@ class PurchaselyPlugin : CordovaPlugin() {
             callbackContext.error("No plan found with $vendorId")
             return
         }
-        Purchasely.plan(vendorId, object : PlanListener {
-            override fun onSuccess(plan: PLYPlan?) {
+        launch {
+            try {
+                val plan: PLYPlan? = Purchasely.plan(vendorId)
                 if (plan != null) {
                     callbackContext.success(JSONObject(transformPlanToMap(plan)))
                 } else {
                     callbackContext.error("No plan found with $vendorId")
                 }
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
             }
-
-            override fun onFailure(throwable: Throwable) {
-                callbackContext.error(throwable.message)
-            }
-        })
+        }
     }
 
     private fun purchaseWithPlanVendorId(
@@ -740,114 +828,129 @@ class PurchaselyPlugin : CordovaPlugin() {
             return
         }
 
-        Purchasely.plan(planVendorId, object : PlanListener {
-            override fun onSuccess(plyPlan: PLYPlan?) {
+        launch {
+            try {
+                val plyPlan: PLYPlan? = Purchasely.plan(planVendorId)
                 if (plyPlan != null) {
                     val offer = plyPlan.promoOffers.firstOrNull { it.vendorId == offerId }
                     Purchasely.purchase(cordova.activity, plyPlan, offer, contentId,
-                        { plyPlan1: PLYPlan? ->
+                        onSuccess = { plyPlan1: PLYPlan? ->
                             callbackContext.success(JSONObject(transformPlanToMap(plyPlan1)))
-                        }) { plyError: PLYError? ->
-                        callbackContext.error(plyError?.message)
-                    }
+                        },
+                        onError = { plyError: PLYError? ->
+                            callbackContext.error(plyError?.message)
+                        })
                 } else {
                     callbackContext.error("No plan found with $planVendorId")
                 }
+            } catch (e: Exception) {
+                callbackContext.error(e.message)
             }
+        }
+    }
 
-            override fun onFailure(throwable: Throwable) {
-                callbackContext.error(throwable.message)
+    //region Action interceptor
+    // v6: register a JS handler for a single action kind. Each intercept emits an
+    // event carrying a unique callbackId; JS replies via completeActionInterceptor.
+    private fun registerActionInterceptor(kind: String?, callbackContext: CallbackContext) {
+        if (kind == null) return
+        val clazz = PLYPresentationAction.fromValue(kind)?.java
+        if (clazz == null) {
+            Log.w("Purchasely", "Unknown interceptor kind: $kind")
+            return
+        }
+        actionInterceptorCallbacks[kind] = callbackContext
+        Purchasely.interceptAction(clazz, object : PLYActionInterceptorCallback {
+            override fun onIntercept(
+                info: PLYInterceptorInfo,
+                action: PLYPresentationAction,
+                completion: (PLYInterceptResult) -> Unit
+            ) {
+                val callback = actionInterceptorCallbacks[kind]
+                if (callback == null) {
+                    completion(PLYInterceptResult.NOT_HANDLED)
+                    return
+                }
+                // Unique id per intercepted invocation so concurrent intercepts resolve independently.
+                val invocationId = "$kind#${++interceptorInvocationCounter}"
+                pendingInterceptCompletions[invocationId] = completion
+
+                val map = hashMapOf<String, Any?>(
+                    "action" to kind,
+                    "callbackId" to invocationId,
+                    "info" to mapOf(
+                        // TODO(v6-verify): presentationId derived from info.presentation?.screenId;
+                        // v6 PLYInterceptorInfo exposes {contentId, presentation}, not a raw id.
+                        "contentId" to info.contentId,
+                        "presentationId" to info.presentation?.screenId
+                    ),
+                    "parameters" to (actionPayloadToMap(action) ?: emptyMap<String, Any?>())
+                )
+                val result = PluginResult(PluginResult.Status.OK, JSONObject(map))
+                result.keepCallback = true
+                callback.sendPluginResult(result)
             }
         })
     }
 
-    private fun setPaywallActionInterceptor(callbackContext: CallbackContext) {
-        Purchasely.setPaywallActionsInterceptor { info, action, parameters, processAction ->
-            paywallActionHandler = processAction
-            paywallAction = action
-
-            interceptorActivity = WeakReference(info?.activity)
+    // v6: stop intercepting a single action kind.
+    private fun unregisterActionInterceptor(kind: String?) {
+        if (kind == null) return
+        val clazz = PLYPresentationAction.fromValue(kind)?.java ?: return
+        actionInterceptorCallbacks.remove(kind)
+        runCatching { Purchasely.removeActionInterceptor(clazz) }.onFailure {
+            Log.w("Purchasely", "removeActionInterceptor($kind) failed: ${it.message}")
+        }
+    }
 
-            val parametersForCordova = hashMapOf<String, Any?>();
-            parametersForCordova["title"] = parameters.title
-            parametersForCordova["url"] = parameters.url?.toString()
-            parametersForCordova["plan"] = transformPlanToMap(parameters.plan)
-            parametersForCordova["offer"] = mapOf(
-                "vendorId" to parameters.offer?.vendorId,
-                "storeOfferId" to parameters.offer?.storeOfferId
+    private fun actionPayloadToMap(action: PLYPresentationAction): Map<String, Any?>? {
+        return when (action) {
+            is PLYPresentationAction.Navigate -> mapOf(
+                "url" to action.url?.toString(),
+                "title" to action.title
             )
-            parametersForCordova["subscriptionOffer"] = parameters.subscriptionOffer?.toMap()
-            parametersForCordova["presentation"] = parameters.presentation
-            parametersForCordova["placement"] = parameters.placement
-            parametersForCordova["closeReason"] = parameters.closeReason?.name
-            parametersForCordova["clientReferenceId"] = parameters?.clientReferenceId
-            parametersForCordova["queryParameterKey"] = parameters?.queryParameterKey
-            parametersForCordova["webCheckoutProvider"] = parameters?.webCheckoutProvider?.name
-
-            val result = PluginResult(
-                PluginResult.Status.OK,
-                JSONObject(
-                    hashMapOf<String, Any?>(
-                        Pair("info", mapOf(
-                            Pair("contentId", info?.contentId),
-                            Pair("presentationId", info?.presentationId),
-                            Pair("placementId", info?.placementId),
-                            Pair("abTestId", info?.abTestId),
-                            Pair("abTestVariantId", info?.abTestVariantId)
-                        )),
-                        Pair("action", action.value),
-                        Pair("parameters", parametersForCordova.filterNot { it.value == null })
+            is PLYPresentationAction.Purchase -> mapOf(
+                "plan" to transformPlanToMap(action.plan),
+                "subscriptionOffer" to action.subscriptionOffer?.toMap(),
+                "offer" to action.offer?.let { offer ->
+                    mapOf(
+                        "vendorId" to offer.vendorId,
+                        "storeOfferId" to offer.storeOfferId
                     )
-                )
+                }
             )
-            result.keepCallback = true
-            callbackContext.sendPluginResult(result)
-        }
-    }
-
-    private fun closePresentation(callbackContext: CallbackContext) {
-        val openedPaywall = productActivity?.activity?.get()
-        openedPaywall?.finish()
-        productActivity = null
-    }
-
-    private fun onProcessAction(processAction: Boolean) {
-        val activityHandler = interceptorActivity?.get() ?: productActivity?.activity?.get() ?: cordova.activity
-        activityHandler?.runOnUiThread {
-            paywallActionHandler?.invoke(processAction)
-
-            interceptorActivity?.clear()
-            interceptorActivity = null
+            is PLYPresentationAction.Close -> mapOf("closeReason" to action.closeReason.value)
+            is PLYPresentationAction.CloseAll -> mapOf("closeReason" to action.closeReason.value)
+            is PLYPresentationAction.OpenPresentation -> mapOf("presentationId" to action.presentationId)
+            is PLYPresentationAction.OpenPlacement -> mapOf("placementId" to action.placementId)
+            is PLYPresentationAction.WebCheckout -> mapOf(
+                "url" to action.url?.toString(),
+                "clientReferenceId" to action.clientReferenceId,
+                "queryParameterKey" to action.queryParameterKey,
+                "webCheckoutProvider" to action.webCheckoutProvider?.name
+            )
+            else -> null
         }
     }
 
-    private fun showPresentation() {
-        val currentActivity = interceptorActivity?.get()
-
-        if (currentActivity != null && !currentActivity.isFinishing && !currentActivity.isDestroyed) {
-            cordova.activity?.let {
-                it.startActivity(
-                    Intent(it, currentActivity::class.java).apply {
-                        //flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                        flags = Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
-                    }
-                )
-            }
+    // v6: JS reports how an intercepted action was handled, keyed by the invocation id
+    // carried on the intercept event. Result is "success"/"failed"/"notHandled".
+    private fun completeActionInterceptor(callbackId: String?, result: String?) {
+        if (callbackId == null) return
+        val completion = pendingInterceptCompletions.remove(callbackId) ?: return
+        val plyResult = when (result) {
+            "success" -> PLYInterceptResult.SUCCESS
+            "failed" -> PLYInterceptResult.FAILED
+            else -> PLYInterceptResult.NOT_HANDLED
         }
-        else {
-            productActivity?.relaunch(cordova)
+        val activity = cordova.activity
+        if (activity != null) {
+            activity.runOnUiThread { completion.invoke(plyResult) }
+        } else {
+            completion.invoke(plyResult)
         }
     }
-
-    private fun hidePresentation() {
-        val cordovaActivity = cordova.activity
-        val activity = productActivity?.activity?.get() ?: cordovaActivity
-        cordovaActivity?.startActivity(
-            Intent(activity, cordovaActivity::class.java).apply {
-                flags = Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
-            }
-        )
-    }
+    //endregion
 
     fun setUserAttributeWithStringArray(key: String?, value: JSONArray?, legalBasisString: String?) {
         if(key == null || value == null) return
@@ -1033,14 +1136,15 @@ class PurchaselyPlugin : CordovaPlugin() {
     }
 
     private fun isEligibleForIntroOffer(planId: String?, callbackContext: CallbackContext) {
-        Purchasely.plan(planId,
-            onSuccess = { plan ->
-                callbackContext.sendPluginResult(PluginResult(PluginResult.Status.OK, plan?.isEligibleToIntroOffer(null) ?: false))
-            },
-            onError = { error ->
-                callbackContext.error(error.message ?: "Unable to fetch plan")
+        launch {
+            try {
+                val plan = Purchasely.plan(planId ?: "")
+                val eligible = plan?.isEligibleToOffer(null) ?: false
+                callbackContext.sendPluginResult(PluginResult(PluginResult.Status.OK, eligible))
+            } catch (e: Exception) {
+                callbackContext.error(e.message ?: "Unable to fetch plan")
             }
-        )
+        }
     }
 
     private fun signPromotionalOffer(storeProductId: String?, storeOfferId: String?, callbackContext: CallbackContext) {
@@ -1074,103 +1178,88 @@ class PurchaselyPlugin : CordovaPlugin() {
         Purchasely.debugMode = enabled
     }
 
-    class ProductActivity {
-        var presentationId: String? = null
-        var placementId: String? = null
-        var productId: String? = null
-        var planId: String? = null
-        var contentId: String? = null
-        var presentation: PLYPresentation? = null
-        var isFullScreen = false
-        var loadingBackgroundColor: String? = null
-        var activity: WeakReference<PLYProductActivity>? = null
-        fun relaunch(cordova: CordovaInterface): Boolean {
-            var backgroundActivity: PLYProductActivity? = null
-            if (activity != null) {
-                backgroundActivity = activity?.get()
-            }
-            return if (backgroundActivity != null && !backgroundActivity.isFinishing
-                && !backgroundActivity.isDestroyed
-            ) {
-                val intent = Intent(cordova.activity, PLYProductActivity::class.java)
-                intent.putExtra("presentation", presentation)
-                intent.putExtra("presentationId", presentationId)
-                intent.putExtra("placementId", placementId)
-                intent.putExtra("productId", productId)
-                intent.putExtra("planId", planId)
-                intent.putExtra("contentId", contentId)
-                intent.putExtra("isFullScreen", isFullScreen)
-                intent.putExtra("background_color", loadingBackgroundColor)
-                intent.flags = Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
-                cordova.activity.startActivity(intent)
-                true
-            } else {
-                val intent = PLYProductActivity.newIntent(cordova.activity)
-                intent.putExtra("presentation", presentation)
-                intent.putExtra("presentationId", presentationId)
-                intent.putExtra("placementId", placementId)
-                intent.putExtra("productId", productId)
-                intent.putExtra("planId", planId)
-                intent.putExtra("contentId", contentId)
-                intent.putExtra("isFullScreen", isFullScreen)
-                intent.putExtra("background_color", loadingBackgroundColor)
-                cordova.activity.startActivity(intent)
-                false
-            }
-        }
-    }
-
     companion object {
         var defaultCallback: CallbackContext? = null
         var purchaseCallback: CallbackContext? = null
         var eventsCallback: CallbackContext? = null
         var attributesCallback: CallbackContext? = null
-        var productActivity: ProductActivity? = null
-
-        var interceptorActivity: WeakReference<Activity>? = null
 
-        val presentationsLoaded = mutableListOf<PLYPresentation>()
-
-        private const val runningModePaywallObserver = 2
-        private const val runningModeFull = 3
-
-        fun sendPurchaseResult(result: PLYProductViewResult, plan: PLYPlan?) {
-            var productViewResult = 0
-            if (result == PLYProductViewResult.PURCHASED) {
-                productViewResult = PLYProductViewResult.PURCHASED.ordinal
-            } else if (result == PLYProductViewResult.CANCELLED) {
-                productViewResult = PLYProductViewResult.CANCELLED.ordinal
-            } else if (result == PLYProductViewResult.RESTORED) {
-                productViewResult = PLYProductViewResult.RESTORED.ordinal
-            }
-            val map = HashMap<String?, Any?>()
-            map["result"] = productViewResult
-            map["plan"] = transformPlanToMap(plan)
-            if (purchaseCallback != null) {
-                purchaseCallback?.success(JSONObject(map))
+        // Resolves a present*/presentPresentation call at dismissal. One-shot for the
+        // purchase callback; falls back to the (repeatable) default dismiss handler.
+        fun sendPurchaseResult(outcome: PLYPresentationOutcome) {
+            val json = JSONObject(outcomeToMap(outcome))
+            val oneShot = purchaseCallback
+            if (oneShot != null) {
+                oneShot.success(json)
                 purchaseCallback = null
-            } else if (defaultCallback != null) {
-                val pluginResult = PluginResult(PluginResult.Status.OK, JSONObject(map))
+                return
+            }
+            defaultCallback?.let {
+                val pluginResult = PluginResult(PluginResult.Status.OK, json)
                 pluginResult.keepCallback = true
-                defaultCallback?.sendPluginResult(pluginResult)
+                it.sendPluginResult(pluginResult)
             }
         }
 
+        // Serializes a v6 PLYPresentationOutcome to the wire contract. `result` is kept as an
+        // int (PurchaseResult 0/1/2) for back-compat with the pre-6.0 JS layer.
+        fun outcomeToMap(outcome: PLYPresentationOutcome): Map<String?, Any?> {
+            val result = when (outcome.purchaseResult?.name?.lowercase(Locale.US)) {
+                "purchased" -> 0
+                "cancelled" -> 1
+                "restored" -> 2
+                else -> 1 // no purchase (plain dismiss) → cancelled
+            }
+            val map = HashMap<String?, Any?>()
+            map["result"] = result
+            // v6: also expose the string purchaseResult ('purchased'|'cancelled'|'restored'|null)
+            // alongside the legacy int `result`, matching the Flutter outcome contract.
+            map["purchaseResult"] = outcome.purchaseResult?.name?.lowercase(Locale.US)
+            map["plan"] = transformPlanToMap(outcome.plan)
+            map["closeReason"] = outcome.closeReason?.value
+            map["error"] = outcome.error?.message
+            map["presentation"] = outcome.presentation?.let { presentationToMap(it) }
+            return map
+        }
+
+        fun presentationToMap(p: PLYPresentationBase.Loaded): Map<String, Any?> {
+            return mapOf(
+                "screenId" to p.screenId,
+                "placementId" to p.placementId,
+                "contentId" to p.contentId,
+                "audienceId" to p.audienceId,
+                "abTestId" to p.abTestId,
+                "abTestVariantId" to p.abTestVariantId,
+                "campaignId" to p.campaignId,
+                "flowId" to p.flowId,
+                "language" to p.language,
+                "type" to p.type.ordinal,
+                "height" to p.height,
+                "plans" to p.plans.map { presentationPlanToMap(it) }
+            )
+        }
+
+        private fun presentationPlanToMap(plan: PLYPresentationPlan): Map<String, Any?> {
+            return mapOf(
+                "planVendorId" to plan.planVendorId,
+                "storeProductId" to plan.storeProductId,
+                "basePlanId" to plan.basePlanId,
+                "offerId" to plan.storeOfferId
+            )
+        }
+
         private fun transformPlanToMap(plan: PLYPlan?): Map<String?, Any?> {
             if (plan == null) return HashMap()
             val map = HashMap(plan.toMap())
-            if (plan.type == DistributionType.CONSUMABLE) {
-                map["type"] = DistributionType.CONSUMABLE.ordinal
-            } else if (plan.type == DistributionType.CONSUMABLE) {
-                map["type"] = DistributionType.NON_CONSUMABLE.ordinal
-            } else if (plan.type == DistributionType.NON_CONSUMABLE) {
-                map["type"] = DistributionType.RENEWING_SUBSCRIPTION.ordinal
-            } else if (plan.type == DistributionType.NON_RENEWING_SUBSCRIPTION) {
-                map["type"] = DistributionType.NON_RENEWING_SUBSCRIPTION.ordinal
-            } else if (plan.type == DistributionType.UNKNOWN) {
-                map["type"] = DistributionType.UNKNOWN.ordinal
+            map["type"] = when (plan.type) {
+                DistributionType.RENEWING_SUBSCRIPTION -> DistributionType.RENEWING_SUBSCRIPTION.ordinal
+                DistributionType.NON_RENEWING_SUBSCRIPTION -> DistributionType.NON_RENEWING_SUBSCRIPTION.ordinal
+                DistributionType.CONSUMABLE -> DistributionType.CONSUMABLE.ordinal
+                DistributionType.NON_CONSUMABLE -> DistributionType.NON_CONSUMABLE.ordinal
+                DistributionType.UNKNOWN -> DistributionType.UNKNOWN.ordinal
+                else -> null
             }
-            map["isEligibleForIntroOffer"] = plan.isEligibleToIntroOffer(null)
+            map["isEligibleForIntroOffer"] = plan.isEligibleToOffer(null)
             return map
         }
     }
@@ -1223,4 +1312,4 @@ class PurchaselyPlugin : CordovaPlugin() {
             BATCH_CUSTOM_USER_ID: 20,
          */
     }
-}
+}