Anuncios nativos

Los anuncios nativos son recursos de anuncios que se presentan a los usuarios a través de componentes de la IU nativos de la plataforma. Se muestran con los mismos tipos de vistas que ya utilizas para crear tus diseños y se pueden adaptar al diseño visual de la app.

Cuando se carga un anuncio nativo, tu app recibe un objeto de anuncio que contiene sus recursos, y la app, en lugar del SDK de anuncios de Google para dispositivos móviles, es responsable de mostrarlos.

En términos generales, hay dos partes para implementar correctamente los anuncios nativos: cargar un anuncio con el SDK y, luego, mostrar el contenido del anuncio en tu app.

En esta página, se muestra cómo usar el SDK para cargar anuncios nativos.

Requisitos previos

• Completa la guía de introducción.

Siempre realiza pruebas con anuncios de prueba

Cuando compiles y pruebes tus apps, asegúrate de usar anuncios de prueba en lugar de anuncios activos en fase de producción.

La forma más sencilla de cargar anuncios de prueba es usar nuestro ID de unidad de anuncios de prueba exclusivo para anuncios nativos en Android:

/21775744923/example/native

Se configuró de forma especial para mostrar anuncios de prueba para cada solicitud, y puedes usarlo en tus propias apps mientras codificas, pruebas y depuras. Solo asegúrate de reemplazarlo por tu propio ID de unidad de anuncios antes de publicar la app.

Para obtener más información sobre cómo funcionan los anuncios de prueba del SDK de anuncios de Google para dispositivos móviles, consulta Anuncios de prueba.

Carga anuncios

Los anuncios nativos se cargan con la clase AdLoader, que tiene su propia clase Builder para personalizarla durante la creación. Cuando se agregan objetos de escucha a AdLoader durante su compilación, una app especifica los tipos de anuncios nativos que está lista para recibir. Luego, AdLoader solo solicita esos tipos.

Cómo compilar un AdLoader

Punto clave: Realiza todas las llamadas al SDK de anuncios para dispositivos móviles en el subproceso principal.

En el siguiente código, se muestra cómo compilar un AdLoader que puede cargar anuncios nativos:

Java

AdLoader adLoader = new AdLoader.Builder(context, "/21775744923/example/native")
    .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
        @Override
        public void onNativeAdLoaded(NativeAd nativeAd) {
            // Show the ad.
        }
    })
    .withAdListener(new AdListener() {
        @Override
        public void onAdFailedToLoad(LoadAdError adError) {
            // Handle the failure by logging, altering the UI, and so on.
        }
    })
    .withNativeAdOptions(new NativeAdOptions.Builder()
            // Methods in the NativeAdOptions.Builder class can be
            // used here to specify individual options settings.
            .build())
    .build();

Kotlin

val adLoader = AdLoader.Builder(this, "/21775744923/example/native}")
    .forNativeAd { ad : NativeAd ->
        // Show the ad.
    }
    .withAdListener(object : AdListener() {
        override fun onAdFailedToLoad(adError: LoadAdError) {
            // Handle the failure.
        }
    })
    .withNativeAdOptions(NativeAdOptions.Builder()
            // Methods in the NativeAdOptions.Builder class can be
            // used here to specify individual options settings.
            .build())
    .build()

Advertencia: No se recomienda intentar cargar un anuncio nuevo desde el método onAdFailedToLoad(). Si debes cargar un anuncio desde onAdFailedToLoad(), limita los reintentos de carga de anuncios para evitar solicitudes de anuncios con errores continuos en situaciones como conectividad de red limitada.

El método forNativeAd() es responsable de preparar el AdLoader para el formato NativeAd. Cuando un anuncio se carga correctamente, se llama al método onNativeAdLoaded() del objeto de escucha.

Configura un AdListener con AdLoader (opcional)

Cuando se crea el AdLoader, la función withAdListener establece un AdListener para el cargador. El método toma un AdListener como su único parámetro, que recibe callbacks del AdLoader cuando se producen eventos de ciclo de vida:

Java

.withAdListener(new AdListener() {
    // AdListener callbacks can be overridden here.
})

Kotlin

.withAdListener(object : AdListener() {
    // AdListener callbacks can be overridden here.
})

Solicitar anuncios

Sugerencia: Puedes usar llamadas de carga de anuncios para crear una caché de anuncios precargados antes de mostrarlos, de modo que se puedan mostrar con cero latencia cuando sea necesario. Dado que los anuncios vencen después de una hora, debes borrar esta caché y volver a cargar anuncios nuevos cada hora.

Una vez que termines de crear un AdLoader, es momento de usarlo para solicitar anuncios. Usa el método loadAd(), que toma un objeto AdManagerAdRequest como primer parámetro. Esta es la misma clase AdManagerAdRequest que usan los anuncios intersticiales y de banners, y puedes usar métodos de la clase AdManagerAdRequest para agregar información de segmentación, tal como lo harías con otros formatos de anuncios.

