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 qui utilisent la médiation AdMobd'ajouter une médiation en cascade pour un réseau publicitaire tiers qui ne fait pas partie des réseaux publicitaires compatibles. Ce guide explique comment utiliser un événement personnalisé existant créé pour Android et iOS dans un projet Unity.

Conditions préalables

Suivez les instructions de la section Premiers pas. Le plug-in Google Mobile Ads Unity doit déjà être importé dans votre application Unity.
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 des événements personnalisés surAndroid etiOS.

Définir un événement personnalisé

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

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

Comment renseigner les paramètres
Nom de classe (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 un préfixe à son nom avec le nom de son application ou module de framework (par exemple, `appName.className`). Veuillez indiquer un nom de cible 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, les données se présenteraient comme suit: `appName_targetName.className`. En outre, n'oubliez pas de remplacer tous les caractères non alphanumériques, tels que les tirets, par des traits de soulignement.
Nom de classe (Android)	Pour Android, assurez-vous que la valeur que vous attribuez à `Class Name` correspond au nom complet de la classe Android (par exemple, `com.google.ads.mediation.sample.customevent.SampleCustomEvent`).
Libellé	Saisissez un nom unique pour l'événement.
Paramètres	Si vous souhaitez transmettre un argument de chaîne à votre événement personnalisé, par exemple un ID de 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 tiers personnalisé Android
SDK publicitaire tiers iOS
Événement tiers personnalisé iOS

Types de bibliothèques

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

Importer des artefacts Android ou iOS prédéfinis à l'aide du gestionnaire de dépendances externes 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 le package des bibliothèques que vous utilisez, vous aurez peut-être besoin d'une stratégie d'importation différente 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 (recommandé)

Importez des artefacts prédéfinis à partir de Maven ou de CocoaPods à l'aide du gestionnaire de dépendances externes pour Unity. Ce plug-in est inclus dans le plug-in GoogleMobileAds.

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

Le fichier doit se trouver dans le dossier /Editor/.
Le nom du fichier doit se terminer par Dependencies.xml.

Par exemple, pour importer les adaptateurs d'événement personnalisé 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. Les règles de configuration des importations sont disponibles sur la page External Dependency Manager for Unity Getting Started (Gestionnaire de dépendances externes pour Unity Getting Started). L'extrait de code suivant inclut les SDK Android et iOS, ainsi que les bibliothèques d'événements personnalisés pour un réseau publicitaire "AdPub" fictif.

`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é a déjà une dépendance sur le SDK de réseau publicitaire requis, vous n'avez pas besoin de définir explicitement la dépendance du SDK : Exemple

Le gestionnaire de dépendances externes surveille automatiquement les modifications de configuration et résout les dépendances. Vous pouvez également exécuter la 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 permet d'importer des fichiers *.aar ainsi que des projets de bibliothèque Android. Si votre événement personnalisé Android est empaqueté de cette manière, consultez Plug-ins AAR et bibliothèques Android pour savoir comment inclure ces fichiers dans votre projet Unity.

Importer des fichiers sources Java et Kotlin

À partir de la version 2018.2 d'Unity, si votre code d'événement personnalisé Android comprend des 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. L'importation d'artefacts et de fichiers sources iOS est expliquée dans le guide Unity sur les plug-ins natifs.

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

L'inspecteur d'annonces permet de vérifier que les événements personnalisés ont bien été importés dans votre application. L'inspecteur d'annonces peut s'ouvrir à l'aide de gestes ou de manière automatisée 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 d'appeler directement des méthodes Android ou iOS. Pour appeler directement ces méthodes, procédez comme suit:

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 une usine cliente pour basculer de manière conditionnelle entre les clients iOS et Android.
Définir une API pour accéder à toutes les fonctionnalités du SDK des réseaux publicitaires tiers

La section suivante montre comment ces étapes sont implémentées pour un réseau publicitaire fictif appelé "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'API Android et iOS sous-jacente.

`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 implémentant l'interface IAdPubClient qui enregistre simplement le nom de la méthode. Utilisez cette implémentation pour l'éditeur Unity et toutes les 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 implémentant l'interface IAdPubClient sur iOS. Cette implémentation utilise InteropServices pour 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éez AdPubClientBridge.m avec une méthode C GADUAdPubSetHasUserConsent() pour gérer l'appel de méthode depuis Unity, puis appelez AdPubSDK.

AdPubClientBridge est un fichier source iOS et doit être placé dans le dossier Plugins/iOS, comme expliqué dans le guide Unity sur les plug-ins natifs.

`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 implémentant l'interface IAdPubClient sur Android. Cette implémentation utilise les classes d'assistance Android Java pour appeler la méthode statique Android setHasUserConsent().

Comme les classes d'assistance Java pour Android ne sont disponibles que pendant l'environnement d'exécution Android, vous pouvez éviter les erreurs de compilation à l'aide de la directive du compilateur UNITY_ANDROID pour encapsuler la classe, comme indiqué dans l'extrait de code. Vous pouvez également utiliser les définitions Assembly 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 client

Maintenant que vous disposez d'implémentations du client pour chaque plate-forme, créez une classe AdPubClientFactory pour renvoyer l'implémentation correcte de l'interface IAdPubClient en fonction de la plate-forme d'exécution. Cette classe utilise des instructions de compilation pour renvoyer le client IAdPubClient approprié.

`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 comportant des appels de méthode pour chaque méthode client dans l'interface IAdPubClient. Cette classe utilise AdPubClientFactory pour obtenir une instance de IAdPubClient et appelle ce client pour obtenir les fonctionnalités du SDK sous-jacentes.

`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éseaux publicitaires tiers

Accédez au dépôt GitHub du plug-in Google Mobile Ads Unity pour obtenir d'autres exemples d'adaptateurs de médiation tiers implémentant des API C# pour encapsuler les appels aux méthodes iOS et Android.