Eventos personalizados de anúncios nativos

Pré-requisitos

Conclua a configuração de eventos personalizados.

Solicitar um anúncio nativo

Quando o item de linha do evento personalizado é alcançado na cadeia de mediação em cascata, o método loadNativeAd() é chamado no nome da classe que você forneceu ao criar um evento personalizado. Nesse caso, esse método está em SampleCustomEvent, que chama o método loadNativeAd() em SampleNativeCustomEventLoader.

Para solicitar um anúncio nativo, crie ou modifique uma classe que estende Adapter para implementar loadNativeAd(). Se uma classe que estende Adapter já existir, implemente loadNativeAd() nela. Além disso, crie uma nova classe para implementar UnifiedNativeAdMapper.

No nosso exemplo de evento personalizado, SampleCustomEvent estende a classe Adapter e delega para SampleNativeCustomEventLoader.

package com.google.ads.mediation.sample.customevent;

import com.google.android.gms.ads.mediation.Adapter;
import com.google.android.gms.ads.mediation.MediationAdConfiguration;
import com.google.android.gms.ads.mediation.MediationAdLoadCallback;

import com.google.android.gms.ads.mediation.MediationNativeAdCallback;
...
public class SampleCustomEvent extends Adapter {
  private SampleNativeCustomEventLoader nativeLoader;

  @Override
  public void loadNativeAd(
      @NonNull MediationNativeAdConfiguration adConfiguration,
      @NonNull MediationAdLoadCallback<UnifiedNativeAdMapper, MediationNativeAdCallback> callback) {
    nativeLoader = new SampleNativeCustomEventLoader(adConfiguration, callback);
    nativeLoader.loadAd();
  }
}

SampleNativeCustomEventLoader é responsável pelas seguintes tarefas:

• Carregamento do anúncio nativo.

• Implementação da classe UnifiedNativeAdMapper.

• Receber e informar callbacks de eventos de anúncios ao SDK dos anúncios para dispositivos móveis do Google.

O parâmetro opcional definido na interface da AdMob é incluído na configuração do anúncio. O parâmetro pode ser acessado usando adConfiguration.getServerParameters().getString(MediationConfiguration.CUSTOM_EVENT_SERVER_PARAMETER_FIELD). Esse parâmetro geralmente é um identificador de bloco de anúncios que um SDK da rede de publicidade requer ao instanciar um objeto de anúncio.

package com.google.ads.mediation.sample.customevent;

import com.google.android.gms.ads.mediation.Adapter;
import com.google.android.gms.ads.mediation.MediationNativeAdConfiguration;
import com.google.android.gms.ads.mediation.MediationAdLoadCallback;
import com.google.android.gms.ads.mediation.MediationNativeAdCallback;
...

public class SampleNativeCustomEventLoader extends SampleNativeAdListener {
  /** Configuration for requesting the native ad from the third-party network. */
  private final MediationNativeAdConfiguration mediationNativeAdConfiguration;

  /** Callback that fires on loading success or failure. */
  private final MediationAdLoadCallback<UnifiedNativeAdMapper, MediationNativeAdCallback>
      mediationAdLoadCallback;

  /** Callback for native ad events. */
  private MediationNativeAdCallback nativeAdCallback;

  /** Constructor */
  public SampleNativeCustomEventLoader(
      @NonNull MediationNativeAdConfiguration mediationNativeAdConfiguration,
      @NonNull MediationAdLoadCallback<MediationNativeAd, MediationNativeAdCallback>
              mediationAdLoadCallback) {
    this.mediationNativeAdConfiguration = mediationNativeAdConfiguration;
    this.mediationAdLoadCallback = mediationAdLoadCallback;
  }

