Questa pagina è stata tradotta dall'API Cloud Translation.

Crea eventi personalizzati

Gli eventi personalizzati consentono ai publisher di utilizzare AdMob per aggiungere la mediazione a cascata per una rete pubblicitaria di terze parti diversa delle reti pubblicitarie supportate. Questa guida spiega come utilizzare un evento personalizzato esistente creato per Android e iOS in un progetto Unity.

Prerequisiti

Completa la sezione Inizia. La tua unione deve avere già importato il plug-in Unity di Google Mobile Ads.
Adattatori eventi personalizzati già creati per Android e iOS. Per creare modelli adattatori di eventi, consulta le nostre guide agli eventi personalizzati Android e iOS.

Definisci un evento personalizzato

Affinché un evento personalizzato possa partecipare alla mediazione, l'evento personalizzato deve essere definiti nell' AdMob interfaccia web. Aggiungi un personalizzato a entrambi Gruppi di mediazione per Android e iOS.

Questo screenshot mostra alcuni esempi di impostazioni degli eventi personalizzati:

Come compilare i parametri
Nome del corso (iOS)	Per iOS, inserisci il nome della classe che implementa l'evento personalizzato. Se la tua classe è implementata in Swift, devi anteporre al nome della classe il prefisso il nome del relativo modulo app / framework (ad esempio, `appName.className`). Il nome destinazione è obbligatorio se hai più destinazioni nel progetto o se il nome del progetto sia diverso da quello della destinazione. Con il nome della destinazione, sarebbe simile a questo: `appName_targetName.className`. Inoltre, ricordati di sostituire i caratteri non alfanumerici, come i trattini, trattini bassi.
Nome corso (Android)	Per Android, assicurati che il valore assegnato per `Class Name` sia il nome completo della classe per Android (ad esempio `com.google.ads.mediation.sample.customevent.SampleCustomEvent`).
Etichetta	Inserisci un nome univoco per l'evento.
Parametro	Se vuoi passare un argomento stringa al tuo evento personalizzato, ad esempio un l'ID unità pubblicitaria.

Importa librerie di eventi personalizzati

Gli eventi personalizzati potrebbero richiedere l'inclusione di librerie aggiuntive per funzionare correttamente. Ad esempio, potresti dover includere le seguenti librerie:

SDK di terze parti per Android
Evento personalizzato di terze parti per Android
SDK annunci di terze parti per iOS
Evento personalizzato di terze parti per iOS

Tipi di librerie

Esistono diversi modi per importare codice Android o iOS in un progetto Unity. tra cui:

Importazione di elementi predefiniti di Android o iOS utilizzando la dipendenza esterna Gestore per Unity
Importazione di plug-in AAR e librerie Android
Importazione di file sorgente Java e Kotlin
Importazione di file di origine e librerie statiche di iOS

A seconda di come le librerie che utilizzi sono pacchettizzate, potrebbe essere necessaria una strategia di importazione per ogni libreria. Ogni opzione verrà discussa più in dettaglio più avanti.

(Consigliato) Importare elementi predefiniti di Android o iOS

Importa artefatti predefiniti da Maven o CocoaPods utilizzando il Gestore delle dipendenze per Unity. Questo plug-in è incluso nel plug-in GoogleMobileAds.

Per importare gli artefatti esistenti, crea un file di configurazione per definire e le importazioni. Il nome file e il percorso presentano i seguenti requisiti:

Il file deve esistere nella cartella /Editor/.
Il nome del file deve terminare con Dependencies.xml.

Ad esempio, per importare gli adattatori degli eventi personalizzati per una rete pubblicitaria ipotetica denominato AdPub, crea il file:

Assets/AdPub/Editor/AdPubDependencies.xml

A questo punto, definisci le dipendenze all'interno del file AdPubDependencies.xml. Regole per configurare le importazioni è disponibile all'indirizzo Gestore delle dipendenze esterno per la generazione di Unity Iniziata. La il seguente snippet di codice include l'SDK per Android e iOS e l'evento personalizzato librerie per un ipotetico "AdPub" rete pubblicitaria.

`Assets/AdPub/Editor/AdPubDependencies.xml`

<dependencies>
  <androidPackages>
    <androidPackage spec="com.adpub.android:adpub-sdk:1.0.0" />
    <androidPackage spec="com.adpub.android:adpub-custom-event:1.0.0">
      <repositories>
        <repository>https://repo.maven.apache.org/maven2/</repository>
        <repository>https://dl.google.com/dl/android/maven2/</repository>
      </repositories>
    </androidPackage>
  </androidPackages>
  <iosPods>
    <iosPod name="AdPubSDK" version="1.0" />
    <iosPod name="AdPubCustomEvent" version="1.0">
      <sources>
        <source>https://github.com/CocoaPods/Specs</source>
      </sources>
    </iosPod>
  </iosPods>
