Esta página foi traduzida pela API Cloud Translation.

Criar eventos personalizados

Os eventos personalizados permitem que os editores que usam a mediação AdMob adicionem a mediação em hierarquia para uma rede de publicidade de terceiros que não seja uma das redes de publicidade compatíveis. Neste guia, explicamos como usar um evento personalizado criado para Android e iOS em um projeto do Unity.

Pré-requisitos

Conclua Primeiros passos. Seu app Unity já deve ter o plug-in dos anúncios para dispositivos móveis do Google para Unity importado.
Adaptadores de eventos personalizados já criados para Android e iOS. Para criar adaptadores de eventos personalizados, consulte nossos guias de eventos personalizados emAndroid eiOS.

Definir um evento personalizado

Para que um evento personalizado participe da mediação, ele precisa ser definido na interface da Web 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 parâmetros
Nome da turma (iOS)	No iOS, insira o nome da classe que implementa o evento personalizado. Se a classe for implementada no Swift, é necessário prefixar o nome da classe com o nome do app / módulo do framework (por exemplo, `appName.className`). O nome do destino será necessá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 ficaria assim: `appName_targetName.className`. Além disso, lembre-se de substituir todos os caracteres não alfanuméricos, como traços por sublinhados.
Nome da classe (Android)	No Android, verifique se o valor fornecido para o `Class Name` é o nome da 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ê quer transmitir um argumento de string ao seu evento personalizado, por exemplo, um ID de bloco de anúncios.

Importar bibliotecas de eventos personalizados

Eventos personalizados podem exigir que outras bibliotecas sejam incluídas 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 no iOS

Tipos de biblioteca

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

Importar artefatos pré-criados do Android ou iOS usando o Gerenciador de dependências externas para Unity
Importação de plug-ins AAR e bibliotecas do Android
Como importar arquivos de origem Java e Kotlin
Como importar arquivos de origem e bibliotecas estáticas do iOS

Dependendo de como as bibliotecas usadas são empacotadas, talvez você precise de uma estratégia de importação diferente para cada biblioteca. Cada opção será discutida com mais detalhes posteriormente.

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

Importe artefatos pré-criados do Maven ou do CocoaPods usando o Gerenciador de dependências externas para Unity. Este plug-in está incluído com o plug-in GoogleMobileAds.

Para importar artefatos atuais, crie um arquivo de configuração para definir as 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 as dependências dentro do arquivo AdPubDependencies.xml. As regras para configurar as importações podem ser encontradas em Primeiros passos com o Gerenciador de dependências externas do 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 do "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 no SDK da rede de anúncios necessário, não será necessário definir a dependência do SDK explicitamente. Exemplo

O Gerenciador de dependências externas monitora automaticamente as mudanças de configuração e resolve as dependências. Também é possível executar a resolução manual com o comando de menu a seguir:

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, bem como de projetos de biblioteca do Android. Se o evento personalizado do Android for empacotado dessa maneira, consulte Plug-ins de AAR e bibliotecas do Android para instruções sobre como incluir esses arquivos no seu projeto do Unity.

Importar arquivos de origem Java e Kotlin

A partir do Unity 2018.2, se o código de evento personalizado do Android incluir 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 e 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 Ad Inspector pode ser aberto com apenas gestos ou de forma programática com o mínimo de código.

(Opcional) Chamar métodos nativos do SDK de terceiros usando scripts C#

Os SDKs de redes de publicidade de terceiros podem ter requisitos especiais que exigem a chamada direta de métodos do Android ou 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 iOS
Implementar uma fábrica de cliente 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 implementando a interface IAdPubClient que apenas registre o nome do método. Use essa implementação para o editor do Unity e todas as plataformas que não sejam 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 implementando 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 dentro da 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 implementando a interface IAdPubClient no Android. Essa implementação usa as classes auxiliares Java do Android para chamar o método estático setHasUserConsent() do Android.

Como as classes auxiliares Java do Android estão disponíveis apenas durante a execução do Android, é possível evitar erros de compilação usando a diretiva do compilador UNITY_ANDROID para unir a classe, conforme mostrado no snippet de código. Como alternativa, você pode usar 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 todas as plataformas, 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 que tenha chamadas de método para cada método cliente na interface IAdPubClient. Essa classe usa o AdPubClientFactory para conseguir uma instância do IAdPubClient e chama esse cliente para as funcionalidades básicas 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);
        }
    }
}

Chame 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 redes de publicidade de terceiros

Acesse o repositório do GitHub sobre o plug-in de anúncios para dispositivos móveis do Google para Unity (link em inglês) para ver mais exemplos de adaptadores de mediação de terceiros que implementam APIs C# para unir chamadas a métodos do iOS e do Android.