  /** Loads the native ad from the third-party ad network. */
  public void loadAd() {
    // Create one of the Sample SDK's ad loaders to request ads.
    Log.i("NativeCustomEvent", "Begin loading native ad.");
    SampleNativeAdLoader loader =
        new SampleNativeAdLoader(mediationNativeAdConfiguration.getContext());

    // All custom events have a server parameter named "parameter" that returns
    // back the parameter entered into the UI when defining the custom event.
    String serverParameter = mediationNativeAdConfiguration
        .getServerParameters()
        .getString(MediationConfiguration
        .CUSTOM_EVENT_SERVER_PARAMETER_FIELD);
    Log.d("NativeCustomEvent", "Received server parameter.");

    loader.setAdUnit(serverParameter);

    // Create a native request to give to the SampleNativeAdLoader.
    SampleNativeAdRequest request = new SampleNativeAdRequest();
    NativeAdOptions options = mediationNativeAdConfiguration.getNativeAdOptions();
    if (options != null) {
      // If the NativeAdOptions' shouldReturnUrlsForImageAssets is true, the adapter should
      // send just the URLs for the images.
      request.setShouldDownloadImages(!options.shouldReturnUrlsForImageAssets());

      request.setShouldDownloadMultipleImages(options.shouldRequestMultipleImages());
      switch (options.getMediaAspectRatio()) {
        case NativeAdOptions.NATIVE_MEDIA_ASPECT_RATIO_LANDSCAPE:
          request.setPreferredImageOrientation(SampleNativeAdRequest.IMAGE_ORIENTATION_LANDSCAPE);
          break;
        case NativeAdOptions.NATIVE_MEDIA_ASPECT_RATIO_PORTRAIT:
          request.setPreferredImageOrientation(SampleNativeAdRequest.IMAGE_ORIENTATION_PORTRAIT);
          break;
        case NativeAdOptions.NATIVE_MEDIA_ASPECT_RATIO_SQUARE:
        case NativeAdOptions.NATIVE_MEDIA_ASPECT_RATIO_ANY:
        case NativeAdOptions.NATIVE_MEDIA_ASPECT_RATIO_UNKNOWN:
        default:
          request.setPreferredImageOrientation(SampleNativeAdRequest.IMAGE_ORIENTATION_ANY);
      }
    }

    loader.setNativeAdListener(this);

    // Begin a request.
    Log.i("NativeCustomEvent", "Start fetching native ad.");
    loader.fetchAd(request);
  }
}

Dependendo se o anúncio é buscado com êxito ou encontra um erro, você vai chamar onSuccess() ou onFailure(). onSuccess() é chamado transmitindo uma instância da classe que implementa MediationNativeAd.

Normalmente, esses métodos são implementados em callbacks do SDK de terceiros que o adaptador implementa. Para este exemplo, o SDK de exemplo tem uma SampleAdListener com callbacks relevantes:

@Override
public void onNativeAdFetched(SampleNativeAd ad) {
  SampleUnifiedNativeAdMapper mapper = new SampleUnifiedNativeAdMapper(ad);
  mediationNativeAdCallback = mediationAdLoadCallback.onSuccess(mapper);
}

@Override
public void onAdFetchFailed(SampleErrorCode errorCode) {
  mediationAdLoadCallback.onFailure(SampleCustomEventError.createSampleSdkError(errorCode));
}

Mapear anúncios nativos

Diferentes SDKs têm formatos exclusivos para anúncios nativos. Uma pode retornar objetos que contêm um campo "title", por exemplo, enquanto outra pode ter "headline". Além disso, os métodos usados para rastrear impressões e processar cliques podem variar de um SDK para outro.

O UnifiedNativeAdMapper é responsável por reconciliar essas diferenças e adaptar o objeto de anúncio nativo de um SDK mediado para corresponder à interface esperada pelo SDK dos anúncios para dispositivos móveis do Google. Os eventos personalizados precisam estender essa classe para criar os próprios mapeadores específicos do SDK mediado. Confira um exemplo de mapeador de anúncios do nosso projeto de evento personalizado:

package com.google.ads.mediation.sample.customevent;

import com.google.android.gms.ads.mediation.UnifiedNativeAdMapper;
import com.google.android.gms.ads.nativead.NativeAd;
...

public class SampleUnifiedNativeAdMapper extends UnifiedNativeAdMapper {

  private final SampleNativeAd sampleAd;

  public SampleUnifiedNativeAdMapper(SampleNativeAd ad) {
    sampleAd = ad;
    setHeadline(sampleAd.getHeadline());
    setBody(sampleAd.getBody());
    setCallToAction(sampleAd.getCallToAction());
    setStarRating(sampleAd.getStarRating());
    setStore(sampleAd.getStoreName());
    setIcon(
        new SampleNativeMappedImage(
            ad.getIcon(), ad.getIconUri(), SampleCustomEvent.SAMPLE_SDK_IMAGE_SCALE));
    setAdvertiser(ad.getAdvertiser());

    List<NativeAd.Image> imagesList = new ArrayList<NativeAd.Image>();
    imagesList.add(new SampleNativeMappedImage(ad.getImage(), ad.getImageUri(),
        SampleCustomEvent.SAMPLE_SDK_IMAGE_SCALE));
    setImages(imagesList);

    if (sampleAd.getPrice() != null) {
      NumberFormat formatter = NumberFormat.getCurrencyInstance();
      String priceString = formatter.format(sampleAd.getPrice());
      setPrice(priceString);
    }

    Bundle extras = new Bundle();
    extras.putString(SampleCustomEvent.DEGREE_OF_AWESOMENESS, ad.getDegreeOfAwesomeness());
    this.setExtras(extras);

    setOverrideClickHandling(false);
    setOverrideImpressionRecording(false);

    setAdChoicesContent(sampleAd.getInformationIcon());
  }

