Responder a acciones de flow - Kotlin Multiplatform

Si estás construyendo flows o paywalls con el Flow Builder o el Paywall Builder de Adapty, es fundamental configurar los botones correctamente:

Añade un botón en el builder y asígnale una acción existente o crea un ID de acción personalizado.
Escribe código en tu app para gestionar cada acción que hayas asignado.

Esta guía muestra cómo gestionar acciones personalizadas y existentes en tu código.

Solo las compras, restauraciones, cierres de flow/paywall y apertura de enlaces se gestionan automáticamente. El resto de acciones de botón, como las acciones personalizadas, requieren una implementación adecuada en el código de la app.

Configurar el AdaptyUIFlowsEventsObserver

Para gestionar las acciones del flow, necesitas implementar la interfaz AdaptyUIFlowsEventsObserver y configurarla con AdaptyUI.setFlowsEventsObserver(). Esto debe hacerse al inicio del ciclo de vida de tu app, normalmente en tu actividad principal o en la inicialización de la app.


// In your app initialization
AdaptyUI.setFlowsEventsObserver(MyAdaptyUIFlowsEventsObserver())

Todas las acciones de los botones llegan al callback flowViewDidPerformAction(view, action) como una clase sellada AdaptyUIAction: CloseAction, AndroidSystemBackAction, OpenUrlAction o CustomAction.

Sobrescribir flowViewDidPerformAction reemplaza el comportamiento predeterminado de todas las acciones, no solo la que te interesa. Mantén las ramas por defecto para CloseAction (cerrar el flow) y OpenUrlAction (abrir la URL) a menos que quieras cambiarlas, como se muestra en los ejemplos a continuación.

Cerrar flows y paywalls

Para añadir un botón que cierre tu flow o paywall:

En el builder, añade un botón y asígnale la acción Close.
En el código de tu app, implementa un handler para la acción close que cierre el flow.

En el SDK de Kotlin Multiplatform, CloseAction activa el cierre del flow o paywall por defecto. Sin embargo, puedes sobrescribir este comportamiento en tu código si lo necesitas. Por ejemplo, cerrar un flow podría desencadenar la apertura de otro.


class MyAdaptyUIFlowsEventsObserver : AdaptyUIFlowsEventsObserver {
    override fun flowViewDidPerformAction(view: AdaptyUIFlowView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CloseAction ->
                mainUiScope.launch { view.dismiss() } // default behavior
            is AdaptyUIAction.OpenUrlAction ->
                AdaptyUI.openWebUrl(action.url, action.openIn) // default behavior
            else -> Unit
        }
    }
}

// Set up the observer
AdaptyUI.setFlowsEventsObserver(MyAdaptyUIFlowsEventsObserver())

Si usas createNativeFlowView, llamar a view.dismiss() no tiene ningún efecto, ya que la vista está integrada en tu layout y no se presenta a través del stack de KMP. En su lugar, elimina la vista de tu layout y llama a dispose() sobre ella.

Gestiona el botón Atrás del sistema Android

Al pulsar el botón Atrás del sistema Android (o usar el gesto de retroceso) se emite AdaptyUIAction.AndroidSystemBackAction. Por defecto, esta acción se ignora: el flow permanece abierto y el usuario lo abandona por el camino que tú definas, como un botón Close o una acción on_device_back en el builder. Si quieres que el botón Atrás del sistema cierre el flow, gestiona la acción tú mismo:

class MyAdaptyUIFlowsEventsObserver : AdaptyUIFlowsEventsObserver {
    override fun flowViewDidPerformAction(view: AdaptyUIFlowView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CloseAction ->
                mainUiScope.launch { view.dismiss() } // default behavior
            is AdaptyUIAction.AndroidSystemBackAction ->
                mainUiScope.launch { view.dismiss() } // not handled by default
            is AdaptyUIAction.OpenUrlAction ->
                AdaptyUI.openWebUrl(action.url, action.openIn) // default behavior
            else -> Unit
        }
    }
}

Abrir URLs desde flows y paywalls

Si quieres añadir un grupo de enlaces (por ejemplo, términos de uso y restauración de compras), añade un elemento Link en el builder y trátalo igual que los botones con la acción Open URL.

Para añadir un botón que abra un enlace desde tu flow o paywall (por ejemplo, Terms of use o Privacy policy), en el builder añade un botón, asígnale la acción Open URL e introduce la URL que quieres abrir.

