Se usó la API de Cloud Translation para traducir esta página.

Cómo crear eventos personalizados

Los eventos personalizados permiten a los publicadores que usan la mediación AdMobagregar la mediación en cascada para una red de publicidad de terceros que no sea una de las redes de publicidad admitidas. En esta guía, se explica cómo usar un evento personalizado existente compilado para iOS y Android en un proyecto de Unity.

Requisitos previos

Completa el curso Comenzar. Tu app de Unity ya debería tener importado el complemento de Google Mobile Ads para Unity.
Adaptadores de eventos personalizados ya compilados para iOS y Android. Para crear adaptadores de eventos personalizados, consulta nuestras guías de eventos personalizados en Android y iOS.

Cómo definir un evento personalizado

Para que un evento personalizado participe en la mediación, este debe definirse en la AdMob interfaz web. Agrega un evento personalizado a tus grupos de mediación de iOS y Android.

En esta captura de pantalla, se muestran algunos ejemplos de configuraciones de eventos personalizados:

Cómo completar los parámetros
Nombre de la clase (iOS)	En iOS, ingresa el nombre de la clase que implementa el evento personalizado. Si tu clase está implementada en Swift, debes anteponer el nombre de la clase con el nombre de su módulo de app o framework (por ejemplo, `appName.className`). El nombre del destino es obligatorio si tienes varios destinos en tu proyecto o si el nombre del proyecto es diferente del nombre. Con el nombre de destino, se vería de la siguiente manera: `appName_targetName.className`. Además, recuerda reemplazar los caracteres que no sean alfanuméricos, como los guiones por guiones bajos.
Nombre de la clase (Android)	En Android, asegúrate de que el valor que proporcionas para `Class Name` sea el nombre de clase completamente calificado para Android (por ejemplo, `com.google.ads.mediation.sample.customevent.SampleCustomEvent`).
Etiqueta	Ingresa un nombre único para el evento.
Parámetro	Si deseas pasar un argumento de cadena a tu evento personalizado, por ejemplo, un ID de unidad de anuncios.

Importa bibliotecas de eventos personalizados

Es posible que los eventos personalizados requieran que se incluyan bibliotecas adicionales para funcionar correctamente. Por ejemplo, es posible que debas incluir las siguientes bibliotecas:

SDK de terceros de Android
Evento personalizado de terceros de Android
SDK de anuncios de terceros para iOS
Evento personalizado de terceros para iOS

Tipos de bibliotecas

Existen varias formas de importar código de Android o iOS a un proyecto de Unity, incluidas las siguientes:

Cómo importar artefactos de Android o iOS compilados previamente con External Dependency Manager para Unity
Cómo importar complementos de AAR y bibliotecas de Android
Cómo importar archivos fuente Java y Kotlin
Importa archivos de origen de iOS y bibliotecas estáticas

Según cómo estén empaquetadas las bibliotecas que utilices, es posible que necesites una estrategia de importación diferente para cada biblioteca. Más adelante, analizaremos cada opción con más detalle.

Importa artefactos de Android o iOS compilados previamente (recomendado)

Importa artefactos compilados previamente desde Maven o CocoaPods con External Dependency Manager for Unity. Este complemento se incluye con el complemento de GoogleMobileAds.

Si quieres importar artefactos existentes, crea un archivo de configuración para definir las importaciones. El nombre de archivo y la ruta deben cumplir con los siguientes requisitos:

El archivo debe existir en la carpeta /Editor/.
El nombre del archivo debe terminar con Dependencies.xml.

Por ejemplo, si deseas importar adaptadores de eventos personalizados para una red de publicidad hipotética llamada AdPub, crea el archivo:

Assets/AdPub/Editor/AdPubDependencies.xml

A continuación, define tus dependencias dentro del archivo AdPubDependencies.xml. Puedes encontrar las reglas para configurar las importaciones en External Dependency Manager for Unity Getting Started. El siguiente fragmento de código incluye el SDK de iOS y Android, y bibliotecas de eventos personalizados para una red de publicidad hipotética "AdPub".