  @Override
  public void recordImpression() {
    sampleAd.recordImpression();
  }

  @Override
  public void handleClick(View view) {
    sampleAd.handleClick(view);
  }

  // The Sample SDK doesn't do its own impression/click tracking, instead relies on its
  // publishers calling the recordImpression and handleClick methods on its native ad object. So
  // there's no need to pass a reference to the View being used to display the native ad. If
  // your mediated network does need a reference to the view, the following method can be used
  // to provide one.

  @Override
  public void trackViews(View containerView, Map<String, View> clickableAssetViews,
      Map<String, View> nonClickableAssetViews) {
    super.trackViews(containerView, clickableAssetViews, nonClickableAssetViews);
    // If your ad network SDK does its own impression tracking, here is where you can track the
    // top level native ad view and its individual asset views.
  }

  @Override
  public void untrackView(View view) {
    super.untrackView(view);
    // Here you would remove any trackers from the View added in trackView.
  }
}

Agora vamos analisar melhor o código do construtor.

Manter uma referência ao objeto de anúncio nativo mediado

O construtor aceita o parâmetro SampleNativeAd, a classe de anúncios nativos usada pelo SDK de exemplo para os anúncios nativos. O mapeador precisa de uma referência ao anúncio mediado para transmitir eventos de clique e impressão. SampleNativeAd é armazenado como uma variável local.

Definir propriedades de recursos mapeados

O construtor usa o objeto SampleNativeAd para preencher recursos no UnifiedNativeAdMapper.

Este snippet recebe os dados de preço do anúncio mediado e os usa para definir o preço do mapeador:

if (sampleAd.getPrice() != null) {
    NumberFormat formatter = NumberFormat.getCurrencyInstance();
    String priceString = formatter.format(sampleAd.getPrice());
    setPrice(priceString);
}

Neste exemplo, o anúncio mediado armazena o preço como um double, enquanto a AdMob usa um String para o mesmo recurso. O mapeador é responsável por processar esses tipos de conversões.

Mapear recursos de imagem

O mapeamento de recursos de imagem é mais complicado do que o mapeamento de tipos de dados, como double ou String. As imagens podem ser transferidas por download automaticamente ou retornadas como valores de URL. As escalas de pixel para dpi também podem variar.

Para ajudar a gerenciar esses detalhes, o SDK dos anúncios para dispositivos móveis do Google oferece a classe NativeAd.Image. Assim como você precisa criar uma subclasse de UnifiedNativeAdMapper para mapear um anúncio nativo mediado, também é necessário criar uma subclasse de NativeAd.Image ao mapear recursos de imagem.

Confira um exemplo da classe SampleNativeMappedImage do evento personalizado:

public class SampleNativeMappedImage extends NativeAd.Image {

  private Drawable drawable;
  private Uri imageUri;
  private double scale;

  public SampleNativeMappedImage(Drawable drawable, Uri imageUri, double scale) {
    this.drawable = drawable;
    this.imageUri = imageUri;
    this.scale = scale;
  }

  @Override
  public Drawable getDrawable() {
    return drawable;
  }

  @Override
  public Uri getUri() {
    return imageUri;
  }

  @Override
  public double getScale() {
    return scale;
  }
}

O SampleNativeAdMapper usa a classe de imagem mapeada nesta linha para definir o recurso de imagem do ícone do mapeador:

setIcon(new SampleNativeMappedImage(ad.getAppIcon(), ad.getAppIconUri(),
    SampleCustomEvent.SAMPLE_SDK_IMAGE_SCALE));

Adicionar campos ao pacote de extras

Alguns SDKs mediados oferecem recursos adicionais além daqueles no formato de anúncio nativo da AdMob. A classe UnifiedNativeAdMapper inclui um método setExtras() que é usado para transmitir esses recursos aos editores. O SampleNativeAdMapper usa isso para o recurso "degree of awesomeness" do SDK de exemplo:

