# App Open

Los anuncios de carga de aplicación (App Open) son un formato especial cuyo propósito es permitir la monetización de las pantalla de carga de las aplicaciones.

Estos anuncios se pueden cerrar en cualquier momento y están pensados para ser mostrados cuando la aplicación realiza una transición a primer plano.

## **Integración**

Este formato de anuncio solo se puede integrar a través de código, implementando cualquiera de las dos integraciones posibles que se describen a continuación.

### **Manual**

En este tipo de integración, es necesario crear una instancia de la clase `AppOpenAd` y utilizar los métodos `loadAd()` y `showAd()` para realizar la carga y mostrado del anuncio bajo demanda. El publisher es el responsable de decidir cuándo se debe mostrar el anuncio e implementar la lógica necesaria.

A continuación, se muestra un ejemplo sencillo de integración:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
class MainActivity : Activity() {

    private var appOpenAd: AppOpenAd? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        appOpenAd = AppOpenAd(this, "Ad Unit ID de Wortise").also {
	    it.loadAd()
        }
    }
    
    override fun onDestroy() {
        ...
        appOpenAd?.destroy()
    }
    
    fun showAppOpen() {
        if (appOpenAd?.isAvailable == true) {
            appOpenAd?.showAd(this)
        }
    }
}
```

{% endtab %}

{% tab title="Java" %}

```java
public class MainActivity extends Activity {

    private AppOpenAd mAppOpenAd;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        ...
        mAppOpenAd = new AppOpenAd(this, "Ad Unit ID de Wortise");
        mAppOpenAd.loadAd();
    }
    
    @Override
    public void onDestroy() {
        ...
        mAppOpenAd.destroy(this);
    }
    
    public void showAppOpen() {
        if (mAppOpenAd.isAvailable()) {
            mAppOpenAd.showAd(this);
        }
    }
}
```

{% endtab %}
{% endtabs %}

Además, la clase `AppOpenAd` ofrece los siguientes métodos adicionales para configurar su comportamiento:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
// Establece si se debe cargar un nuevo anuncio tras cerrar el anterior
appOpenAd.autoReload = true

// Muestra un anuncio inmediatamente si está disponible. En caso contrario,
// solicita la carga de un nuevo anuncio
appOpenAd.tryToShowAd(activity)
```

{% endtab %}

{% tab title="Java" %}

```java
// Establece si se debe cargar un nuevo anuncio tras cerrar el anterior
mAppOpenAd.setAutoReload(true);

// Muestra un anuncio inmediatamente si está disponible. En caso contrario,
// solicita la carga de un nuevo anuncio
mAppOpenAd.tryToShowAd(activity);
```

{% endtab %}
{% endtabs %}

### **Vía Manager**

El SDK ofrece una implementación estándar de App Open para facilitar la integración de este formato de anuncios.

Para realizar este tipo de integración, es necesario que la aplicación extienda la clase `Application` y, dentro de ella, crear una instancia de `AppOpenManager`, tal y como se muestra en el siguiente ejemplo:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
class MyApplication : Application() {

    private val appOpenManager by lazy {
        AppOpenManager(this, "Ad Unit ID de Wortise")
    }

    override fun onCreate() {
        ...
        appOpenManager.loadAd()
    }
}
```

{% endtab %}

{% tab title="Java" %}

```java
public class MyApplication extends Application {

    private AppOpenManager mAppOpenManager;

    @Override
    public void onCreate() {
        ...
        mAppOpenManager = new AppOpenManager(this, "Ad Unit ID de Wortise");
        mAppOpenManager.loadAd();
    }
}
```

{% endtab %}
{% endtabs %}

Con esta simple integración, la aplicación mostrará anuncios cada vez que se realice una transición de segundo a primer plano.

Igualmente, la clase `AppOpenManager` ofrece los mismos métodos que `AppOpenAd` para configurar su comportamiento y mostrar los anuncios bajo demanda.

## **Configuración del listener**

Como en el resto de formatos, se puede añadir un listener para recibir los diferentes eventos\
que sucedan durante el ciclo de vida del anuncio. Para ello, es necesario implementar la interfaz `AppOpenAd.Listener` como se muestra en el siguiente ejemplo:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
appOpenAd.listener = object : AppOpenAd.Listener() {

    override fun onAppOpenClicked(ad: AppOpenAd) {
        // Invocado cuando el anuncio ha sido clickeado
    }
    
    override fun onAppOpenDismissed(ad: AppOpenAd) {
        // Invocado cuando el anuncio ha sido cerrado
    }
    
    override fun onAppOpenFailedToLoad(ad: AppOpenAd, error: AdError) {
        // Invocado cuando el anuncio no se ha podido cargar
        // (por error o falta de inventario)
    }
    
    override fun onAppOpenFailedToShow(ad: AppOpenAd, error: AdError) {
        // Invocado cuando el anuncio no se ha podido mostrar
    }
    
    override fun onAppOpenImpression(ad: AppOpenAd) {
        // Invocado cuando el anuncio ha generado una impresión
    }

    override fun onAppOpenLoaded(ad: AppOpenAd) {
        // Invocado cuando el anuncio ha sido cargado
    }
    
    override fun onAppOpenRevenuePaid(ad: AppOpenAd,
                                      data: RevenueData) {
        // Invocado cuando el anuncio ha generado un ingreso
    }
    
    override fun onAppOpenShown(ad: AppOpenAd) {
        // Invocado cuando el anuncio ha sido mostrado
    }
}
```

{% endtab %}

{% tab title="Java" %}

```java
mAppOpenAd.setListener(new AppOpenAd.Listener() {
    @Override
    public void onAppOpenClicked(@NonNull AppOpenAd ad) {
        // Invocado cuando el anuncio ha sido clickeado
    }
    
    @Override
    public void onAppOpenDismissed(@NonNull AppOpenAd ad) {
        // Invocado cuando el anuncio ha sido cerrado
    }
    
    @Override
    public void onAppOpenFailedToLoad(@NonNull AppOpenAd ad,
                                      @NonNull AdError error) {
        // Invocado cuando el anuncio no se ha podido cargar
        // (por error o falta de inventario)
    }
    
    @Override
    public void onAppOpenFailedToShow(@NonNull AppOpenAd ad,
                                      @NonNull AdError error) {
        // Invocado cuando el anuncio no se ha podido mostrar
    }
    
    @Override
    public void onAppOpenImpression(@NonNull AppOpenAd ad) {
        // Invocado cuando el anuncio ha generado una impresión
    }
    
    @Override
    public void onAppOpenLoaded(@NonNull AppOpenAd ad) {
        // Invocado cuando el anuncio ha sido cargado
    }
    
    @Override
    public void onAppOpenRevenuePaid(@NonNull AppOpenAd ad,
                                     @NonNull Revenuedata data) {
        // Invocado cuando el anuncio ha generado un ingreso
    }
    
    @Override
    public void onAppOpenShown(@NonNull AppOpenAd ad) {
        // Invocado cuando el anuncio ha sido mostrado
    }
});
```

{% endtab %}
{% endtabs %}