Cette page a été traduite par l'API Cloud Translation.

Créer des événements personnalisés

Les événements personnalisés permettent aux éditeurs utilisant AdMob afin d'ajouter une médiation en cascade pour un réseau publicitaire tiers autre que celui parmi les réseaux publicitaires compatibles. Ce guide explique comment utiliser un événement personnalisé existant conçu pour Android et iOS dans un projet Unity.

Prérequis

Suivez la procédure Commencer. Votre unité le plug-in Google Mobile Ads Unity doit déjà être importé dans votre application.
Des adaptateurs d'événements personnalisés déjà conçus pour Android et iOS. Pour créer des adaptateurs d'événements personnalisés, consultez nos guides sur les événements personnalisés Android et iOS

Définir un événement personnalisé

Pour qu'un événement personnalisé participe à la médiation, il doit : être défini dans l' AdMob interface Web. Ajoutez un un événement personnalisé à vos deux les groupes de médiation Android et iOS.

Cette capture d'écran montre quelques exemples de paramètres d'événements personnalisés:

Comment renseigner les paramètres
Nom du cours (iOS)	Pour iOS, saisissez le nom de la classe qui implémente l'événement personnalisé. Si votre classe est implémentée en Swift, vous devez ajouter le préfixe le nom de son application / module de framework (par exemple, `appName.className`). Le nom de la cible est obligatoire si votre projet comporte plusieurs cibles ou si le nom du projet est différent du nom de la cible. Avec le nom de la cible, ressemblerait à ceci: `appName_targetName.className`. De plus, n'oubliez pas de remplacer tous les caractères non alphanumériques tels que les tirets par et des traits de soulignement.
Nom du cours (Android)	Pour Android, assurez-vous que la valeur indiquée pour `Class Name` est Nom de classe complet pour Android (par exemple, `com.google.ads.mediation.sample.customevent.SampleCustomEvent`)
Libellé	Saisissez un nom unique pour l'événement.
Paramètre	Si vous souhaitez transmettre un argument de chaîne à votre événement personnalisé, par exemple l'ID du bloc d'annonces.

Importer des bibliothèques d'événements personnalisés

Les événements personnalisés peuvent nécessiter l'ajout de bibliothèques supplémentaires pour fonctionner correctement. Par exemple, vous devrez peut-être inclure les bibliothèques suivantes:

SDK tiers Android
Événement personnalisé tiers Android
SDK publicitaire tiers iOS
Événement personnalisé tiers iOS

Types de bibliothèques

Il existe plusieurs façons d'importer du code Android ou iOS dans un projet Unity, y compris:

Importer des artefacts Android ou iOS prédéfinis à l'aide de la dépendance externe Gestionnaire pour Unity
Importer des plug-ins AAR et des bibliothèques Android
Importer des fichiers sources Java et Kotlin
Importer des fichiers sources iOS et des bibliothèques statiques

Selon la manière dont les bibliothèques que vous utilisez sont empaquetées, vous aurez peut-être besoin d'un une stratégie d'importation pour chaque bibliothèque. Chaque option est abordée plus en détail ultérieurement.

(Recommandé) Importer des artefacts Android ou iOS prédéfinis

Importez des artefacts prédéfinis à partir de Maven ou de CocoaPods à l'aide de la classe External Gestionnaire de dépendances pour Unity Ce plug-in est inclus avec le plug-in GoogleMobileAds.

Pour importer des artefacts existants, créez un fichier de configuration afin de définir votre des importations. Le nom de fichier et le chemin d'accès présentent les exigences suivantes:

Le fichier doit exister dans le dossier /Editor/.
Le nom de fichier doit se terminer par Dependencies.xml.

Par exemple, pour importer des adaptateurs d'événements personnalisés pour un réseau publicitaire fictif nommé AdPub, créez le fichier:

Assets/AdPub/Editor/AdPubDependencies.xml

Ensuite, définissez vos dépendances dans le fichier AdPubDependencies.xml. Règles de configuration des importations est disponible à l'adresse Obtention du gestionnaire de dépendances externes pour Unity Début. La L'extrait de code suivant inclut les SDK Android et iOS, ainsi que l'événement personnalisé pour un "AdPub" fictif de votre réseau publicitaire.

