Esta página foi traduzida pela API Cloud Translation.

Criar eventos personalizados

Com os eventos personalizados, os editores que usam a mediação da AdMob podem adicionar a mediação em hierarquia a uma rede de publicidade de terceiros que não é uma das redes de publicidade compatíveis. Este guia explica como usar um evento personalizado criado para Android e iOS em um projeto do Unity.

Pré-requisitos

Conclua a etapa Começar. O plug-in dos anúncios para dispositivos móveis do Google para Unity já precisa estar importado no app Unity.
Adaptadores de eventos personalizados já criados para Android e iOS. Para criar adaptadores de eventos personalizados, consulte nossos guias de eventos personalizados no Android e no iOS.

Definir um evento personalizado

Para que um evento personalizado participe da mediação, ele precisa ser definido na interface da Web da AdMob. Adicione um evento personalizado aos seus grupos de mediação do Android e do iOS.

Esta captura de tela mostra alguns exemplos de configurações de eventos personalizados:

Como preencher os parâmetros
Nome da classe (iOS)	No iOS, insira o nome da classe que implementa o evento personalizado. Se a classe for implementada no Swift, você precisa adicionar o nome do app / módulo da biblioteca correspondente como prefixo (por exemplo, `appName.className`). O nome do destino é obrigatório se você tiver vários destinos no projeto ou se o nome do projeto for diferente do nome do destino. Com o nome do destino, ele fica assim: `appName_targetName.className`. Além disso, substitua todos os caracteres não alfanuméricos, como traços, por sublinhados.
Nome da classe (Android)	Para Android, verifique se o valor informado para `Class Name` é o nome de classe totalmente qualificado para Android (por exemplo, `com.google.ads.mediation.sample.customevent.SampleCustomEvent`).
Rótulo	Insira um nome exclusivo para o evento.
Parâmetro	Se você quiser transmitir um argumento de string para seu evento personalizado, por exemplo, um ID de unidade de anúncio.

Importar bibliotecas de eventos personalizados

Os eventos personalizados podem exigir a inclusão de outras bibliotecas para funcionar corretamente. Por exemplo, talvez seja necessário incluir as seguintes bibliotecas:

SDK de terceiros do Android
Evento personalizado de terceiros do Android
SDK de anúncios de terceiros para iOS
Evento personalizado de terceiros para iOS

Tipos de bibliotecas

Há várias maneiras de importar código do Android ou iOS para um projeto do Unity, incluindo:

Como importar artefatos pré-criados do Android ou iOS usando o External Dependency Manager para Unity
Como importar plug-ins de AAR e bibliotecas do Android
Importar arquivos de origem Java e Kotlin
Como importar arquivos de origem e bibliotecas estáticas do iOS

Dependendo de como as bibliotecas que você usa são empacotadas, talvez seja necessário usar uma estratégia de importação diferente para cada uma delas. Cada opção será discutida em mais detalhes mais tarde.

(Recomendado) Importar artefatos pré-criados do Android ou iOS

Importe artefatos pré-criados do Maven ou CocoaPods usando o External Dependency Manager para Unity. Esse plug-in está incluído no plug-in GoogleMobileAds.

Para importar artefatos existentes, crie um arquivo de configuração para definir suas importações. O nome do arquivo e o caminho têm os seguintes requisitos:

O arquivo precisa existir na pasta /Editor/.
O nome do arquivo precisa terminar com Dependencies.xml.

Por exemplo, para importar adaptadores de eventos personalizados para uma rede de publicidade hipotética chamada AdPub, crie o arquivo:

Assets/AdPub/Editor/AdPubDependencies.xml

Em seguida, defina suas dependências no arquivo AdPubDependencies.xml. As regras para configurar as importações podem ser encontradas em Introdução ao Gerenciador de dependências externas para Unity. O snippet de código a seguir inclui o SDK do Android e do iOS e as bibliotecas de eventos personalizados para uma rede de publicidade 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>

Se o artefato de evento personalizado já tiver uma dependência do SDK da rede de publicidade necessário, não será necessário definir a dependência do SDK explicitamente: Exemplo

O External Dependency Manager monitora automaticamente as mudanças de configuração e resolve as dependências. Você também pode executar a resolução manual com o seguinte comando de menu:

Assets > External Dependency Manager > Android Resolver > Force Resolve

Importar plug-ins AAR e bibliotecas do Android