loadAd()

Este método envía una solicitud para un solo anuncio.

Java

adLoader.loadAd(new AdManagerAdRequest.Builder().build());

Kotlin

adLoader.loadAd(AdManagerAdRequest.Builder().build())

Nota: Ad Manager no admite el método loadAds() y, si se usa, solo muestra un anuncio.

Devoluciones de llamada

Después de una llamada a loadAd(), se realiza una sola devolución de llamada a los métodos de objeto de escucha definidos anteriormente para entregar el objeto de anuncio nativo o informar un error.

Libera recursos

Asegúrate de usar el método destroy() en los anuncios nativos cargados. Esto libera los recursos utilizados y evita las fugas de memoria.

Punto clave: Se debe llamar a destroy() en todos los anuncios, incluso si no se usaron ni se hizo referencia a ellos.

Asegúrate de que se destruyan todas las referencias a NativeAd en el método onDestroy() de tu actividad.

En la devolución de llamada de onNativeAdLoaded, asegúrate de destruir los anuncios nativos existentes que se desreferenciarán.

Otra verificación clave es si se destruye la actividad y, de ser así, llama a destroy() en el anuncio que se muestra y muestra de inmediato lo siguiente:

Java

final AdLoader adLoader = new AdLoader.Builder(this, "/21775744923/example/native")
        .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
    @Override
    public void onNativeAdLoaded(NativeAd nativeAd) {
        // If this callback occurs after the activity is destroyed, you
        // must call destroy and return or you may get a memory leak.
        // Note `isDestroyed()` is a method on Activity.
        if (isDestroyed()) {
            nativeAd.destroy();
            return;
        }
        ...
    }
}).build();

Kotlin

lateinit var adLoader: AdLoader
...
adLoader = AdLoader.Builder(this, "/21775744923/example/native")
    .forNativeAd { nativeAd ->
        // If this callback occurs after the activity is destroyed, you
        // must call destroy and return or you may get a memory leak.
        // Note `isDestroyed` is a method on Activity.
        if (isDestroyed) {
            nativeAd.destroy()
            return@forNativeAd
        }
        ...
    }.build()

Prácticas recomendadas

Sigue estas reglas cuando cargues anuncios.

• Las apps que usan anuncios nativos en una lista deben almacenar en caché la lista de anuncios de forma previa.

• Cuando almacenes anuncios en caché de forma previa, borra la caché y vuelve a cargarla después de una hora.

• No llames a loadAd() en un AdLoader hasta que se termine de cargar la primera solicitud.

• Limita la caché de anuncios nativos solo a lo que sea necesario. Por ejemplo, cuando se precarga, solo almacena en caché los anuncios que se ven de inmediato en la pantalla. Los anuncios nativos tienen un gran espacio en la memoria, y almacenar en caché los anuncios nativos sin destruirlos genera un uso excesivo de la memoria.

• Destruye los anuncios nativos cuando ya no se usen.

Aceleración de hardware para los anuncios de video

Para que los anuncios de video se muestren correctamente en tus vistas de anuncios nativos, debes habilitar la aceleración de hardware.

La aceleración de hardware está habilitada de forma predeterminada, pero algunas apps pueden inhabilitarla. Si esto se aplica a tu app, te recomendamos que habilites la aceleración de hardware para las clases de Activity que usan anuncios.

Cómo habilitar la aceleración de hardware

Si la aceleración de hardware activada globalmente hace que tu app no se comporte de manera adecuada, puedes controlarla en actividades individuales. Para habilitar o inhabilitar la aceleración de hardware, usa el atributo android:hardwareAccelerated para los elementos <application> y <activity> en tu AndroidManifest.xml. En el siguiente ejemplo, se habilita la aceleración de hardware para toda la app, pero se inhabilita para una actividad:

<application android:hardwareAccelerated="true">
    <!-- For activities that use ads, hardwareAcceleration should be true. -->
    <activity android:hardwareAccelerated="true" />
    <!-- For activities that don't use ads, hardwareAcceleration can be false. -->
    <activity android:hardwareAccelerated="false" />
</application>

Consulta la guía de aceleración de hardware para obtener más información sobre las opciones de control de la aceleración de hardware. Ten en cuenta que las vistas de anuncios individuales no se pueden habilitar para la aceleración de hardware si la actividad está inhabilitada, por lo que la actividad debe tener habilitada la aceleración de hardware.

Cómo mostrar tu anuncio

Una vez que hayas cargado un anuncio, solo queda mostrarlo a tus usuarios. Consulta nuestra guía avanzada de anuncios nativos para ver cómo hacerlo.