Este guia mostra como usar o complemento de anúncios nativos para implementar anúncios nativos da AdMob em um app Unity, além de alguns pontos importantes a serem considerados ao longo do caminho.
Os anúncios nativos correspondem tanto à forma quanto à função da experiência do usuário na qual estão inseridos. Eles também combinam com o design visual do aplicativo do qual fazem parte. O formato de anúncios nativos da AdMob permite que os editores renderizem anúncios que estão integrados ao conteúdo. Você pode usar essa tecnologia para implementar renderizações altamente personalizadas que aproveitam ao máximo o código nativo em apps Unity.
Os anúncios nativos são exibidos usando os mesmos tipos de GameObjects com que você já
está criando seus apps e podem ser formatados para combinar com o design visual da
experiência do usuário em que eles estão. Quando um anúncio nativo é carregado, seu app recebe um objeto nativo que contém os recursos dele, e o app do Unity os exibe em vez do SDK.
Pré-requisitos
- Plug-in dos anúncios para dispositivos móveis do Google para Unity versão 7.0.0 ou mais recente.
- Leia o Guia explicativo.
- Faça o download e instale o complemento de anúncios nativos.
Carregar formatos de anúncios nativos
Os anúncios nativos são carregados usando a classe AdLoader, que tem a própria classe AdLoader.Builder para personalizá-la durante a criação. O método ForNativeAd()
configura o AdLoader para lidar com anúncios nativos.
private void RequestNativeAd() {
AdLoader adLoader = new AdLoader.Builder(INSERT_AD_UNIT_HERE)
.ForNativeAd()
.Build();
}
Registro para eventos de anúncio AdLoader
Para receber uma notificação quando um anúncio nativo for carregado ou não for carregado, adicione
delegados à classe AdLoader para os eventos listados abaixo.
OnNativeAdLoaded
Invocado quando um anúncio nativo é carregado. É necessário ter um delegado para esse evento para acessar o anúncio que foi carregado.
OnAdFailedToLoad
Invocado quando um anúncio nativo não é carregado.
Carregar o anúncio
Quando terminar de criar um AdLoader, chame o método LoadAd() para
solicitar um anúncio:
adLoader.LoadAd(new AdRequest.Builder().Build());
Agrupar a solicitação de anúncio
O snippet de código abaixo demonstra como criar um AdLoader configurado para solicitar anúncios nativos, definir delegados para carregamentos de anúncios bem-sucedidos e com falha e fazer uma solicitação de anúncio.
private void RequestNativeAd() {
AdLoader adLoader = new AdLoader.Builder(INSERT_AD_UNIT_HERE)
.ForNativeAd()
.Build();
adLoader.OnNativeAdLoaded += this.HandleNativeAdLoaded;
adLoader.OnAdFailedToLoad += this.HandleAdFailedToLoad;
adLoader.LoadAd(new AdRequest.Builder().Build());
}
Lidar com falhas nos carregamentos de anúncios
O evento OnAdFailedToLoad é do tipo EventHandle<AdFailedToLoadEventArgs>.
A análise do motivo de uma falha no carregamento do anúncio desse evento é mostrada abaixo.
private void RequestNativeAd() {
...
adLoader.OnAdFailedToLoad += this.HandleNativeAdFailedToLoad;
}
private void HandleNativeAdFailedToLoad(object sender, AdFailedToLoadEventArgs args) {
Debug.Log("Native ad failed to load: " + args.Message);
}
Exibir um anúncio nativo
Quando um anúncio nativo é carregado, o evento do anúncio correspondente é invocado. Assim, seu app é responsável por mostrar o anúncio, mas isso não precisa ser feito imediatamente.
Processar o carregamento de anúncios
O evento OnNativeAdLoaded é do tipo EventHandler<NativeAdEventArgs>. O
anúncio, encapsulado em um objeto NativeAd, pode ser recuperado de
NativeAdEventArgs, conforme mostrado:
private NativeAd nativeAd;
...
private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
Debug.Log("Native ad loaded.");
this.nativeAd = args.nativeAd;
}
Recuperar recursos de anúncios nativos
Após o carregamento dos anúncios, os recursos podem ser acessados conforme mostrado abaixo. Os recursos
gráficos são retornados como objetos Texture2D, e os recursos de texto, como
objetos string.
private bool nativeAdLoaded;
private NativeAd nativeAd;
void Update() {
...
if (this.nativeAdLoaded) {
this.nativeAdLoaded = false;
// Get Texture2D for the icon asset of native ad.
Texture2D iconTexture = this.nativeAd.GetIconTexture();
// Get string for headline asset of native ad.
string headline = this.nativeAd.GetHeadlineText();
}
}
private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
Debug.Log("Native ad loaded.");
this.nativeAd = args.nativeAd;
this.nativeAdLoaded = true;
}
Os recursos de anúncios só podem ser acessados na linha de execução principal, por exemplo,
pelo método Update() de um script do Unity. Além disso, os seguintes recursos nem sempre estão presentes e precisam ser verificados antes de serem exibidos:
GetStarRating()GetStore()GetPrice()GetAdvertiser()GetIconTexture()
Recurso de Opções de anúncios
É um requisito exibir o recurso de anúncio das Opções de anúncios como parte do anúncio nativo. Além disso, é importante que o recurso de anúncio das Opções de anúncios seja visto com facilidade. Portanto, escolha cores de plano de fundo e imagens adequadas.
Registrar GameObjects para o recurso de anúncio
Registre o GameObject para que o recurso de anúncio seja exibido no seu
app Unity. Se o registro for bem-sucedido, o método usado para registrar o
GameObject retornará um bool. Para uma List<GameObject>, o método retorna uma
int indicando a contagem de GameObject registrada.
Se ocorrer uma falha no registro do recurso de anúncio, as impressões e os cliques no anúncio nativo correspondente não serão reconhecidos.
if (!this.nativeAd.RegisterIconImageGameObject(icon))
{
// Handle failure to register the icon ad asset.
}
O GameObject registrado para um recurso de anúncio precisa ter um componente Collider
convexo que represente o tamanho e a forma do GameObject. Se os
objetos GameObject registrados nos recursos de anúncio não tiverem componentes Collider
ou tiverem um configurado incorretamente, os anúncios nativos não funcionarão corretamente.
No snippet de código abaixo, um BoxCollider é adicionado a GameObject, que usa um
TextMesh para mostrar o recurso de anúncio de título de um anúncio nativo. Depois que o
BoxCollider for anexado ao GameObject, ele será escalonado automaticamente para
acomodar o texto do componente TextMesh.
// Create GameObject that will display the headline ad asset.
GameObject headline = new GameObject();
headline.AddComponent<TextMesh>();
headline.GetComponent<TextMesh>().characterSize = 0.5 f;
headline.GetComponent<TextMesh>().anchor = TextAnchor.MiddleCenter;
headline.GetComponent<TextMesh>().color = Color.black;
// Get string of the headline asset.
string headlineText = this.nativeAd.GetHeadlineText();
headline.GetComponent<TextMesh>().text = headlineText;
// Add box collider to the GameObject which will automatically scale.
headline.AddComponent<BoxCollider>();
Demonstração
O código a seguir demonstra como recuperar o recurso de ícone de um anúncio nativo
carregado, exibir o recurso de anúncio de ícone definindo a textura de um Quad
e registrar o GameObject para mostrar o recurso. Esse processo de
recuperação e registro do recurso de anúncio com a classe de anúncio nativo precisa ser
repetido para cada um dos recursos exibidos pelo app.
private GameObject icon;
private bool nativeAdLoaded;
private NativeAd nativeAd;
...
void Update() {
...
if (this.nativeAdLoaded) {
this.nativeAdLoaded = false;
// Get Texture2D for icon asset of native ad.
Texture2D iconTexture = this.nativeAd.GetIconTexture();
icon = GameObject.CreatePrimitive(PrimitiveType.Quad);
icon.transform.position = new Vector3(1, 1, 1);
icon.transform.localScale = new Vector3(1, 1, 1);
icon.GetComponent<Renderer>().material.mainTexture = iconTexture;
// Register GameObject that will display icon asset of native ad.
if (!this.nativeAd.RegisterIconImageGameObject(icon))
{
// Handle failure to register ad asset.
}
}
}
...
private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
Debug.Log("Native ad loaded.");
this.nativeAd = args.nativeAd;
this.nativeAdLoaded = true;
}