</dependencies>

Se l'artefatto dell'evento personalizzato ha già una dipendenza sull'annuncio richiesto SDK di rete, non devi definire esplicitamente la dipendenza dall'SDK: Esempio

Il gestore di dipendenze esterno monitora automaticamente le modifiche alla configurazione e risolve le dipendenze. Puoi anche eseguire la risoluzione manuale con seguente comando di menu:

Assets > External Dependency Manager > Android Resolver > Force Resolve

Importa plug-in AAR e librerie Android

Unity supporta l'importazione di file *.aar e di progetti della libreria Android. Se l'evento personalizzato Android viene pacchettizzato in questo modo; consulta l'articolo su plug-in AAR e Android Librerie per istruzioni su come includere questi file nel tuo progetto Unity.

Importa file sorgente Java e Kotlin

A partire da Unity 2018.2 o versioni successive, se il tuo codice evento personalizzato di Android comprende di file *.java o *.kt non compilati, puoi utilizzare file di origine Java o Kotlin come plug-in.

Importa file di origine e librerie statiche di iOS

Unity supporta gli artefatti *.framework, *.h e file di origine *.m. In fase di importazione Gli elementi e i file sorgente di iOS sono descritti nella guida di Unity per gli strumenti nativi plug-in.

Testare gli eventi personalizzati con lo strumento di controllo degli annunci

Lo strumento di controllo degli annunci può essere usato per testare per verificare che gli eventi personalizzati siano stati importati correttamente nella tua applicazione. Annuncio inspector può essere aperto con solo gesti o in modo programmatico con un codice minimo.

(Facoltativo) Chiamare metodi nativi SDK di terze parti dagli script C#

Gli SDK delle reti pubblicitarie di terze parti potrebbero avere requisiti speciali che richiedono chiamare direttamente i metodi Android o iOS. La procedura per chiamare questi metodi sono i seguenti:

Definisci un'interfaccia comune per i client della piattaforma
Implementare un client predefinito per le piattaforme non supportate
Implementare un client Android per chiamare metodi Android
Implementare un client iOS per chiamare metodi iOS
Implementa un client fabbrica a condizione passare da un client iOS a un client Android e viceversa
Definire un'API per accedere a tutte le funzionalità dell'SDK delle reti pubblicitarie di terze parti

La seguente sezione mostra come vengono implementati questi passaggi per un modello ipotetico una rete pubblicitaria denominata "AdPub" in un'API C# che può chiamare i metodi su Android e iOS:

Android

package com.adpub.android;

public class AdPubSdk
{
    public static void setHasUserConsent(boolean hasUserConsent);
}

iOS

@interface AdPubSdk : NSObject
+ (void)setHasUserConsent:(BOOL)hasUserConsent;
@end

Definisci un'interfaccia comune per i client della piattaforma

Crea un'interfaccia IAdPubClient con un metodo che rappresenta la parte sottostante API per Android e iOS.

`Assets/AdPub/Common/IAdPubClient.cs`

namespace AdPub.Common
{
    public interface IAdPubClient
    {
        ///<summary>
        /// Sets a flag indicating if the app has user consent for advertisement.
        ///</summary>
        void SetHasUserConsent(bool hasUserConsent);
    }
}

Definisci un client predefinito per le piattaforme non supportate

Crea un corso DefaultClient implementando l'interfaccia IAdPubClient che registra solo il nome del metodo. Utilizza questa implementazione per l'editor Unity e per tutti piattaforme diverse da Android o iOS.

`Assets/AdPub/Common/DefaultClient.cs`

namespace AdPub.Common
{
    public class DefaultClient : IAdPubClient
    {
        public void SetHasUserConsent(bool hasUserConsent)
        {
            Debug.Log("SetHasUserConsent was called.");
        }
    }
}

Implementare un client della piattaforma iOS

Crea un corso iOSAdPubClient implementando l'interfaccia IAdPubClient su iOS. Questa implementazione utilizza InteropServices per chiamare il metodo setHasUserConsent() nella classe AdPubSdk per iOS.

`Assets/AdPub/Platforms/iOS/iOSAdPubClient.cs`

// Wrap this class in a conditional operator to make sure it only runs on iOS.
#if UNITY_IOS

// Reference InteropServices to include the DLLImportAttribute type.
using System.Runtime.InteropServices;

using AdPub.Common;

namespace AdPub.Platforms.Android
{
    public class iOSAdPubClient : IAdPubClient
    {
        public void SetHasUserConsent(bool hasUserConsent)
        {
            GADUAdPubSetHasUserConsent(hasUserConsent);
        }

        [DllImport("__Internal")]
        internal static extern void GADUAdPubSetHasUserConsent(bool hasUserConsent);
    }
}
#endif

