Começar

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

A integração do SDK dos anúncios para dispositivos móveis do Google para C++ em um app é o primeiro passo para exibir anúncios e gerar receita. Depois de integrar o SDK, você poderá 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 para iOS e Android e está disponível apenas nessas plataformas. O SDK do Google Mobile Ads C++ usa as construções do Firebase para C++ para oferecer suporte a operações assíncronas. Por isso, ele reside no namespace firebase::gma.

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

Pré-requisitos

Android

  • Usar o Android Studio 3.2 ou uma versão mais recente
  • Verifique se o arquivo de build do app usa os seguintes valores:
    • minSdkVersion de 16 ou mais
    • Uma compileSdkVersion de 28 ou mais

iOS

  • Use o Xcode 13 ou versões mais recentes
  • Segmentar o iOS 10.0 ou superior

Configurar o app na conta da AdMob

Registre seu app como um app da AdMob seguindo estas etapas:

  1. Faça login na sua conta da AdMob ou crie uma.

  2. Registre seu app na AdMob. Essa etapa cria um aplicativo da AdMob com um ID do aplicativo da AdMob 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, em seguida, descompacte-o em um diretório da sua escolha.

O SDK do Firebase para C++ não é específico da plataforma, mas exige 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 arquivo do Gradle (geralmente app/build.gradle) do seu módulo (nível do app), 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 seguinte conteúdo ao arquivo CMakeLists.txt do seu 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 de C++ dos anúncios para dispositivos móveis do Google sem nenhum outro serviço do Firebase.

iOS

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

  1. Instale o 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 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 de C++ dos anúncios para dispositivos móveis do Google sem nenhum outro serviço do Firebase.

Configurar o ID do seu app na AdMob

Android

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

iOS

Siga a etapa Atualizar o arquivo Info.plist conforme descrito no guia do SDK de anúncios para dispositivos móveis do 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 o app inicialize o SDK de C++ dos anúncios para dispositivos móveis do Google chamando firebase::gma::Initialize(), que inicializa o SDK e conclui uma firebase::Future quando a inicialização é concluída (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 sinalizações específicas de solicitações (como tag_for_child_directed_treatment ou tag_for_under_age_of_consent) ou tome medidas antes de carregar os 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

Um Future oferece uma maneira de determinar o status de conclusão das chamadas de método assíncrono.

Por exemplo, quando o 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. Quando concluído, seu app poderá invocar result() para receber o AdapterInitializationStatus resultante.

Os métodos que retornam um Future têm um método correspondente para o "último resultado" 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 da Future estiver concluído e o código do erro dela for firebase::gma::kAdErrorCodeNone, a operação foi concluída com êxito.

Também é possível registrar callbacks para serem invocados quando uma Future é concluída. Em alguns casos, o callback vai ser executado em uma linha de execução diferente, então verifique se o código é seguro para linhas 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 de C++ dos anúncios para dispositivos móveis do Google agora é importado, e você está pronto para implementar um anúncio. Na AdMob, há vários formatos de anúncios diferentes para que você possa escolher o mais adequado à experiência do usuário no seu app.

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ê não tem experiência em publicidade para dispositivos móveis, eles são um bom ponto de partida.

Implementar anúncios de banner

Intersticial

São anúncios em tela cheia que cobrem a interface de um aplicativo até serem fechados pelo usuário. Elas são melhor usadas em pausas naturais no fluxo de execução de um app, como entre as fases 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 Usados para gerar receita com apps sem custo financeiro.

Implementar anúncios premiados