---
title: "Instalar y configurar el SDK de Adapty para Kotlin Multiplatform"
description: "Instala y configura el SDK de Adapty para apps de Kotlin Multiplatform."
---

El SDK de Adapty incluye dos módulos principales para una integración fluida en tu app:

- **Core Adapty**: Este SDK esencial es necesario para que Adapty funcione correctamente en tu app.
- **AdaptyUI** (`io.adapty:adapty-kmp-ui`): Este módulo es necesario si usas el [Adapty Paywall Builder](adapty-paywall-builder) con la capa de renderizado de Compose Multiplatform (`view.present()`). Si tu proyecto no utiliza Compose Multiplatform, puedes usar [`createNativePaywallView`](kmp-present-paywalls#without-compose-multiplatform) y [`createNativeOnboardingView`](kmp-present-onboardings#without-compose-multiplatform) del módulo principal.

:::tip
¿Quieres ver un ejemplo real de cómo se integra el SDK de Adapty en una app móvil? Consulta nuestra [app de ejemplo](https://github.com/adaptyteam/AdaptySDK-KMP/tree/main/example), que muestra la configuración completa, incluyendo la visualización de paywalls, la realización de compras y otras funciones básicas.
:::

Para un recorrido completo de implementación, también puedes ver el vídeo:

<iframe width="560" height="315" src="https://www.youtube.com/embed/JfwJvwnloNw?si=HskPxRk4WGkF_u9s" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## Requisitos \{#requirements\}

El SDK de Adapty para Kotlin Multiplatform es compatible con Xcode 16.2 y versiones posteriores.

:::info
Adapty es compatible con Google Play Billing Library hasta la versión 8.x. Por defecto, Adapty funciona con Google Play Billing Library v.7.0.0, pero si quieres forzar una versión posterior, puedes [añadir la dependencia](https://developer.android.com/google/play/billing/integrate#dependency) manualmente.
:::

---
no_index: true
---
import Callout from '../../../components/Callout.astro';

<Callout type="info">
Instalar el SDK es el paso 5 de la configuración de Adapty. Para que las compras funcionen en tu app, también necesitas conectar tu app a los stores, y luego crear productos, un paywall y un placement en el Adapty Dashboard. La [guía de inicio rápido](quickstart) explica todos los pasos necesarios.
</Callout>

## Instalar el SDK de Adapty con Gradle \{#install-adapty-sdk-via-gradle\}

La instalación del SDK de Adapty con Gradle es necesaria tanto para apps de Android como de iOS.

Elige tu método de configuración de dependencias:
- Gradle estándar: añade las dependencias a tu `build.gradle` **a nivel de módulo**
- Si tu proyecto usa archivos `.gradle.kts`, añade las dependencias a tu `build.gradle.kts` **a nivel de módulo**
- Si usas catálogos de versiones, añade las dependencias a tu archivo `libs.versions.toml` y luego haz referencia a él en `build.gradle.kts`

<Tabs>
<TabItem value="module-level build.gradle" label="module-level build.gradle" default>

```kotlin showLineNumbers
kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation libs.adapty.kmp
            }
        }
    }
}
```

</TabItem>
<TabItem value="module-level build.gradle.kts" label="module-level build.gradle.kts" default>

```kotlin showLineNumbers
kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(libs.adapty.kmp)
            }
        }
    }
}
```

</TabItem>

<TabItem value="version-catalog" label="Versions library" default>

```toml showLineNumbers
// libs.versions.toml
[versions]
..
adapty-kmp    = "<the latest SDK version>"

[libraries]
..
adapty-kmp = { module = "io.adapty:adapty-kmp", version.ref = "adapty-kmp" }

// build.gradle.kts

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(libs.adapty.kmp)
            }
        }
    }
}

```

</TabItem>
</Tabs>

:::note
Si obtienes un error relacionado con Maven, asegúrate de tener `mavenCentral()` en tus scripts de Gradle.

<details>
   <summary>Instrucciones para añadirlo</summary>

Si tu proyecto no tiene `dependencyResolutionManagement` en tu `settings.gradle`, añade lo siguiente a tu `build.gradle` de nivel superior al final de repositories:

```groovy showLineNumbers title="top-level build.gradle"
allprojects {
    repositories {
        ...
        mavenCentral()
    }
}
```

De lo contrario, añade lo siguiente a tu `settings.gradle` en `repositories` de la sección `dependencyResolutionManagement`:

```groovy showLineNumbers title="settings.gradle"
dependencyResolutionManagement {
    ...
    repositories {
        ...
        google()
        mavenCentral()
    }
}
```

</details>
:::

## Activar el SDK de Adapty \{#activate-adapty-sdk\}

### Configuración básica \{#basic-setup\}

Añade la inicialización lo antes posible, normalmente en tu código Kotlin compartido para ambas plataformas.

:::note
El SDK de Adapty solo necesita activarse una vez en tu app.
:::

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
    .Builder("PUBLIC_SDK_KEY")
    .build()

Adapty.activate(configuration = config)
    .onSuccess {
        Log.d("Adapty", "SDK initialised")
    }
    .onError { error ->
        Log.e("Adapty", "Adapty init error: ${error.message}")
    }
```

:::important
Espera a que `activate` termine antes de llamar a cualquier otro método del SDK de Adapty. Consulta [Orden de llamadas en el SDK de Kotlin Multiplatform](kmp-sdk-call-order) para ver la secuencia completa.
:::

Para obtener tu **Public SDK Key**:

1. Ve al Adapty Dashboard y navega a [App settings → General](https://app.adapty.io/settings/general).
2. En la sección **Api keys**, copia la **Public SDK Key** (NO la Secret Key).
3. Reemplaza `"YOUR_PUBLIC_SDK_KEY"` en el código.

:::info
- Asegúrate de usar la Public SDK Key para inicializar Adapty; la Secret Key debe usarse únicamente para la [API del lado del servidor](getting-started-with-server-side-api).
- Las claves del SDK son únicas para cada app, así que si tienes varias apps asegúrate de elegir la correcta.
  :::

Ahora configura los paywalls en tu app:

- Si usas [Adapty Paywall Builder](adapty-paywall-builder), primero [activa el módulo AdaptyUI](#activate-adaptyui-module-of-adapty-sdk) a continuación, y luego sigue la [guía de inicio rápido del Paywall Builder](kmp-quickstart-paywalls).
- Si construyes tu propio UI de paywall, consulta la [guía de inicio rápido para paywalls personalizados](kmp-quickstart-manual).

## Activar el módulo AdaptyUI del SDK de Adapty \{#activate-adaptyui-module-of-adapty-sdk\}

Si planeas activar el módulo **AdaptyUI** para usar el [Adapty Paywall Builder](kmp-present-paywalls), asegúrate de establecer `.withActivateUI(true)` en tu configuración.

:::info
importante
En tu código, debes activar el módulo principal de Adapty antes de activar AdaptyUI.
:::

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
    .Builder("PUBLIC_SDK_KEY")
    .withActivateUI(true)           // true for activating the AdaptyUI module
    .build()  

Adapty.activate(configuration = config)
    .onSuccess {
        Log.d("Adapty", "SDK initialised")
    }
    .onError { error ->
        Log.e("Adapty", "Adapty init error: ${error.message}")
    }    
```

## Configurar Proguard (Android) \{#configure-proguard-android\}

Antes de lanzar tu app en producción, es posible que necesites añadir `-keep class com.adapty.** { *; }` a tu configuración de Proguard.

## Configuración opcional \{#optional-setup\}

### Registro de eventos \{#logging\}

#### Configurar el sistema de registro \{#set-up-the-logging-system\}

Adapty registra errores y otra información importante para ayudarte a entender qué está ocurriendo. Los niveles disponibles son los siguientes:

| Nivel                    | Descripción                                                                                                                          |
| :----------------------- | :----------------------------------------------------------------------------------------------------------------------------------- |
| `AdaptyLogLevel.NONE`    | No se registrará nada. Valor por defecto                                                                                             |
| `AdaptyLogLevel.ERROR`   | Solo se registrarán los errores                                                                                                      |
| `AdaptyLogLevel.WARN`    | Se registrarán los errores y los mensajes del SDK que no causan errores críticos pero que vale la pena tener en cuenta.              |
| `AdaptyLogLevel.INFO`    | Se registrarán errores, advertencias y varios mensajes informativos.                                                                 |
| `AdaptyLogLevel.VERBOSE` | Se registrará cualquier información adicional que pueda ser útil durante la depuración, como llamadas a funciones, consultas a la API, etc. |

Puedes establecer el nivel de registro en tu app antes de configurar Adapty:

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
     .Builder("PUBLIC_SDK_KEY")
     .withLogLevel(AdaptyLogLevel.VERBOSE) // recommended for development
     .build()   
```

### Políticas de datos \{#data-policies\}

#### Desactivar la recopilación y el uso compartido de direcciones IP \{#disable-ip-address-collection-and-sharing\}

Al activar el módulo Adapty, establece `ipAddressCollectionDisabled` en `true` para desactivar la recopilación y el uso compartido de la dirección IP del usuario. El valor por defecto es `false`.

Usa este parámetro para mejorar la privacidad del usuario, cumplir con las normativas de protección de datos regionales (como el RGPD o la CCPA), o reducir la recopilación innecesaria de datos cuando las funciones basadas en IP no son necesarias para tu app.

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
     .Builder("PUBLIC_SDK_KEY")
     .withIpAddressCollectionDisabled(true)  
     .build()  
```
#### Desactivar la recopilación y el uso compartido del ID publicitario \{#disable-advertising-id-collection-and-sharing\}

Al activar el módulo Adapty, establece `appleIdfaCollectionDisabled` (iOS) o `googleAdvertisingIdCollectionDisabled` (Android) en `true` para desactivar la recopilación de identificadores publicitarios. El valor por defecto es `false`.

Usa este parámetro para cumplir con las políticas de la App Store/Play Store, evitar que se active el aviso de App Tracking Transparency, o si tu app no requiere atribución publicitaria o análisis basado en IDs publicitarios.

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
     .Builder("PUBLIC_SDK_KEY")
     .withGoogleAdvertisingIdCollectionDisabled(true)        // Android only
     .withAppleIdfaCollectionDisabled(true)                  // iOS only
     .build()  
```

#### Configurar la caché de medios para AdaptyUI \{#set-up-media-cache-configuration-for-adaptyui\}

Por defecto, AdaptyUI almacena en caché los medios (como imágenes y vídeos) para mejorar el rendimiento y reducir el uso de red. Puedes personalizar la configuración de la caché proporcionando una configuración personalizada.

Usa `mediaCache` para sobrescribir la configuración de caché por defecto:

```kotlin

val config = AdaptyConfig
    .Builder("PUBLIC_SDK_KEY")
    .withMediaCacheConfiguration(
        AdaptyConfig.MediaCacheConfiguration(
            memoryStorageTotalCostLimit = 200 * 1024 * 1024, // 200 MB
            memoryStorageCountLimit = Int.MAX_VALUE,          
            diskStorageSizeLimit = 200 * 1024 * 1024 // 200 MB
        )
    )
    .build()
```

### Habilitar niveles de acceso locales (Android) \{#enable-local-access-levels-android\}

Por defecto, los [niveles de acceso locales](local-access-levels) están desactivados para Android. Para habilitarlos, establece `withLocalAccessLevelAllowed` en `true`:

```kotlin title="Kotlin" showLineNumbers

val config = AdaptyConfig
    .Builder("PUBLIC_SDK_KEY")
    .withGoogleLocalAccessLevelAllowed(true)
    .build()
```

### Limpiar datos al restaurar desde copia de seguridad \{#clear-data-on-backup-restore\}

Cuando `withAppleClearDataOnBackup` se establece en `true`, el SDK detecta cuándo la app se restaura desde una copia de seguridad de iCloud y elimina todos los datos del SDK almacenados localmente, incluida la información del perfil en caché, los detalles de los productos y los paywalls. Luego, el SDK se inicializa con un estado limpio. El valor por defecto es `false`.

:::note
Solo se elimina la caché local del SDK. El historial de transacciones con Apple y los datos de usuario en los servidores de Adapty permanecen sin cambios.
:::

```swift showLineNumbers

val config = AdaptyConfig
    .Builder("PUBLIC_SDK_KEY")
    .withAppleClearDataOnBackup(true)
    .build()
```

## Solución de problemas \{#troubleshooting\}

#### Reglas de copia de seguridad de Android (configuración de Auto Backup) \{#android-backup-rules-auto-backup-configuration\}

Algunos SDKs (incluido Adapty) incluyen su propia configuración de Android Auto Backup. Si utilizas varios SDKs que definen reglas de copia de seguridad, el fusionador de manifiestos de Android puede fallar con un error relacionado con `android:fullBackupContent`, `android:dataExtractionRules` o `android:allowBackup`.

Síntomas típicos del error: `Manifest merger failed: Attribute application@dataExtractionRules value=(@xml/your_data_extraction_rules)
is also present at [com.other.sdk:library:1.0.0] value=(@xml/other_sdk_data_extraction_rules)`

:::note
Estos cambios deben realizarse en el directorio de la plataforma Android (normalmente en la carpeta `android/` de tu proyecto).
:::

Para resolverlo, necesitas:

- Indicar al fusionador de manifiestos que use los valores de tu app para los atributos relacionados con la copia de seguridad.

- Crear archivos de reglas de copia de seguridad que combinen las reglas de Adapty con las de otros SDKs.

#### 1. Añade el namespace `tools` a tu manifiesto \{#1-add-the-tools-namespace-to-your-manifest\}

En tu archivo `AndroidManifest.xml`, asegúrate de que la etiqueta raíz `<manifest>` incluya tools:

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
package="com.example.app">

    ...
</manifest>
```

#### 2. Sobreescribe los atributos de copia de seguridad en `<application>` \{#2-override-backup-attributes-in-application\}

En el mismo archivo `AndroidManifest.xml`, actualiza la etiqueta `<application>` para que tu app proporcione los valores definitivos e indique al fusionador de manifiestos que reemplace los valores de las librerías:

```xml
<application
android:name=".App"
android:allowBackup="true"
android:fullBackupContent="@xml/sample_backup_rules"           
android:dataExtractionRules="@xml/sample_data_extraction_rules"
tools:replace="android:fullBackupContent,android:dataExtractionRules">

    ...
</application>
```

Si algún SDK también define `android:allowBackup`, inclúyelo en `tools:replace`:

```xml
tools:replace="android:allowBackup,android:fullBackupContent,android:dataExtractionRules"
```

#### 3. Crea los archivos de reglas de copia de seguridad combinadas \{#3-create-merged-backup-rules-files\}

Crea archivos XML en el directorio `res/xml/` de tu proyecto Android que combinen las reglas de Adapty con las de otros SDKs. Android utiliza distintos formatos de reglas de copia de seguridad según la versión del sistema operativo, por lo que crear ambos archivos garantiza la compatibilidad con todas las versiones de Android que admite tu app.

:::note
Los ejemplos a continuación usan AppsFlyer como SDK de terceros de muestra. Reemplaza o añade reglas para cualquier otro SDK que uses en tu app.
:::

**Para Android 12 y superior** (usa el nuevo formato de reglas de extracción de datos):

```xml title="sample_data_extraction_rules.xml"
<?xml version="1.0" encoding="utf-8"?>
<data-extraction-rules>
    <cloud-backup>
        
        <exclude domain="sharedpref" path="appsflyer-data"/>
        <exclude domain="sharedpref" path="appsflyer-purchase-data"/>
        <exclude domain="database" path="afpurchases.db"/>
        
        <exclude domain="sharedpref" path="AdaptySDKPrefs.xml"/>
    </cloud-backup>

    <device-transfer>
        
        <exclude domain="sharedpref" path="appsflyer-data"/>
        <exclude domain="sharedpref" path="appsflyer-purchase-data"/>
        <exclude domain="database" path="afpurchases.db"/>
        <exclude domain="sharedpref" path="AdaptySDKPrefs.xml"/>
    </device-transfer>
</data-extraction-rules>
```

**Para Android 11 e inferior** (usa el formato legado de contenido de copia de seguridad completa):

```xml title="sample_backup_rules.xml"
<?xml version="1.0" encoding="utf-8"?>
<full-backup-content>
    
    <exclude domain="sharedpref" path="appsflyer-data"/>

    
    <exclude domain="sharedpref" path="AdaptySDKPrefs.xml"/>

:::important
En un proyecto de Kotlin Multiplatform, aplica estos cambios en el módulo de aplicación de Android (el que genera el APK/AAB), por ejemplo, `androidApp` o `app`:
- Manifest: `androidApp/src/main/AndroidManifest.xml`
- Backup rules XML: `androidApp/src/main/res/xml/`
:::

#### Las compras fallan al volver desde otra app en Android \{#purchases-fail-after-returning-from-another-app-in-android\}

Si el Activity que inicia el flujo de compra usa un `launchMode` no predeterminado, Android puede recrearlo o reutilizarlo incorrectamente cuando el usuario vuelve desde Google Play, una app bancaria o un navegador. Esto puede provocar que el resultado de la compra se pierda o se trate como cancelado.

Para asegurarte de que las compras funcionan correctamente, usa solo los modos de lanzamiento `standard` o `singleTop` para el Activity que inicia el flujo de compra, y evita cualquier otro modo.

En tu `AndroidManifest.xml`, asegúrate de que el Activity que inicia el flujo de compra está configurado como `standard` o `singleTop`:

```xml
<activity
    android:name=".MainActivity"
    android:launchMode="standard" />
```