Começar

Este guia é destinado a editores que querem gerar receita com um app em C++ usando a AdMob e não estão usando o Firebase. Se você pretende incluir o Firebase no seu aplicativo (ou se estiver pensando em usá-lo), consulte a versão AdMob com Firebase deste guia.

Integrar o SDK dos anúncios para dispositivos móveis do Google para C++ a um aplicativo é o primeiro passo para exibir anúncios e gerar receita. Depois de integrar o SDK, você pode escolher um formato de anúncio (como intersticial ou premiado) e seguir as etapas para implementá-lo.

O SDK dos anúncios para dispositivos móveis do Google para C++ envolve os SDKs dos anúncios para dispositivos móveis do Google e do Android e está disponível somente nessas plataformas. O SDK dos anúncios para dispositivos móveis do Google para C++ usa as construções do Firebase para C++ para oferecer suporte a operações assíncronas. Portanto, ele reside no namespace firebase::gma.

Se esta é a primeira vez que você lê este guia, recomendamos que faça o download e continue usando o app de teste de anúncios para dispositivos móveis do Google para C++.

Pré-requisitos

Android

  • Usar o Android Studio 3.2 ou posterior
  • Verifique se o arquivo de build do app usa os seguintes valores:
    • Um minSdkVersion de 16 ou mais
    • Um compileSdkVersion de 28 ou mais

iOS

  • Usar o Xcode 13 ou uma versão mais recente
  • Segmentar iOS 10.0 ou superior

Configurar o app na conta da AdMob

Registre seu aplicativo como um aplicativo da AdMob concluindo as seguintes etapas:

  1. Faça login ou inscreva-se em uma conta da AdMob.

  2. Registre seu app na AdMob. Essa etapa cria um aplicativo da AdMob com um ID do aplicativo da AdMob exclusivo que será necessário mais adiante neste guia.

Instalar o SDK dos anúncios para dispositivos móveis do Google para C++

Como o SDK dos anúncios para dispositivos móveis do Google para C++ reside no namespace firebase::gma, faça o download do SDK do Firebase para C++ e descompacte-o no diretório desejado.

O SDK do Firebase para C++ não é específico da plataforma, mas requer configurações de biblioteca específicas da plataforma.

Android

  1. No arquivo gradle.properties do projeto, especifique o local do SDK descompactado:

      systemProp.firebase_cpp_sdk.dir=full-path-to-SDK

  2. Adicione o seguinte conteúdo ao arquivo settings.gradle do seu projeto:

      def firebase_cpp_sdk_dir = System.getProperty('firebase_cpp_sdk.dir')

  gradle.ext.firebase_cpp_sdk_dir = "$firebase_cpp_sdk_dir"
  includeBuild "$firebase_cpp_sdk_dir"

  3. No seu arquivo Gradle do módulo (nível do app) (geralmente app/build.gradle), adicione o seguinte conteúdo, que inclui a dependência da biblioteca do SDK dos anúncios para dispositivos móveis do Google para C++.

      android.defaultConfig.externalNativeBuild.cmake {
    arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir"
  }

  # Add the dependency for the Google Mobile Ads C++ SDK
  apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle"
  firebaseCpp.dependencies {
    gma
  }

  4. Adicione o conteúdo a seguir ao arquivo CMakeLists.txt do projeto.

      # Add Firebase libraries to the target using the function from the SDK.
  add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)

  # Add the Google Mobile Ads C++ SDK.

  # The Firebase C++ library `firebase_app` is required,
  # and it must always be listed last.

  set(firebase_libs
    firebase_gma
    firebase_app
  )

  target_link_libraries(${target_name} "${firebase_libs}")

  5. Sincronize seu app para garantir que todas as dependências tenham as versões necessárias.

Tudo pronto! Seu app em C++ está configurado para usar o SDK dos anúncios para dispositivos móveis do Google para C++ sem outros serviços do Firebase.

iOS

As etapas nesta seção são um exemplo de como adicionar o SDK dos anúncios para dispositivos móveis do Google para C++ ao seu projeto do iOS.

  1. Faça o download do CocoaPods versão 1 ou mais recente executando:

    sudo gem install cocoapods --pre

  2. Adicione o conjunto de anúncios para dispositivos móveis do Google a partir do SDK descompactado.

    1. Crie um Podfile, se ainda não tiver um:

      cd your-app-directory
pod init

    2. No seu Podfile, adicione o pod do SDK dos anúncios para dispositivos móveis do Google para C++:

        pod 'Google-Mobile-Ads-SDK'

    3. Instale o pod e abra o arquivo .xcworkspace no Xcode.

      pod install
open your-app.xcworkspace

    4. Adicione os seguintes frameworks do SDK do Firebase para C++ ao projeto:

      • xcframeworks/firebase.xcframework
      • xcframeworks/firebase_gma.xcframework

Tudo pronto! Seu app em C++ está configurado para usar o SDK dos anúncios para dispositivos móveis do Google para C++ sem outros serviços do Firebase.

Configurar o ID do seu aplicativo da AdMob

Android

Siga a etapa 3 de Configurar seu aplicativo conforme descrito no Guia do SDK dos anúncios para dispositivos móveis para Android e retorne a esta página de primeiros passos do C++.

iOS

Siga a etapa Atualizar seu Info.plist conforme descrito no guia do SDK dos anúncios para dispositivos móveis para iOS e retorne a esta página de primeiros passos do C++.

Inicializar o SDK de anúncios do Google para dispositivos móveis