Bundle extras = new Bundle();
extras.putString(SampleCustomEvent.DEGREE_OF_AWESOMENESS, ad.getDegreeOfAwesomeness());
this.setExtras(extras);

Os editores podem recuperar os dados usando o método getExtras() da classe NativeAd.

Opções de anúncios

Seu evento personalizado é responsável por fornecer um ícone de Opções de anúncios usando o método setAdChoicesContent() em UnifiedNativeAdMapper. Confira um snippet de SampleNativeAdMapper mostrando como fornecer o ícone de Opções de anúncios:

public SampleNativeAdMapper(SampleNativeAd ad) {
    ...
    setAdChoicesContent(sampleAd.getInformationIcon());
}

Eventos de impressão e clique

Tanto o SDK dos anúncios para dispositivos móveis do Google quanto o SDK mediado precisam saber quando uma impressão ou um clique ocorre, mas apenas um SDK precisa acompanhar esses eventos. Há duas abordagens diferentes que os eventos personalizados podem usar, dependendo se o SDK mediado oferece suporte ao rastreamento de impressões e cliques por conta própria.

Rastrear cliques e impressões com o SDK dos anúncios para dispositivos móveis do Google

Se o SDK mediado não executar o próprio rastreamento de impressões e cliques, mas oferecer métodos para registrar cliques e impressões, o SDK dos anúncios para dispositivos móveis do Google poderá rastrear esses eventos e notificar o adaptador. A classe UnifiedNativeAdMapper inclui dois métodos: recordImpression() e handleClick() que os eventos personalizados podem implementar para chamar o método correspondente no objeto de anúncio nativo mediado:

@Override
public void recordImpression() {
  sampleAd.recordImpression();
}

@Override
public void handleClick(View view) {
  sampleAd.handleClick(view);
}

Como o SampleNativeAdMapper contém uma referência ao objeto de anúncio nativo do SDK de exemplo, ele pode chamar o método apropriado nesse objeto para informar um clique ou uma impressão. O método handleClick() usa um único parâmetro: o objeto View correspondente ao recurso de anúncio nativo que recebeu o clique.

Rastrear cliques e impressões com o SDK mediado

Alguns SDKs mediados podem preferir rastrear cliques e impressões por conta própria. Nesse caso, substitua o acompanhamento de cliques e impressões padrão fazendo as duas chamadas a seguir no construtor do UnifiedNativeAdMapper:

setOverrideClickHandling(true);
setOverrideImpressionRecording(true);

Eventos personalizados que substituem o acompanhamento de cliques e impressões são necessários para informar os eventos onAdClicked() e onAdImpression() ao SDK dos anúncios para dispositivos móveis do Google.

Para acompanhar impressões e cliques, o SDK mediado provavelmente precisa ter acesso às visualizações para ativar o acompanhamento. O evento personalizado precisa substituir o método trackViews() e usá-lo para transmitir a visualização do anúncio nativo ao SDK mediado para rastreamento. O SDK de exemplo do nosso projeto de evento personalizado (do qual os snippets de código deste guia foram retirados) não usa essa abordagem. Se usasse, o código do evento personalizado seria parecido com este:

@Override
public void trackViews(View containerView,
    Map<String, View> clickableAssetViews,
    Map<String, View> nonClickableAssetViews) {
  sampleAd.setNativeAdViewForTracking(containerView);
}

Se o SDK mediado oferece suporte ao rastreamento de recursos individuais, ele pode verificar clickableAssetViews para saber quais visualizações precisam ser clicáveis. Esse mapa é codificado por um nome de recurso em NativeAdAssetNames. O UnifiedNativeAdMapper oferece um método untrackView() correspondente que os eventos personalizados podem substituir para liberar todas as referências à visualização e desassociar do objeto de anúncio nativo.

Encaminhar eventos de mediação para o SDK dos anúncios para dispositivos móveis do Google

Encontre todos os callbacks com suporte à mediação nos documentos do MediationNativeAdCallback.

É importante que seu evento personalizado encaminhe o maior número possível de callbacks para que o app receba esses eventos equivalentes do SDK dos anúncios para dispositivos móveis do Google. Confira um exemplo de uso de callbacks:

Isso conclui a implementação de eventos personalizados para anúncios nativos. O exemplo completo está disponível no GitHub.