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 hierarquia,
the loadNativeAd()
method é chamado no nome da classe fornecido ao
criar um evento
personalizado. Nesse caso,
esse método está em SampleCustomEvent
, que chama
the loadNativeAd()
method em SampleNativeCustomEventLoader
.
Para solicitar um anúncio nativo, crie ou modifique uma classe que estenda 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
.
Em nosso exemplo de evento personalizado,
SampleCustomEvent
implementa
the Adapter
interface e, em seguida, delega para
SampleNativeCustomEventLoader
.
Java
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(); } }
OSampleNativeCustomEventLoader
é responsável pelas seguintes tarefas:
Carregar o anúncio nativo
Implementar o
UnifiedNativeAdMapper
interfaceReceber e relatar callbacks de eventos de anúncios para o SDK dos anúncios para dispositivos móveis do Google.
O parâmetro opcional definido na interface 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 normalmente é um identificador de bloco de anúncios que um SDK de rede de publicidade exige ao instanciar um objeto de anúncio.
Java
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 de o anúncio ser buscado ou encontrar um erro, você
chama
onSuccess()
ou
onFailure()
.
O onSuccess()
é chamado transmitindo uma instância da classe que implementa
MediationNativeAd
.
Normalmente, esses métodos são implementados dentro de callbacks do
SDK de terceiros implementado pelo adaptador. Neste exemplo, o SDK de amostra
tem um SampleAdListener
com callbacks relevantes:
Java
@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
SDKs diferentes têm formatos próprios para anúncios nativos. Um pode retornar objetos que contêm um campo "title", por exemplo, enquanto outro 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 que corresponda à 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. Veja um mapeador de anúncios de nosso exemplo de projeto de evento personalizado:
Java
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 o código do construtor mais a fundo.
Manter uma referência ao objeto de anúncio nativo mediado
O construtor aceita o parâmetro SampleNativeAd
, a classe de anúncio nativo usada pelo SDK de amostra para os anúncios nativos. O mapeador precisa de uma referência ao anúncio mediado para que ele possa 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 usa os dados de preço do anúncio mediado para definir o preço do mapeador:
Java
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 double
, enquanto
AdMob usa um String
para o mesmo recurso. O mapeador é responsável por lidar com esses tipos de conversões.
Mapear recursos de imagem
Mapear recursos de imagem é mais complicado do que mapear 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 delas também podem variar.
Para ajudar você a gerenciar esses detalhes, o SDK dos anúncios para dispositivos móveis do Google oferece a classe NativeAd.Image
. Da mesma forma que 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 para a classe SampleNativeMappedImage
do evento personalizado:
Java
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:
Java
setIcon(new SampleNativeMappedImage(ad.getAppIcon(), ad.getAppIconUri(), SampleCustomEvent.SAMPLE_SDK_IMAGE_SCALE));
Adicionar campos ao pacote de extras
Alguns SDKs mediados fornecem recursos adicionais além daqueles no
AdMob formato de anúncio nativo. A classe UnifiedNativeAdMapper
inclui um método setExtras()
que é usado para transmitir esses recursos aos
editores. A SampleNativeAdMapper
usa essas informações para o recurso "degree of awesomeness"
do SDK de amostra:
Java
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
.
AdChoices
Seu evento personalizado é responsável por fornecer um ícone de Opções de anúncios usando o
método setAdChoicesContent()
em UnifiedNativeAdMapper
. Veja um snippet de
SampleNativeAdMapper
que mostra como fornecer o ícone "Opções de anúncios":
Java
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 ocorre uma impressão ou um clique, mas apenas um SDK precisa rastrear esses eventos. Existem duas abordagens diferentes que os eventos personalizados podem usar, dependendo se o SDK mediado é compatível com o 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 fornecer 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.
UnifiedNativeAdMapper
interface 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:
Java
@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 amostra, ele pode chamar o método apropriado nesse objeto para relatar 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, é necessário substituir o rastreamento padrão de cliques e impressões
fazendo as duas chamadas a seguir no construtor da
UnifiedNativeAdMapper
:
Java
setOverrideClickHandling(true); setOverrideImpressionRecording(true);
Eventos personalizados que substituem o rastreamento de cliques e impressões precisam informar os eventos onAdClicked()
e onAdImpression()
ao SDK dos anúncios para dispositivos móveis do Google.
Para rastrear impressões e cliques, o SDK mediado provavelmente precisa de acesso às visualizações para ativar o rastreamento. O evento personalizado precisa substituir o
método trackViews()
e usá-lo para transmitir a visualização do anúncio nativo ao SDK mediado
que será rastreado. O SDK de exemplo do nosso projeto de exemplo de evento personalizado (do qual os snippets de código deste guia foram retirados) não usa essa abordagem, mas, se usasse, o código do evento personalizado ficaria assim:
Java
@Override public void trackViews(View containerView, Map<String, View> clickableAssetViews, Map<String, View> nonClickableAssetViews) { sampleAd.setNativeAdViewForTracking(containerView); }
Se o SDK mediado for compatível com o rastreamento de recursos individuais, ele poderá examinar
clickableAssetViews
para conferir 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 modificar
para liberar qualquer referência à visualização e desassociá-la do objeto do
anúncio nativo.
Encaminhar eventos de mediação ao SDK dos anúncios para dispositivos móveis do Google
Confira todos os callbacks compatíveis com a mediação nos
documentos do MediationNativeAdCallback
.
É importante que seu evento personalizado encaminhe o maior número possível desses callbacks para que seu app receba esses eventos equivalentes do SDK dos anúncios para dispositivos móveis do Google. Confira um exemplo de como usar callbacks:
Isso conclui a implementação dos eventos personalizados para anúncios nativos. O exemplo completo está disponível no GitHub (link em inglês).