De forma predeterminada, el SDK abre la URL recibida de forma nativa — en un navegador externo o dentro de la app, según action.openIn — por lo que no se necesita ningún código. Sobrescribe el handler solo si quieres una lógica personalizada, como mostrar primero un diálogo de confirmación:


class MyAdaptyUIFlowsEventsObserver(
    private val uriHandler: UriHandler
) : AdaptyUIFlowsEventsObserver {
    override fun flowViewDidPerformAction(view: AdaptyUIFlowView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.OpenUrlAction -> {
                // Show confirmation dialog before opening URL
                mainUiScope.launch {
                    val selectedAction = view.showDialog(
                        title = "Open URL?",
                        content = action.url,
                        primaryActionTitle = "Cancel",
                        secondaryActionTitle = "Open"
                    ).getOrNull()

                    when (selectedAction) {
                        AdaptyUIDialogActionType.PRIMARY -> {
                            // User cancelled
                        }
                        AdaptyUIDialogActionType.SECONDARY -> {
                            // User confirmed - open URL
                            uriHandler.openUri(action.url)
                        }
                        else -> Unit
                    }
                }
            }
            else -> Unit
        }
    }
}

// Set up the observer with UriHandler
AdaptyUI.setFlowsEventsObserver(MyAdaptyUIFlowsEventsObserver(uriHandler))

Iniciar sesión en la app

Para añadir un botón que permita a los usuarios iniciar sesión en tu app:

En el builder, añade un botón y asígnale una acción Custom con el ID “login”.
En el código de tu app, implementa un manejador para la acción personalizada que identifique a tu usuario.


class MyAdaptyUIFlowsEventsObserver : AdaptyUIFlowsEventsObserver {
    override fun flowViewDidPerformAction(view: AdaptyUIFlowView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CustomAction -> {
                if (action.action == "login") {
                    // Handle login action - navigate to login screen
                    // This depends on your app's navigation system
                    // For example, in Compose Multiplatform:
                    // navController.navigate("login")
                }
            }
            else -> Unit
        }
    }
}

Manejar acciones personalizadas

Para añadir un botón que gestione cualquier otra acción:

En el builder, añade un botón, asígnale la acción Custom y asígnale un ID.
En el código de tu app, implementa un manejador para el ID de acción que hayas creado.

Por ejemplo, si tienes otro conjunto de ofertas de suscripción o compras únicas, puedes añadir un botón que muestre otro flow o paywall:


class MyAdaptyUIFlowsEventsObserver : AdaptyUIFlowsEventsObserver {
    override fun flowViewDidPerformAction(view: AdaptyUIFlowView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CustomAction -> {
                when (action.action) {
                    "openNewFlow" -> {
                        // Display another flow or paywall
                    }
                }
            }
            else -> Unit
        }
    }
}

// Set up the observer
AdaptyUI.setFlowsEventsObserver(MyAdaptyUIFlowsEventsObserver())

Solo las compras y restauraciones se gestionan automáticamente. Todas las demás acciones de los botones, como cerrar paywalls o abrir enlaces, requieren implementar las respuestas correspondientes en el código de la app.

Si estás construyendo paywalls con el Paywall Builder de Adapty, es fundamental configurar los botones correctamente:

Añade un botón en el Paywall Builder y asígnale una acción predefinida o crea un ID de acción personalizado.
Escribe código en tu app para gestionar cada acción que hayas asignado.

Esta guía muestra cómo gestionar acciones personalizadas y preexistentes en tu código.

Configura el AdaptyUIPaywallsEventsObserver

Para gestionar las acciones del paywall, necesitas implementar la interfaz AdaptyUIPaywallsEventsObserver y configurarla con AdaptyUI.setPaywallsEventsObserver(). Esto debe hacerse en una etapa temprana del ciclo de vida de tu app, normalmente en tu actividad principal o en la inicialización de la app.


// In your app initialization
AdaptyUI.setPaywallsEventsObserver(MyAdaptyUIPaywallsEventsObserver())

Cerrar paywalls

Para añadir un botón que cierre tu paywall:

En el Paywall Builder, añade un botón y asígnale la acción Close.
En el código de tu app, implementa un manejador para la acción close que descarte el paywall.

En el SDK de Kotlin Multiplatform, CloseAction y AndroidSystemBackAction activan el cierre del paywall por defecto. Sin embargo, puedes sobreescribir este comportamiento en tu código si lo necesitas. Por ejemplo, cerrar un paywall podría desencadenar la apertura de otro.


