Anúncios nativos

Importante: saiba mais sobre anúncios nativos no nosso manual de anúncios nativos. As amostras estão disponíveis para Java e Kotlin. Confira também algumas histórias de sucesso dos clientes: estudo de caso 1, estudo de caso 2.

Os anúncios nativos são recursos de anúncios apresentados aos usuários por componentes de IU nativos da plataforma. Eles aparecem com base nos mesmos tipos de visualização que você usa para criar seus layouts. Além disso, esses anúncios podem ser formatados para corresponder ao design visual da experiência do usuário. Em termos de codificação, isso significa que, quando um anúncio nativo é carregado, seu app recebe um objeto NativeAd que contém os recursos, e o app, em vez do SDK dos anúncios para dispositivos móveis do Google, é responsável por exibi-los.

Em termos gerais, há duas partes para implementar os anúncios nativos com sucesso: carregar um anúncio usando o SDK e, em seguida, exibir o conteúdo do anúncio no seu aplicativo.

Esta página está relacionada ao uso do SDK para carregar anúncios nativos.

Pré-requisitos

• Conclua o guia Primeiros passos.

Implementação

Os anúncios nativos são carregados com a classe AdLoader, que tem a própria classe Builder para personalizá-la durante a criação. Ao adicionar listeners à AdLoader ao criá-la, um app especifica quais tipos de anúncios nativos ela está pronta para receber. O AdLoader solicita apenas esses tipos.

Criar um AdLoader

Importante: faça todas as chamadas para o SDK de anúncios para dispositivos móveis na linha de execução principal.

O código a seguir demonstra como criar um AdLoader que possa carregar anúncios nativos:

Java

AdLoader adLoader = new AdLoader.Builder(context, "ca-app-pub-3940256099942544/2247696110")
    .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, "ca-app-pub-3940256099942544/2247696110")
    .forNativeAd { ad : NativeAd ->
        // Show the ad.
    }
    .withAdListener(object : AdListener() {
        override fun onAdFailedToLoad(adError: LoadAdError) {
            // Handle the failure by logging, altering the UI, and so on.
        }
    })
    .withNativeAdOptions(NativeAdOptions.Builder()
            // Methods in the NativeAdOptions.Builder class can be
            // used here to specify individual options settings.
            .build())
    .build()

Aviso:não é recomendável carregar um novo anúncio do método onAdFailedToLoad(). Se você precisar carregar um anúncio de onAdFailedToLoad(), limite as tentativas de carregamento de anúncios para evitar solicitações contínuas de falha com anúncios em situações como conectividade de rede limitada.

Prepare-se para o formato NativeAd

O primeiro método acima é responsável por preparar o AdLoader para o formato NativeAd:

forNativeAd()

Chamar esse método configura o AdLoader para solicitar anúncios nativos. Quando um anúncio é carregado corretamente, o método onNativeAdLoaded() do objeto do listener é chamado.

Quando AdLoader faz uma solicitação de anúncio, o Google seleciona e retorna o anúncio que maximiza o rendimento do editor.

Configurar um AdListener com o AdLoader (opcional)

Durante a criação do AdLoader acima, a função withAdListener define um AdListener. O método usa um AdListener como parâmetro solitário, que recebe callbacks da AdLoader quando ocorrem eventos de ciclo de vida do anúncio:

Java

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

Kotlin

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

Carregar anúncios

Depois de criar um AdLoader, é hora de usá-lo para carregar anúncios. Há dois métodos disponíveis para fazer isso: loadAd() e loadAds().

Importante: no momento, o método loadAds() funciona apenas com os anúncios do Google. Para anúncios mediados, use loadAd().

loadAd()

Este método envia uma solicitação para um único anúncio. :

Java

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

Kotlin

adLoader.loadAd(AdRequest.Builder().build())

loadAds()

Este método envia uma solicitação de vários anúncios (até cinco):

Java

adLoader.loadAds(new AdRequest.Builder().build(), 3);

Kotlin

adLoader.loadAds(AdRequest.Builder().build(), 3)

Ambos os métodos usam um objeto AdRequest como primeiro parâmetro. Essa é a mesma classe AdRequest usada por banners e intersticiais, e você pode usar métodos da classe AdRequest para adicionar informações de segmentação, assim como como outros formatos de anúncio.

loadAds() usa um parâmetro adicional: o número de anúncios que o SDK deve tentar carregar para a solicitação. Esse número é limitado a cinco, e não é garantido que o SDK retornará o número exato de anúncios solicitados.

Os anúncios do Google retornados serão diferentes entre si. Não há garantia de que os anúncios de inventário reservado ou de terceiros, incluindo compradores configurados para mediação ou lances em hierarquia, sejam exclusivos.

Callbacks

Após uma chamada para loadAd(), um único callback é feito para os métodos de listener definidos anteriormente para exibir o objeto de anúncio nativo ou informar um erro.