Antes de carregar anúncios, faça com que seu app inicialize o SDK dos anúncios para dispositivos móveis do Google para C++ chamando firebase::gma::Initialize(), que inicializa o SDK e conclui um firebase::Future após a conclusão da inicialização (ou após um tempo limite de 30 segundos). Isso precisa ser feito apenas uma vez, de preferência na inicialização do app.

Os anúncios podem ser pré-carregados pelo SDK dos anúncios para dispositivos móveis do Google para C++ ou SDKs de parceiros de mediação ao chamar Initialize(). Se você precisar do consentimento de usuários no Espaço Econômico Europeu (EEE), defina sinalizadores específicos de solicitações (como tag_for_child_directed_treatment ou tag_for_under_age_of_consent) ou tome medidas antes de carregar anúncios. Para isso, invoque firebase::gma::SetRequestConfiguration() antes de inicializar o SDK C++ dos anúncios para dispositivos móveis do Google. Para mais informações, consulte nosso guia de Segmentação.

Veja um exemplo de como chamar Initialize():

Android

// Initialize the Google Mobile Ads library
firebase::InitResult result;
Future<AdapterInitializationStatus> future =
  firebase::gma::Initialize(jni_env, j_activity, &result);

if (result != kInitResultSuccess) {
  // Initialization immediately failed, most likely due to a missing dependency.
  // Check the device logs for more information.
  return;
}

// Monitor the status of the future.
// See "Use a Future to monitor the completion status of a method call" below.
if (future.status() == firebase::kFutureStatusComplete &&
    future.error() == firebase::gma::kAdErrorCodeNone) {
  // Initialization completed.
} else {
  // Initialization on-going, or an error has occurred.
}

iOS

// Initialize the Google Mobile Ads library.
firebase::InitResult result;
Future<AdapterInitializationStatus> future =
  firebase::gma::Initialize(&result);

if (result != kInitResultSuccess) {
  // Initialization immediately failed, most likely due to a missing dependency.
  // Check the device logs for more information.
  return;
}

// Monitor the status of the future.
// See "Use a Future to monitor the completion status of a method call" below.
if (future.status() == firebase::kFutureStatusComplete &&
    future.error() == firebase::gma::kAdErrorCodeNone) {
  // Initialization completed.
} else {
  // Initialization on-going, or an error has occurred.
}

Usar um Future para monitorar o status de conclusão de uma chamada de método

Uma Future fornece uma maneira de determinar o status de conclusão das chamadas de método assíncronas.

Por exemplo, quando seu app chama firebase::gma::Initialize(), um novo firebase::Future é criado e retornado. Seu app pode pesquisar o status() do Future para determinar quando a inicialização foi concluída. Depois de concluído, seu app pode invocar result() para receber o AdapterInitializationStatus resultante.

Os métodos que retornam um Future têm um método de "último resultado" correspondente que os apps podem usar para recuperar o Future mais recente de uma determinada ação. Por exemplo, firebase::gma::Initialize() tem um método correspondente chamado firebase::gma::InitializeLastResult(), que retorna um Future que o app pode usar para verificar o status da última chamada para firebase::gma::Initialize().

Se o status de Future estiver concluído e o código de erro for firebase::gma::kAdErrorCodeNone, a operação foi concluída.

Você também pode registrar callbacks para serem invocados quando um Future for concluído. Em alguns casos, o callback será executado em uma linha de execução diferente, portanto, verifique se o código é seguro para linha de execução. Esse snippet de código usa um ponteiro de função para o callback:

// Registers the OnCompletion callback. user_data is a pointer that is passed verbatim
// to the callback as a void*. This allows you to pass any custom data to the callback
// handler. In this case, the app has no data, so you must pass nullptr.
firebase::gma::InitializeLastResult().OnCompletion(OnCompletionCallback,
  /*user_data=*/nullptr);

// The OnCompletion callback function.
static void OnCompletionCallback(
  const firebase::Future<AdapterInitializationStatus>& future, void* user_data) {
  // Called when the Future is completed for the last call to firebase::gma::Initialize().
  // If the error code is firebase::gma::kAdErrorCodeNone,
  // then the SDK has been successfully initialized.
  if (future.error() == firebase::gma::kAdErrorCodeNone) {
    // success!
  } else {
    // failure.
  }
}

Selecione um formato de anúncio

O SDK dos anúncios para dispositivos móveis do Google para C++ agora é importado e você está pronto para implementar um anúncio. A AdMob oferece vários formatos de anúncio diferentes. Assim, você pode escolher a melhor opção para a experiência do usuário do seu aplicativo.

Anúncios retangulares que aparecem na parte superior ou inferior da tela do dispositivo. Os anúncios de banner permanecem na tela enquanto os usuários interagem com o aplicativo e podem ser atualizados automaticamente após um determinado período. Se você começou a usar os anúncios para dispositivos móveis agora, eles são um bom lugar para começar.

Implementar anúncios de banner

Intersticial

Anúncios em tela cheia que cobrem a interface de um aplicativo até serem fechados pelo usuário. Elas são mais úteis em pausas naturais no fluxo de execução de um app, como entre os níveis de um jogo ou logo após a conclusão de uma tarefa.

Implementar anúncios intersticiais

Premiado

Anúncios que recompensam os usuários por assistir a vídeos curtos e interagir com pesquisas e anúncios jogáveis. Usado para gerar receita com apps sem custo financeiro.

Implementar anúncios premiados