class MyAdaptyUIPaywallsEventsObserver : AdaptyUIPaywallsEventsObserver {
    override fun paywallViewDidPerformAction(view: AdaptyUIPaywallView, action: AdaptyUIAction) {
        when (action) {
            AdaptyUIAction.CloseAction, AdaptyUIAction.AndroidSystemBackAction -> view.dismiss()
        }
    }
}

// Set up the observer
AdaptyUI.setPaywallsEventsObserver(MyAdaptyUIPaywallsEventsObserver())

Si usas createNativePaywallView, llamar a view.dismiss() no tendrá ningún efecto: la vista está integrada en tu layout, no se presenta a través del stack de KMP. En su lugar, elimina la vista de tu layout y llama a dispose() sobre ella.

Abrir URLs desde paywalls

Si quieres añadir un grupo de enlaces (por ejemplo, términos de uso y restauración de compras), añade un elemento Link en el paywall builder y trátalo de la misma manera que los botones con la acción Open URL.

Para añadir un botón que abra un enlace desde tu paywall (por ejemplo, Terms of use o Privacy policy):

En el paywall builder, añade un botón, asígnale la acción Open URL e introduce la URL que quieres abrir.
En el código de tu app, implementa un manejador para la acción openUrl que abra la URL recibida en un navegador.

En el SDK de Kotlin Multiplatform, OpenUrlAction proporciona la URL que debe abrirse. Puedes implementar lógica personalizada para gestionar la apertura de URLs, como mostrar un diálogo de confirmación o usar el método de manejo de URLs preferido de tu app.


class MyAdaptyUIPaywallsEventsObserver(
    private val uriHandler: UriHandler
) : AdaptyUIPaywallsEventsObserver {
    override fun paywallViewDidPerformAction(view: AdaptyUIPaywallView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.OpenUrlAction -> {
                // Show confirmation dialog before opening URL
                mainUiScope.launch {
                    val selectedAction = view.showDialog(
                        title = "Open URL?",
                        content = action.url,
                        primaryActionTitle = "Cancel",
                        secondaryActionTitle = "Open"
                    ).getOrNull()

                    when (selectedAction) {
                        AdaptyUIDialogActionType.PRIMARY -> {
                            // User cancelled
                        }
                        AdaptyUIDialogActionType.SECONDARY -> {
                            // User confirmed - open URL
                            uriHandler.openUri(action.url)
                        }
                        else -> Unit
                    }
                }
            }
        }
    }
}

// Set up the observer with UriHandler
AdaptyUI.setPaywallsEventsObserver(MyAdaptyUIPaywallsEventsObserver(uriHandler))

Inicia sesión en la aplicación

Para añadir un botón que permita a los usuarios iniciar sesión en tu aplicación:

En el Paywall Builder, añade un botón y asígnale una acción Custom con el ID “login”.
En el código de tu aplicación, implementa un manejador para la acción personalizada que identifique a tu usuario.


class MyAdaptyUIObserver : AdaptyUIObserver {
    override fun paywallViewDidPerformAction(view: AdaptyUIView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CustomAction -> {
                if (action.action == "login") {
                    // Handle login action - navigate to login screen
                    // This depends on your app's navigation system
                    // For example, in Compose Multiplatform:
                    // navController.navigate("login")
                }
            }
        }
    }
}

Gestionar acciones personalizadas

Para añadir un botón que gestione cualquier otra acción:

En el Paywall Builder, añade un botón, asígnale la acción Custom y asígnale un ID.
En el código de tu app, implementa un manejador para el ID de acción que has creado.

Por ejemplo, si tienes otro conjunto de ofertas de suscripción o compras únicas, puedes añadir un botón que muestre otro paywall:


class MyAdaptyUIPaywallsEventsObserver : AdaptyUIPaywallsEventsObserver {
    override fun paywallViewDidPerformAction(view: AdaptyUIPaywallView, action: AdaptyUIAction) {
        when (action) {
            is AdaptyUIAction.CustomAction -> {
                when (action.action) {
                    "login" -> {
                        // Handle login action - navigate to login screen
                        // This depends on your app's navigation system
                        // For example, in Compose Multiplatform:
                        // navController.navigate("login")
                    }
                }
            }
        }
    }
}

// Set up the observer
AdaptyUI.setPaywallsEventsObserver(MyAdaptyUIPaywallsEventsObserver())