Banner adaptativo inline

Banners adaptativos inline são um formato flexível de publicidade em banner, proporcionando máxima eficiência ao otimizar o tamanho do anúncio em cada dispositivo.

Esse tipo de anúncio permite que os desenvolvedores definam uma largura e altura máximas permitidas para o anúncio, embora o tamanho ideal do anúncio ainda seja determinado automaticamente. Para selecionar o melhor tamanho de anúncio, os banners adaptativos integrados usam a altura máxima em vez da altura fixa. Dessa forma, há espaço para melhorar o desempenho.

Normalmente, esse formato é usado em aplicativos baseados em feed ou contextos em que é aceitável focar principalmente no anúncio.

Aparência

Este guia mostra como integrar banners adaptativos inline em aplicativos Android. Além de exemplos de código e instruções, contém recomendações específicas aos formatos e links para recursos adicionais.

Pré-requisito

Siga os passos de integração do SDK descritos em Início rápido.
Inicialize seu SDK de anúncios com antecedência.
Confirme se você está utilizando a última versão do Yandex Mobile Ads SDK. Se você estiver usando mediação, confirme se também está utilizando a última versão da compilação unificada.

Implementação

Principais passos para integrar banners adaptativos inline:

Criar e configurar uma visualização para exibir anúncios em banner.
Registrar um listener de método de callback.
Carregar o anúncio.
Passar configurações adicionais se você estiver usando Adfox.

Características da integração de banners adaptativos inline

Todas as chamadas para métodos do Yandex Mobile Ads SDK devem ser feitas a partir do thread principal.
Para exibir corretamente anúncios em vídeo na tela do seu aplicativo, você precisa ativar a aceleração de hardware. A aceleração de hardware é ativada por padrão, mas alguns aplicativos a desativam. Se isso se aplicar ao seu aplicativo, recomendamos ativar a aceleração de hardware para as classes de atividade que usam anúncios.
Se houve um erro no callback onAdFailedToLoad(), não tente carregar um novo anúncio novamente. Se não houver outra opção, limite o número de tentativas de carregamento de anúncios. Isso ajudará a evitar solicitações constantes malsucedidas e problemas de conexão quando surgirem limitações.
Para garantir que os banners adaptativos inline funcionem corretamente, torne seus layouts de aplicativo adaptativos. Caso contrário, seus anúncios podem ser renderizados incorretamente.
Os banners adaptativos inline funcionam melhor quando usam toda a largura disponível. Na maioria dos casos, essa é a largura total da tela do dispositivo. Você deve incluir todas as margens e áreas seguras de exibição aplicáveis ao aplicativo.
Os banners adaptativos inline foram projetados para uso em conteúdo rolável. Ele pode ter a mesma altura que a tela do dispositivo ou ser limitado à altura máxima, dependendo da API.
Para obter o tamanho do anúncio, use o método BannerAdSize.inlineSize(context, adWidth, maxAdHeight), que recebe o contexto do anúncio, a largura disponível do contêiner do anúncio e a altura máxima aceitável do anúncio como argumentos.
O objeto BannerAdSize, calculado usando o método BannerAdSize.inlineSize(context, adWidth, maxAdHeight), contém dados técnicos para selecionar os tamanhos de anúncio mais eficazes no backend. A altura do anúncio pode mudar toda vez que é carregado. A largura e altura reais do anúncio ficam disponíveis após o recebimento de uma mensagem de carregamento de anúncio bem-sucedido.

Adição de uma visualização de anúncio ao layout do aplicativo

Para exibir anúncios em banner, você precisa adicionar BannerAdView ao layout do aplicativo. Você pode fazer isso programaticamente ou usando um arquivo XML.

Exemplo de adição de BannerAdView ao layout da tela do aplicativo:

# activity.xml
...
<com.yandex.mobile.ads.banner.BannerAdView
        android:id="@+id/banner"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
...

Você também pode criar um objeto BannerAdView programaticamente:

Kotlin

Java

val bannerAd = BannerAdView(this)

final BannerAdView bannerAd = new BannerAdView(this);

Carregamento e renderização de anúncios

Após criar BannerAdView e adicioná-lo à tela do aplicativo, o anúncio precisa ser carregado. O tamanho do anúncio também deve ser calculado para cada dispositivo antes de carregar banners adaptativos inline.

Essa operação é realizada automaticamente através da API do SDK: BannerAdSize.inlineSize(context, adWidth, maxAdHeight). Passe o contexto, a largura disponível do contêiner do anúncio e a altura máxima aceitável do anúncio como argumentos. Os banners adaptativos inline funcionam melhor quando utilizam toda a largura disponível da tela. Na maioria dos casos, será a largura total da tela do dispositivo. Você precisa considerar os parâmetros de margem definidos no seu aplicativo e a área segura de exibição:

Kotlin

Java