Successivamente, implementa il metodo GADUAdPubSetHasUserConsent() che è stato definito in alto. Crea AdPubClientBridge.m con un metodo C GADUAdPubSetHasUserConsent() per gestire la chiamata al metodo da Unity e richiamare AdPubSDK.

AdPubClientBridge è un file di origine iOS e deve essere posizionato all'interno dell'elemento Plugins/iOS come spiegato nella guida di Unity per gli annunci nativi plug-in.

`Assets/AdPub/Plugins/iOS/AdPubClientBridge.m`

#import <AdPubSDK/AdPubSDK.h>

void GADUAdPubSetHasUserConsent(BOOL hasUserConsent) {
  [AdPubSDK setHasUserConsent:hasUserConsent];
}

Implementare un client della piattaforma Android

Crea un corso AndroidAdPubCient implementando l'interfaccia IAdPubClient su Android. Questa implementazione utilizza l' helper Java per Android corsi per chiamare il metodo statico di Android setHasUserConsent().

Poiché le classi helper Java per Android sono disponibili solo durante la runtime, puoi evitare errori di compilazione utilizzando il compilatore UNITY_ANDROID istruzione per aggregare la classe come mostrato nello snippet di codice. In alternativa, puoi usare Assembly definizioni su Unity 2017.4 e versioni successive per risolvere il problema.

`Assets/AdPub/Platforms/Android/AndroidAdPubClient.cs`

// Wrap this class in a conditional operator to make sure it only runs on Android.
#if UNITY_ANDROID

// Reference the UnityEngine namespace which contains the JNI Helper classes.
using UnityEngine;

using AdPub.Common;

namespace AdPub.Platforms.Android
{
    public class AndroidAdPubClient : IAdPubClient
    {
        public void SetHasUserConsent(bool hasUserConsent)
        {
             // Make a reference to the com.adpub.AdPubSDK.
            AndroidJavaClass adPubSdk = new AndroidJavaClass("com.adpub.AdPubSdk");

            // Call the native setHasUserConsent method of com.adpub.AdPubSDK.
            adPubSdk.CallStatic("setHasUserConsent", hasUserConsent);
        }
    }
}
#endif

Crea un metodo di fabbrica per restituire l'implementazione corretta del client

Ora che hai le implementazioni del client per ogni piattaforma, crea un AdPubClientFactory per restituire la corretta implementazione della IAdPubClient a seconda della piattaforma di runtime. Questo corso utilizza compilatore su restituire il client IAdPubClient corretto.

`Assets/AdPub/Common/AdPubClientFactory.cs`

namespace AdPub.Common
{
    public class AdPubClientFactory
    {
        // Return the correct platform client.
        public static IAdPubClient GetClient()
        {
#if   !UNITY_EDITOR && UNITY_ANDROID
            return new AdPub.Platforms.Android.AndroidAdPubClient();
#elif !UNITY_EDITOR && UNITY_IOS
            return new AdPub.Platforms.iOS.iOSAdPubClient();
#else
            // Returned for the Unity Editor and unsupported platforms.
            return new DefaultClient();
#endif
        }
    }
}

Definire un'API pubblica per ogni metodo di interfaccia

Crea una classe AdPubApi che contenga chiamate di metodi per ciascun metodo client in IAdPubClient. Questo corso utilizza AdPubClientFactory per ricevere dell'istanza di IAdPubClient e chiama quel client per l'SDK sottostante le funzionalità di machine learning.

`Assets/AdPub/AdPubApi.cs`

using AdPub.Common;

namespace AdPub
{
    public class AdPubApi
    {
        private static readonly IAdPubClient client = GetAdPubClient();

        // Returns the correct client for the current runtime platform.
        private static IAdPubClient GetAdPubClient()
        {
            return AdPubClientFactory.GetClient();
        }

        // Sets the user consent using the underlying SDK functionality.
        public static void SetHasUserConsent(bool hasUserConsent)
        {
            client.SetHasUserConsent(hasUserConsent);
        }
    }
}

Chiama l'API appena definita

Ecco come chiamare l'API definita sopra:

`Assets/Scripts/AdPubController.cs`

using UnityEngine;
using AdPub;

public class AdPubController : MonoBehaviour
{
    // TODO: Get consent from the user and update this userConsent field.
    public bool userConsent;

    // Called on startup of the GameObject it's assigned to.
    public void Start()
    {
        // Pass the user consent to AdPub.
        AdPubApi.SetHasUserConsent(userConsent);
    }
}

Altri esempi di adattatori di rete pubblicitaria di terze parti

Visita il plug-in Unity di Google Mobile Ads di archiviazione per altri esempi di adattatori di mediazione di terze parti che implementano le API C# per eseguire il wrapping delle chiamate ai metodi iOS e Android.