Após uma chamada para loadAds(), vários retornos de chamada serão feitos (pelo menos um, e não mais que o número de anúncios solicitados). Os apps que solicitam vários anúncios precisam chamar AdLoader.isLoading() nas implementações de callback para determinar se o processo de carregamento foi concluído.

Veja um exemplo que mostra como verificar isLoading() no callback onNativeAdLoaded():

Java

final AdLoader adLoader = new AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
        .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
    @Override
    public void onNativeAdLoaded(NativeAd nativeAd) {
        ...
        // some code that displays the ad.
        ...
        if (adLoader.isLoading()) {
            // The AdLoader is still loading ads.
            // Expect more adLoaded or onAdFailedToLoad callbacks.
        } else {
            // The AdLoader has finished loading ads.
        }
    }
}).build();
adLoader.loadAds(new AdRequest.Builder().build(), 3);

Kotlin

lateinit var adLoader: AdLoader
...
adLoader = AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
    .forNativeAd {
        ...
        // some code that displays the ad.
        ...
        if (adLoader.isLoading) {
            // The AdLoader is still loading ads.
            // Expect more adLoaded or onAdFailedToLoad callbacks.
        } else {
            // The AdLoader has finished loading ads.
        }
    }.build()
adLoader.loadAds(AdRequest.Builder().build(), 3)

Importante: ao reutilizar um AdLoader, aguarde a finalização de cada solicitação antes de chamar loadAd() ou loadAds() novamente.

Liberar recursos

Use o método destroy() em anúncios nativos carregados. Isso libera os recursos utilizados e evita vazamentos de memória.

Importante: destroy() precisa ser chamado em todos os anúncios, mesmo que não sejam usados ou referenciados.

Certifique-se de que todas as referências a NativeAd sejam destruídas no método onDestroy() da atividade.

No callback onNativeAdLoaded, destrua todos os anúncios nativos atuais que serão desreferenciados.

Outra verificação importante é que, se a atividade for destruída, será possível chamar destroy() no anúncio retornado e retornar imediatamente:

Java

final AdLoader adLoader = new AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
        .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, "ca-app-pub-3940256099942544/2247696110")
    .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()

Sempre testar com anúncios de teste

Ao criar e testar seus apps, use anúncios de teste em vez de anúncios de produção ativos. Sua conta poderá ser suspensa se isso não for feito.

A maneira mais fácil de carregar anúncios de teste é usar nosso ID de bloco de anúncios de teste dedicado para o Native Native no Android:

ca-app-pub-3940256099942544/2247696110

Ele foi configurado especialmente para retornar anúncios de teste para todas as solicitações, e você pode usá-los nos seus próprios apps ao programar, testar e depurar. Basta substituí-lo pelo ID do seu bloco de anúncios antes de publicar o app.

Para mais informações sobre como os anúncios de teste do SDK de anúncios para dispositivos móveis funcionam, consulte Anúncios de teste.

Quando solicitar anúncios

Os aplicativos que exibem anúncios nativos podem solicitá-los antes de serem exibidos. Em muitos casos, essa é a prática recomendada. Um app que exibe uma lista de itens com anúncios nativos misturados, por exemplo, pode carregar anúncios nativos para a lista inteira, sabendo que alguns serão exibidos somente depois que o usuário rolar a visualização e outros talvez não sejam exibidos.

Observação: pré-buscar anúncios é uma ótima técnica, mas é importante que os editores não mantenham os anúncios antigos por muito tempo sem exibi-los. Os objetos de anúncios mantidos por mais de uma hora sem serem exibidos precisam ser descartados e substituídos por novos anúncios de uma nova solicitação.

Aceleração de hardware para anúncios em vídeo

Para que os anúncios em vídeo sejam exibidos com sucesso nas visualizações nativas, a aceleração do hardware precisa estar ativada.

A aceleração de hardware é ativada por padrão, mas alguns apps podem desativá-la. Se isso se aplica ao seu app, recomendamos que você ative a aceleração de hardware para as classes de atividade que usam anúncios.

Ativar a aceleração de hardware

Se o app não se comporta corretamente com a aceleração de hardware ativada globalmente, você também pode controlar esse recurso em atividades individuais. Para ativar ou desativar a aceleração de hardware, use o atributo android:hardwareAccelerated para os elementos <application> e <activity> no seu AndroidManifest.xml. O exemplo a seguir ativa a aceleração de hardware para todo o app, mas a desativa para uma atividade:

<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>

Consulte o Guia de aceleração de hardware para ver mais informações sobre opções de controle da aceleração de hardware. Observe que as visualizações de anúncios individuais não poderão ser ativadas para aceleração de hardware se a atividade estiver desativada. Portanto, a atividade em si precisa ter a aceleração de hardware ativada.

Exibir um NativeAd

Após carregar um anúncio, basta exibi-lo para seus usuários. Acesse nosso guia nativo avançado para saber como fazer isso.