Este guia mostra como usar o complemento de anúncios nativos para implementar anúncios nativos anúncios em um app Unity, além de alguns itens importantes a serem considerados ao longo do caminho.
Os anúncios nativos correspondem à forma e à função da experiência do usuário em que estão inseridos. Eles também combinam com o design visual do aplicativo do qual fazem parte. Com o formato de anúncios nativos do Ad Manager, os editores podem renderizar anúncios que combinam com o conteúdo. Você pode usar essa tecnologia para implementar renderizações altamente personalizadas que aproveitam ao máximo o código nativo em apps do Unity.
Os anúncios nativos são exibidos usando os mesmos tipos de GameObjects
que você
já estão criando seus apps e podem ser formatados para combinar com o design visual do
a experiência do usuário em que ele vive. Quando um anúncio nativo é carregado, seu aplicativo
recebe um objeto nativo que contém os recursos dele e o app Unity, em vez de
e o SDK os exibe.
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.
- Fazer o download e instalar 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
AdLoader.Builder
para personalizá-la durante a criação. O 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
delega para a classe AdLoader
para os eventos listados abaixo.
OnNativeAdLoaded
Invocado quando um anúncio nativo é carregado. É necessário ter um delegar 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());
Reunir a solicitação de anúncio
O snippet de código abaixo demonstra como criar um AdLoader
que seja
configurado para solicitar anúncios nativos, defina delegados para carregamentos de anúncios
bem-sucedidos e com falha e faça 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);
}
Mostrar um anúncio nativo
Quando um anúncio nativo é carregado, o evento de anúncio correspondente é invocado. Seu app é responsável por exibir o anúncio, embora não precisam fazer isso 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 são retornados 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 conversa principal, por exemplo,
do método Update()
de um script do Unity. Os recursos a seguir são
não há garantia de que estarão presentes, e eles devem ser verificados antes de serem
exibido:
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 "Opções de anúncios" seja facilmente visualizado. Portanto, as cores de fundo e as imagens apropriadas.
Registrar GameObjects para recursos de anúncios
É necessário registrar o GameObject
para que o recurso de anúncio seja exibido no
app Unity. Se o registro for bem-sucedido, o método usado para registrar o
GameObject
vai retornar um bool
. Para uma List<GameObject>
, o método retorna uma
int
indicando a contagem de GameObject
registrada.
Se o registro de um recurso de anúncio não for bem-sucedido, as impressões e os cliques no o anúncio nativo correspondente não será reconhecido.
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 de colisor convexo
que represente o tamanho e a forma do GameObject
. Se
Objetos GameObject
registrados nos recursos de anúncios não têm componentes Collider
ou tiverem um configurado incorretamente, os anúncios nativos não funcionarão corretamente.
No snippet de código abaixo, uma BoxCollider
é adicionada a GameObject
, que usa um
TextMesh
para mostrar o recurso de anúncio principal de um anúncio nativo. Quando o
BoxCollider
for anexado ao GameObject
, ele será dimensionado 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 ativo de ícone de um com sucesso
anúncio nativo carregado, exiba o recurso de anúncio de ícone definindo a textura de um Quad
,
e registrar o GameObject
a ser usado para exibir o recurso. Esse processo de
a recuperação do recurso e o registro dele com a classe de anúncio nativo precisa ser
repetido para cada um dos recursos exibidos pelo aplicativo.
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;
}