private val adSize: BannerAdSize
    get() {
        val screenHeight = resources.displayMetrics.run { heightPixels / density }.roundToInt()
        // Calculate the width of the ad, taking into account the padding in the ad container.
        var adWidthPixels = binding.adContainerView.width
        if (adWidthPixels == 0) {
            // If the ad hasn't been laid out, default to the full screen width
            adWidthPixels = resources.displayMetrics.widthPixels
        }
        val adWidth = (adWidthPixels / resources.displayMetrics.density).roundToInt()
        val maxAdHeight = screenHeight / 2

        return BannerAdSize.inlineSize(context, adWidth, maxAdHeight)
    }

@NonNull
private BannerAdSize getAdSize() {
    final DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
    final int screenHeight = Math.round(displayMetrics.heightPixels / displayMetrics.density);
    // Calculate the width of the ad, taking into account the padding in the ad container.
    int adWidthPixels = mBinding.adContainerView.getWidth();
    if (adWidthPixels == 0) {
        // If the ad hasn't been laid out, default to the full screen width
        adWidthPixels = displayMetrics.widthPixels;
    }
    final int adWidth = Math.round(adWidthPixels / displayMetrics.density);
    // Determine the maximum allowable ad height. The current value is given as an example.
    final int maxAdHeight = screenHeight / 2;

    return BannerAdSize.inlineSize(this, adWidth, maxAdHeight);
}

Para carregar um anúncio, você também precisa do contexto de Atividade e da ID da unidade de anúncio (adUnitId) da interface do Yandex Advertising Network.

Para notificar quando os anúncios são carregados ou falham ao carregar e para acompanhar o ciclo de vida dos banners adaptativos inline, defina o listener do método de callback BannerAdEventListener para o objeto da classe BannerAdView.

Você pode expandir os parâmetros de solicitação de anúncio através de AdRequest.Builder() passando interesses do usuário, dados contextuais do aplicativo, detalhes de localização ou outros dados na solicitação. Fornecer dados contextuais adicionais na solicitação pode melhorar consideravelmente a qualidade do anúncio. Saiba mais na seção Segmentação de anúncios.

O exemplo a seguir mostra como carregar um banner adaptativo inline. Após o carregamento bem-sucedido, o banner será exibido automaticamente:

Kotlin

Java

class AdaptiveInlineBannerAdActivity : AppCompatActivity(R.layout.activity_inline_banner_ad) {
    private var bannerAd: BannerAdView? = null
    private lateinit var binding: ActivityInlineBannerAdBinding

    private val adSize: BannerAdSize
        get() {
            val screenHeight = resources.displayMetrics.run { heightPixels / density }.roundToInt()
            // Calculate the width of the ad, taking into account the padding in the ad container.
            var adWidthPixels = binding.adContainerView.width
            if (adWidthPixels == 0) {
                // If the ad hasn't been laid out, default to the full screen width
                adWidthPixels = resources.displayMetrics.widthPixels
            }
            val adWidth = (adWidthPixels / resources.displayMetrics.density).roundToInt()
            // Determine the maximum allowable ad height. The current value is given as an example.
            val maxAdHeight = screenHeight / 2

            return BannerAdSize.inlineSize(context, adWidth, maxAdHeight)
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityInlineBannerAdBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // Since we're loading the banner based on the adContainerView size,
        // we need to wait until this view is laid out before we can get the width
        binding.adContainerView.viewTreeObserver.addOnGlobalLayoutListener(object :
            ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                binding.adContainerView.viewTreeObserver.removeOnGlobalLayoutListener(this);
                bannerAd = loadBannerAd(adSize)
            }
        })
    }

    private fun loadBannerAd(adSize: BannerAdSize): BannerAdView {
        return binding.banner.apply {
            setAdSize(adSize)
            setAdUnitId("your-ad-unit-id")
            setBannerAdEventListener(object : BannerAdEventListener {
                override fun onAdLoaded() {
                    // 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) {
                        bannerAd?.destroy()
                        return
                    }
                }

                override fun onAdFailedToLoad(adRequestError: AdRequestError) {
                    // Ad failed to load with AdRequestError.
                    // Attempting to load a new ad from the onAdFailedToLoad() method is strongly discouraged.
                }

                override fun onAdClicked() {
                    // Called when a click is recorded for an ad.
                }

                override fun onLeftApplication() {
                    // Called when user is about to leave application (e.g., to go to the browser), as a result of clicking on the ad.
                }

                override fun onReturnedToApplication() {
                    // Called when user returned to application after click.
                }

                override fun onImpression(impressionData: ImpressionData?) {
                    // Called when an impression is recorded for an ad.
                }
            })
            loadAd(
                AdRequest.Builder()
                    // Methods in the AdRequest.Builder class can be used here to specify individual options settings.
                    .build()
            )
        }
    }
}

public class AdaptiveInlineBannerAdActivity extends AppCompatActivity {
    @Nullable
    private BannerAdView mBannerAd = null;
    private ActivityInlineBannerAdBinding mBinding;

    public AdaptiveInlineBannerAdActivity() {
        super(R.layout.activity_inline_banner_ad);
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = ActivityInlineBannerAdBinding.inflate(getLayoutInflater());
        setContentView(mBinding.getRoot());

        // Since we're loading the banner based on the adContainerView size,
        // we need to wait until this view is laid out before we can get the width
        mBinding.adContainerView.getViewTreeObserver().addOnGlobalLayoutListener(
                new ViewTreeObserver.OnGlobalLayoutListener() {
                    @Override
                    public void onGlobalLayout() {
                        mBinding.adContainerView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                        mBannerAd = loadBannerAd(getAdSize());
                    }
                }
        );
    }