`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>

Si votre artefact d'événement personnalisé dépend déjà de l'annonce requise réseau SDK, vous n'avez pas besoin de définir explicitement la dépendance SDK: Exemple

Le gestionnaire de dépendances externe surveille automatiquement les modifications de configuration et résout les dépendances. Vous pouvez également effectuer une résolution manuelle à l'aide de la commande de menu suivante:

Assets > External Dependency Manager > Android Resolver > Force Resolve

Importer des plug-ins AAR et des bibliothèques Android

Unity prend en charge l'importation de fichiers *.aar ainsi que de projets de bibliothèque Android. Si votre événement personnalisé Android est empaqueté de cette façon. Consultez la section Plug-ins AAR et bibliothèques pour obtenir des instructions comment les inclure dans votre projet Unity.

Importer des fichiers sources Java et Kotlin

À partir de Unity 2018.2 ou version ultérieure, si le code d'événement personnalisé Android comprend de fichiers *.java ou *.kt non compilés, vous pouvez utiliser des fichiers sources Java ou Kotlin en tant que plug-ins.

Importer des fichiers sources iOS et des bibliothèques statiques

Unity accepte les artefacts *.framework, ainsi que les fichiers sources *.h et *.m. Importation... Pour en savoir plus sur les artefacts iOS et les fichiers sources, consultez le guide Unity plug-ins.

Tester des événements personnalisés avec l'inspecteur d'annonces

L'inspecteur d'annonces permet de tester que les événements personnalisés ont été correctement importés dans votre application. Annonce l'outil d'inspection peut être ouvert avec des gestes seulement ou programmatique avec un minimum de code.

(Facultatif) Appeler des méthodes natives de SDK tiers à partir de scripts C#

Les SDK de réseaux publicitaires tiers peuvent avoir des exigences spéciales qui nécessitent appelant directement des méthodes Android ou iOS. Le processus d'appel de ces méthodes sont les suivantes:

Définir une interface commune pour les clients de la plate-forme
Implémenter un client par défaut pour les plates-formes non compatibles
Implémenter un client Android pour appeler des méthodes Android
Implémenter un client iOS pour appeler des méthodes iOS
Implémentez un client d'usine pour qu'elle utilise basculer entre les clients iOS et Android
Définir une API permettant d'accéder à toutes les fonctionnalités du SDK de réseau publicitaire tiers

La section suivante montre comment ces étapes sont mises en œuvre pour un scénario le réseau publicitaire "AdPub" dans une API C# pouvant appeler les méthodes sur Android et iOS:

Android

package com.adpub.android;

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

iOS

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

Définir une interface commune pour les clients de la plate-forme

Créez une interface IAdPubClient avec une méthode qui représente l'instance API Android et 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);
    }
}

Définir un client par défaut pour les plates-formes non compatibles

Créez une classe DefaultClient pour implémenter l'interface IAdPubClient qui enregistre simplement le nom de la méthode. Utilisez cette implémentation pour l'éditeur Unity et tous plates-formes autres qu'Android ou iOS.

`Assets/AdPub/Common/DefaultClient.cs`

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

Implémenter un client de plate-forme iOS

Créez une classe iOSAdPubClient pour implémenter l'interface IAdPubClient sur iOS Cette implémentation utilise InteropServices à appeler la méthode setHasUserConsent() dans la classe iOS AdPubSdk.

`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

Implémentez ensuite la méthode GADUAdPubSetHasUserConsent() définie. ci-dessus. Créer AdPubClientBridge.m avec une méthode C GADUAdPubSetHasUserConsent() pour gérer l'appel de méthode depuis Unity et appeler AdPubSDK.

AdPubClientBridge est un fichier source iOS qui doit être placé à l'intérieur de Plugins/iOS, comme expliqué dans le guide d'Unity sur les annonces natives plug-ins.

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

#import <AdPubSDK/AdPubSDK.h>

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

Implémenter un client de plate-forme Android

Créez une classe AndroidAdPubCient pour implémenter l'interface IAdPubClient sur Android Cette mise en œuvre utilise l' outil d'aide Java pour Android cours pour appeler la méthode statique Android setHasUserConsent().

Étant donné que les classes d'assistance Java pour Android ne sont disponibles que pendant la phase vous pouvez éviter les erreurs de compilation à l'aide du compilateur UNITY_ANDROID. d'entrée pour encapsuler la classe, comme indiqué dans l'extrait de code. Vous pouvez également utiliser la méthode Assembly définitions sur Unity 2017.4 et versions ultérieures pour résoudre ce problème.

`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

Créer une méthode de fabrique pour renvoyer la bonne implémentation du client

Maintenant que vous disposez d'implémentations du client pour chaque plate-forme, créez une AdPubClientFactory pour renvoyer l'implémentation correcte de IAdPubClient en fonction de la plate-forme d'exécution. Ce cours utilise compilateur d'instructions pour renvoyer le bon client IAdPubClient.

`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
        }
    }
}

Définir une API publique pour chaque méthode d'interface

Créez une classe AdPubApi contenant des appels de méthode pour chaque méthode cliente de votre IAdPubClient. Cette classe utilise AdPubClientFactory pour obtenir une instance de IAdPubClient et appelle ce client pour le SDK sous-jacent de Google Cloud.

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

Appeler l'API que vous venez de définir

Voici comment appeler l'API définie ci-dessus:

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

Autres exemples d'adaptateurs de réseau publicitaire tiers

Accédez à l'interface GitHub du plug-in Google Mobile Ads pour Unity. dépôt pour obtenir des exemples supplémentaires d'adaptateurs de médiation tiers qui implémentent des API C# pour encapsuler les appels vers des méthodes iOS et Android.