O Unity oferece suporte à importação de arquivos *.aar e projetos de biblioteca do Android. Se o evento personalizado do Android estiver empacotado dessa forma, consulte Plug-ins de AAR e bibliotecas do Android para instruções sobre como incluir esses arquivos no projeto do Unity.

Importar arquivos de origem Java e Kotlin

A partir do Unity 2018.2 ou mais recente, se o código de evento personalizado do Android for composto de arquivos *.java ou *.kt não compilados, você poderá usar arquivos de origem Java ou Kotlin como plug-ins.

Importar arquivos de origem e bibliotecas estáticas do iOS

O Unity oferece suporte a artefatos *.framework, arquivos de origem *.h e *.m. A importação de artefatos e arquivos de origem do iOS é explicada no guia do Unity para plug-ins nativos.

Testar eventos personalizados com o Ad Inspector

O Ad Inspector pode ser usado para testar se os eventos personalizados foram importados corretamente para o aplicativo. O inspector de anúncios pode ser aberto com apenas gestos ou de forma programática com um código mínimo.

(Opcional) Chamar métodos nativos de SDKs de terceiros em scripts C#

Os SDKs de rede de publicidade de terceiros podem ter requisitos especiais que exigem a chamada direta de métodos do Android ou do iOS. O processo para chamar esses métodos diretamente é o seguinte:

Definir uma interface comum para clientes de plataforma
Implementar um cliente padrão para plataformas sem suporte
Implementar um cliente Android para chamar métodos do Android
Implementar um cliente iOS para chamar métodos do iOS
Implementar uma fábrica de clientes para alternar condicionalmente entre clientes iOS e Android
Definir uma API para acessar todas as funcionalidades do SDK da rede de publicidade de terceiros

A seção a seguir mostra como essas etapas são implementadas para uma rede de publicidade hipotética chamada "AdPub" em uma API C# que pode chamar os métodos no Android e no iOS:

Android

package com.adpub.android;

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

iOS

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

Definir uma interface comum para clientes de plataforma

Crie uma interface IAdPubClient com um método que represente a API 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);
    }
}

Definir um cliente padrão para plataformas sem suporte

Crie uma classe DefaultClient que implemente a interface IAdPubClient que apenas registra o nome do método. Use essa implementação para o editor do Unity e todas as plataformas, exceto 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.");
        }
    }
}

Implementar um cliente da plataforma iOS

Crie uma classe iOSAdPubClient que implemente a interface IAdPubClient no iOS. Essa implementação usa InteropServices para chamar o método setHasUserConsent() na classe AdPubSdk do 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

Em seguida, implemente o método GADUAdPubSetHasUserConsent() definido acima. Crie AdPubClientBridge.m com um método C GADUAdPubSetHasUserConsent() para processar a chamada de método do Unity e invocar o AdPubSDK.

AdPubClientBridge é um arquivo de origem do iOS e precisa ser colocado na pasta Plugins/iOS, conforme explicado no guia do Unity para plug-ins nativos.

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

#import <AdPubSDK/AdPubSDK.h>

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

Implementar um cliente da plataforma Android

Crie uma classe AndroidAdPubCient que implemente a interface IAdPubClient no Android. Essa implementação usa as classes auxiliares do Java para Android para chamar o método estático setHasUserConsent() do Android.

Como as classes auxiliares Java do Android só estão disponíveis durante o ambiente de execução do Android, é possível evitar erros de compilação usando a diretiva do compilador UNITY_ANDROID para agrupar a classe, conforme mostrado no snippet de código. Como alternativa, use as definições de assembly no Unity 2017.4 e versões mais recentes para resolver esse 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

Criar um método de fábrica para retornar a implementação correta do cliente

Agora que você tem implementações do cliente para cada plataforma, crie uma classe AdPubClientFactory para retornar a implementação correta da interface IAdPubClient dependendo da plataforma de execução. Essa classe usa diretivas do compilador para retornar o cliente IAdPubClient correto.

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

Definir uma API pública para cada método de interface

Crie uma classe AdPubApi com chamadas de método para cada método de cliente na interface IAdPubClient. Essa classe usa o AdPubClientFactory para receber uma instância do IAdPubClient e chama esse cliente para as funcionalidades subjacentes do SDK.

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

Chamar a API recém-definida

Veja como chamar a API definida acima:

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

Outros exemplos de adaptadores de rede de publicidade de terceiros

Acesse o repositório do plug-in dos anúncios para dispositivos móveis do Google no Github para conferir outros exemplos de adaptadores de mediação de terceiros que implementam APIs C# para agrupar chamadas para métodos do iOS e do Android.