`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 tu artefacto de evento personalizado ya tiene una dependencia en el SDK de red de publicidad requerido, no necesitas definir la dependencia del SDK de forma explícita: Ejemplo

External Dependency Manager supervisa automáticamente los cambios de configuración y resuelve las dependencias. También puedes ejecutar la resolución manual con el siguiente comando del menú:

Assets > External Dependency Manager > Android Resolver > Force Resolve

Importa complementos de AAR y bibliotecas de Android

Unity admite la importación de archivos *.aar y proyectos de biblioteca de Android. Si tu evento personalizado de Android se empaqueta de esta manera, consulta Complementos de AAR y bibliotecas de Android para obtener instrucciones sobre cómo incluir esos archivos en tu proyecto de Unity.

Cómo importar archivos fuente Java y Kotlin

A partir de Unity 2018.2 o versiones posteriores, si tu código de evento personalizado de Android consta de archivos *.java o *.kt sin compilar, puedes usar archivos fuente Java o Kotlin como complementos.

Importa archivos de origen de iOS y bibliotecas estáticas

Unity admite artefactos *.framework, *.h y archivos de origen *.m. La importación de artefactos y archivos de origen de iOS se explica en la guía de Unity para complementos nativos.

Cómo probar eventos personalizados con el inspector de anuncios

El Inspector de anuncios puede usarse para probar que los eventos personalizados se hayan importado correctamente a tu aplicación. El inspector de anuncios se puede abrir con solo gestos o de manera programática con una cantidad mínima de código.

Llama a métodos nativos del SDK de terceros desde secuencias de comandos C# (opcional)

Los SDKs de redes de publicidad de terceros pueden tener requisitos especiales que requieran llamar directamente a los métodos de Android o iOS. El proceso para llamar directamente a estos métodos es el siguiente:

Define una interfaz común para los clientes de plataforma
Implementa un cliente predeterminado para plataformas no compatibles
Implementa un cliente de Android para llamar a métodos de Android
Implementa un cliente de iOS para llamar a métodos de iOS
Implementa una fábrica de clientes para cambiar condicionalmente entre clientes iOS y Android.
Definir una API para acceder a todas las funcionalidades del SDK de red de publicidad de terceros

En la siguiente sección, se muestra cómo se implementan estos pasos en una red de publicidad hipotética llamada "AdPub" en una API de C# que puede llamar a los métodos en iOS y Android:

Android

package com.adpub.android;

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

iOS

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

Define una interfaz común para los clientes de plataforma

Crea una interfaz IAdPubClient con un método que represente la API de iOS y Android subyacente.

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

Define un cliente predeterminado para plataformas no compatibles

Crea una clase DefaultClient que implemente la interfaz IAdPubClient que solo registra el nombre del método. Usa esta implementación para el editor de Unity y todas las plataformas, excepto 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.");
        }
    }
}

Implementa un cliente de la plataforma de iOS

Crea una clase iOSAdPubClient que implemente la interfaz IAdPubClient en iOS. Esta implementación usa InteropServices para llamar al método setHasUserConsent() en la clase AdPubSdk de 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

A continuación, implementa el método GADUAdPubSetHasUserConsent() que se definió anteriormente. Crea AdPubClientBridge.m con un método GADUAdPubSetHasUserConsent() de C para controlar la llamada de método de Unity y, luego, invoca el AdPubSDK.

AdPubClientBridge es un archivo fuente de iOS y debe colocarse dentro de la carpeta Plugins/iOS como se explica en la guía de Unity para complementos nativos.

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

#import <AdPubSDK/AdPubSDK.h>

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

Cómo implementar un cliente de la plataforma de Android

Crea una clase AndroidAdPubCient que implemente la interfaz IAdPubClient en Android. Esta implementación usa las clases auxiliares de Java para Android a fin de llamar al método estático de Android setHasUserConsent().

Como las clases auxiliares de Java para Android solo están disponibles durante el tiempo de ejecución de Android, puedes evitar errores de compilación usando la directiva del compilador UNITY_ANDROID para unir la clase como se muestra en el fragmento de código. Como alternativa, puedes usar las definiciones de Assembly en Unity 2017.4 y versiones posteriores para resolver este 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 método de fábrica para mostrar la implementación de cliente correcta.

Ahora que tienes implementaciones del cliente para cada plataforma, crea una clase AdPubClientFactory a fin de mostrar la implementación correcta de la interfaz IAdPubClient según la plataforma del entorno de ejecución. Esta clase usa directivas del compilador para mostrar el cliente IAdPubClient correcto.

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

Cómo definir una API pública para cada método de interfaz

Crea una clase AdPubApi que tenga llamadas de método para cada método cliente en tu interfaz IAdPubClient. Esta clase usa el AdPubClientFactory para obtener una instancia de IAdPubClient y llama a ese cliente para las funcionalidades del SDK subyacente.

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

Llama a tu API recientemente definida

Así es cómo puedes llamar a la API definida anteriormente:

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

Ejemplos adicionales de adaptadores de redes de publicidad de terceros

Visita el repositorio de GitHub del complemento de Unity de anuncios para dispositivos móviles de Google a fin de obtener más ejemplos de adaptadores de mediación de terceros que implementan las API de C# para unir llamadas a métodos de iOS y Android.