    @NonNull
    private BannerAdSize getAdSize() {
        final DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        final int screenHeight = Math.round(displayMetrics.heightPixels / displayMetrics.density);
        // Calculate the width of the ad, taking into account the padding in the ad container.
        int adWidthPixels = mBinding.adContainerView.getWidth();
        if (adWidthPixels == 0) {
            // If the ad hasn't been laid out, default to the full screen width
            adWidthPixels = displayMetrics.widthPixels;
        }
        final int adWidth = Math.round(adWidthPixels / displayMetrics.density);
        // Determine the maximum allowable ad height. The current value is given as an example.
        final int maxAdHeight = screenHeight / 2;

        return BannerAdSize.inlineSize(this, adWidth, maxAdHeight);
    }

    @NonNull
    private BannerAdView loadBannerAd(@NonNull final BannerAdSize adSize) {
        final BannerAdView bannerAd = mBinding.banner;
        bannerAd.setAdSize(adSize);
        bannerAd.setAdUnitId("your-ad-unit-id");
        bannerAd.setBannerAdEventListener(new BannerAdEventListener() {
            @Override
            public void onAdLoaded() {
                // 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() && mBannerAd != null) {
                    mBannerAd.destroy();
                }
            }

            @Override
            public void onAdFailedToLoad(@NonNull final AdRequestError adRequestError) {
                // Ad failed to load with AdRequestError.
                // Attempting to load a new ad from the onAdFailedToLoad() method is strongly discouraged.
            }

            @Override
            public void onAdClicked() {
                // Called when a click is recorded for an ad.
            }

            @Override
            public void onLeftApplication() {
                // Called when user is about to leave application (e.g., to go to the browser), as a result of clicking on the ad.
            }

            @Override
            public void onReturnedToApplication() {
                // Called when user returned to application after click.
            }

            @Override
            public void onImpression(@Nullable ImpressionData impressionData) {
                // Called when an impression is recorded for an ad.
            }
        });
        final AdRequest adRequest = new AdRequest.Builder()
                // Methods in the AdRequest.Builder class can be used here to specify individual options settings.
                .build();
        bannerAd.loadAd(adRequest);
        return bannerAd;
    }
}

Liberação de recursos

Se o método de callback foi chamado após o término do ciclo de vida de Activity, libere os recursos chamando a função destroy() para o objeto do anúncio:

Kotlin

Java

private fun loadBannerAd(adSize: BannerAdSize): BannerAdView {
    return binding.banner.apply {
        setBannerAdEventListener(object : BannerAdEventListener {
            override fun onAdLoaded() {
                // 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) {
                    bannerAd?.destroy()
                    return
                }
            }
            ...
        })
        ...
    }
}

@NonNull
private BannerAdView loadBannerAd(@NonNull final BannerAdSize adSize) {
    final BannerAdView bannerAd = mBinding.banner;
    bannerAd.setBannerAdEventListener(new BannerAdEventListener() {
        @Override
        public void onAdLoaded() {
            // 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() && mBannerAd != null) {
                mBannerAd.destroy();
            }
        }
        ...
    });
    ...
    return bannerAd;
}

Teste da integração do banner adaptativo inline

Uso de blocos de anúncios de demonstração para teste de anúncios

Recomendamos usar anúncios de teste para testar sua integração de banner adaptativo inline e seu próprio aplicativo.

Para garantir que anúncios de teste sejam retornados para cada solicitação de anúncio, criamos um ID especial de posicionamento de anúncios de demonstração. Use-o para verificar sua integração de anúncios.

adUnitId de demonstração: demo-banner-yandex.

Importante

Antes de publicar seu app na loja, lembre-se de substituir a ID de inserção demonstrativa por uma ID real obtida na interface do Yandex Advertising Network.

Confira a lista de IDs de posicionamento de anúncios de demonstração disponíveis na seção Blocos de anúncio de demonstração para teste.

Teste da integração de anúncios

Você pode testar sua integração de banner adaptativo inline usando o analisador integrado do SDK.

A ferramenta garante que seus anúncios estejam integrados corretamente e gera um relatório detalhado no log. Para ver o relatório, procure a palavra-chave "YandexAds" na ferramenta Logcat usada para depuração de aplicativos Android.

adb logcat -v brief '*:S YandexAds'

Se a integração for bem-sucedida, você verá esta mensagem:

adb logcat -v brief '*:S YandexAds'
mobileads$ adb logcat -v brief '*:S YandexAds'
I/YandexAds(13719): [Integration] Ad type banner was integrated successfully

Se você estiver tendo problemas para integrar anúncios em banner, receberá um relatório detalhado sobre os problemas e recomendações de como corrigi-los.

Recursos adicionais

Link para GitHub.

Este artigo foi útil?

Seguinte

Anúncios intersticiais