Inizia

Nota: gli annunci nativi su Unity sono in versione beta.

Questa guida mostra come utilizzare il componente aggiuntivo degli annunci nativi per implementare gli annunci nativi AdMob in un'app Unity, nonché alcuni aspetti importanti da considerare durante il processo.

Attenzione: gli annunci nativi in Unity non supportano la mediazione o gli asset video. Consulta gli annunci in overlay nativi per conoscere un formato nativo che supporta la mediazione e gli annunci video.

Gli annunci nativi rispecchiano sia la forma che la funzione dell'esperienza utente in cui vengono posizionati. Inoltre, si adattano al design visivo dell'app in cui si trovano. Il formato degli annunci nativi di AdMob consente ai publisher di pubblicare annunci perfettamente integrati con i contenuti. che permette di implementare rendering altamente personalizzati che sfruttano al meglio il codice nativo delle app Unity.

Gli annunci nativi vengono mostrati utilizzando gli stessi tipi di GameObjects con cui stai già creando le tue app e possono essere formattati in base al design visivo dell'esperienza utente in cui vengono pubblicati. Quando un annuncio nativo viene caricato, l'app riceve un oggetto nativo che contiene i relativi asset e li visualizza l'app Unity (anziché l'SDK).

Punto chiave: scopri di più sugli annunci nativi nel nostro Playbook sugli annunci nativi. Puoi anche dare un'occhiata ad alcuni casi di successo dei clienti: case study 1, case study 2.

Prerequisiti

• Plug-in Unity di Google Mobile Ads versione 7.0.0 o successive.
• Completa la Guida introduttiva.
• Scarica e installa il componente aggiuntivo degli annunci nativi.

Carica i formati degli annunci nativi

Gli annunci nativi vengono caricati tramite la classe AdLoader, che dispone di una propria classe AdLoader.Builder per personalizzarli durante la creazione. Il metodo ForNativeAd() configura il componente AdLoader per la gestione degli annunci nativi.

private void RequestNativeAd() {
    AdLoader adLoader = new AdLoader.Builder(INSERT_AD_UNIT_HERE)
        .ForNativeAd()
        .Build();
}

Registrati per gli eventi annuncio AdLoader

Per ricevere una notifica quando un annuncio nativo viene caricato correttamente o non viene caricato, aggiungi dei delegati alla classe AdLoader per gli eventi elencati di seguito.

OnNativeAdLoaded

Richiamato quando un annuncio nativo viene caricato correttamente. Per accedere all'annuncio caricato, è necessario delegarlo per questo evento.

OnAdFailedToLoad

Richiamato quando non viene caricato un annuncio nativo.

Carica l'annuncio

Suggerimento: puoi utilizzare le chiamate al carico degli annunci per creare una cache di annunci precaricati prima di volerli mostrare, in modo che gli annunci possano essere mostrati con latenza zero quando necessario. Poiché gli annunci scadono dopo un'ora, è consigliabile svuotare la cache e ricaricare gli annunci ogni ora.

Dopo aver completato la creazione di un AdLoader, chiama il metodo LoadAd() per richiedere un annuncio:

adLoader.LoadAd(new AdRequest.Builder().Build());

Compila la richiesta di annuncio

Lo snippet di codice riportato di seguito mostra come creare un elemento AdLoader configurato per richiedere annunci nativi, imposta i delegati per i caricamenti di annunci riusciti e non riusciti ed effettua una richiesta di annuncio.

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());
}

Gestire i caricamenti degli annunci non riusciti

L'evento OnAdFailedToLoad è di tipo EventHandle<AdFailedToLoadEventArgs>. Di seguito è riportata l'analisi del motivo di un errore di caricamento dell'annuncio da questo evento.

private void RequestNativeAd() {
    ...
    adLoader.OnAdFailedToLoad += this.HandleNativeAdFailedToLoad;
}

private void HandleNativeAdFailedToLoad(object sender, AdFailedToLoadEventArgs args) {
    Debug.Log("Native ad failed to load: " + args.Message);
}

Visualizza un annuncio nativo

Quando viene caricato un annuncio nativo, viene richiamato l'evento dell'annuncio per il formato dell'annuncio corrispondente. La tua app è quindi responsabile della pubblicazione dell'annuncio, anche se non deve necessariamente farlo immediatamente.

Gestire il carico degli annunci

L'evento OnNativeAdLoaded è di tipo EventHandler<NativeAdEventArgs>. L'annuncio, incapsulato in un oggetto NativeAd, può essere recuperato da NativeAdEventArgs come mostrato di seguito:

private NativeAd nativeAd;
...
private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
    Debug.Log("Native ad loaded.");
    this.nativeAd = args.nativeAd;
}

Recupera gli asset di annunci nativi

Una volta caricati gli annunci, è possibile accedere ai relativi asset come mostrato di seguito. Gli asset grafici vengono restituiti come oggetti Texture2D, mentre gli asset di testo come oggetti 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;
}

Tieni presente che devi accedere agli asset annuncio solo nel thread principale, ad esempio dal metodo Update() di uno script Unity. Tieni inoltre presente che non è sempre garantito che i seguenti asset siano presenti e devono essere controllati prima di essere visualizzati:

• GetStarRating()
• GetStore()
• GetPrice()
• GetAdvertiser()
• GetIconTexture()

Asset Scegli Tu!

È obbligatorio visualizzare l'asset annuncio Scegli Tu! come parte dell'annuncio nativo. Inoltre, è importante che l'asset annuncio Scegli Tu! sia facilmente visibile, perciò scegli i colori e le immagini di sfondo in modo appropriato.

Registrare GameObjects per asset annuncio

Devi registrare il GameObject per l'asset annuncio da visualizzare nell'app Unity. Se la registrazione ha esito positivo, il metodo utilizzato per registrare il GameObject restituisce un bool. Per List<GameObject>, il metodo restituisce un int che indica il conteggio di GameObject registrato correttamente.

Se la registrazione di un asset annuncio non va a buon fine, le impressioni e i clic sull'annuncio nativo corrispondente non verranno riconosciuti.

if (!this.nativeAd.RegisterIconImageGameObject(icon))
{
    // Handle failure to register the icon ad asset.
}

L'elemento GameObject registrato per un asset annuncio deve avere un componente Collider convesso rappresentativo delle dimensioni e della forma di GameObject. Se GameObject di oggetti registrati negli asset annuncio non contengono componenti Collider o ne hanno uno configurato in modo errato, gli annunci nativi non funzioneranno correttamente.

Nello snippet di codice riportato di seguito, a GameObject viene aggiunto un elemento BoxCollider che utilizza TextMesh per visualizzare l'asset annuncio titolo di un annuncio nativo. Una volta che l'elemento BoxCollider viene collegato a GameObject, verrà scalato automaticamente per accogliere il testo del 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>();

Demo

Il seguente codice mostra come recuperare l'asset icona di un annuncio nativo caricato correttamente, visualizzare l'asset annuncio icona impostando la texture di un Quad e registrare il GameObject da utilizzare per visualizzare l'asset. Questo processo di recupero dell'asset annuncio e registrazione con la classe di annuncio nativo deve essere ripetuto per ciascuno degli asset visualizzati nell'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;
}