Tutorial: otimizar a monetização híbrida com a AdMob, o Google Analytics e o Firebase

Etapa 3: configurar Firebase Remote Config para mostrar experiências de anúncios específicas


Introdução: otimizar a monetização híbrida usando AdMob, Google Analytics e o Firebase
Etapa 1: use AdMob para criar novos blocos de anúncios para exibição
Etapa 2: configurar o Google Analytics

Etapa 3: configure Firebase Remote Config para mostrar experiências de anúncios específicas


No final da última etapa, você aprendeu sobre os públicos-alvo do Google Analytics. Nesta etapa, você vai criar um parâmetro controlado por booleano Remote Config (chamado ad_control_switch) que usa o público-alvo "Compradores". Em seguida, adicione a lógica ao código do app para o que ele vai mostrar com base no valor desse parâmetro.

Configurar parâmetros e condições de Remote Config no console do Firebase

  1. No console do Firebase, abra seu projeto do Firebase.

  2. No painel à esquerda, expanda a seção Engage e selecione Configuração remota.

  3. Clique em Criar configuração ou Adicionar parâmetro se você já usou o Remote Config.

  4. No painel Criar parâmetro, siga estas etapas:

    1. No campo Nome do parâmetro, insira ad_control_switch.

    2. No menu suspenso Data type, selecione Booleano.

    3. Clique em Criar novo e selecione Criar nova condição.

  5. Na caixa de diálogo Definir uma nova condição, siga estas etapas:

    1. No campo Nome, digite Purchasers Group (ou qualquer outro nome facilmente identificável para a condição).

    2. No menu suspenso Aplica-se se..., selecione Públicos-alvo do usuário.

    3. No menu suspenso Selecionar públicos-alvo, selecione Compradores.

    4. Clique em Salvar condição.

  6. No painel Criar parâmetro, siga estas etapas:

    1. Para o Valor do Grupo de compradores, selecione false.

    2. Em Valor padrão, selecione true.

  7. Clique em Salvar e em Publicar alterações.

Essa configuração vai verificar se o usuário está no público-alvo "Compradores", ou seja, se ele é um usuário pagante:

  • Se o usuário estiver no público-alvo "Compradores", Remote Config vai retornar o valor de false para o parâmetro ad_control_switch.

  • Se o usuário não estiver no público-alvo "Compradores", Remote Config vai retornar o valor de true para o parâmetro ad_control_switch.

Nas próximas etapas, você vai implementar Remote Config no app para processar esses valores de parâmetro.

Adicionar o SDK do Remote Config ao app

Antes de usar o Remote Config no código do aplicativo, adicione o SDK Remote Config à base de código do app. Seu app já deve ter o SDK Google Mobile Ads (AdMob) e o SDK do Google Analytics para Firebase das etapas anteriores deste tutorial.

Swift

Adicione e instale o pod Remote Config no podfile:

pod 'Firebase/RemoteConfig'

Android

Adicione a dependência da biblioteca Remote Config ao arquivo build.gradle:

implementation 'com.google.firebase:firebase-config:22.0.1'

Flutter

Na raiz do seu projeto do Flutter, execute o seguinte comando para instalar o plug-in Remote Config:

flutter pub add firebase_remote_config

Unity

Faça o download e instale o SDK do Firebase para Unity mais recente. Em seguida, adicione o pacote Remote Config ao seu projeto:
FirebaseRemoteConfig.unitypackage

Configurar a instância Remote Config

Para que o app possa usar os valores do parâmetro Remote Config, configure a instância Remote Config para buscar novos valores para a instância do app cliente.

Neste exemplo, Remote Config está configurado para verificar novos valores de parâmetro uma vez por hora.

Swift 

remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 3600
remoteConfig.configSettings = settings

Kotlin 

remoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)

Java 

mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);

Flutter 

remoteConfig = FirebaseRemoteConfig.instance;
  final configSettings = FirebaseRemoteConfigSettings(
    minimumFetchInterval: Duration(hours: 1),
  );
  await remoteConfig.setConfigSettings(configSettings);

  // Use the `onConfigUpdated` callback to listen for changes to the config settings.
  remoteConfig.onConfigUpdated.listen((_) {
    print('Config settings confirmed');
  });

Unity 

var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
var configSettings = new ConfigSettings {
  MinimumFetchInternalInMilliseconds =
        (ulong)(new TimeSpan(1, 0, 0).TotalMilliseconds)
};
remoteConfig.SetConfigSettingsAsync(configSettings)
        .ContinueWithOnMainThread(task => {
          Debug.Log("Config settings confirmed");
}

Buscar e ativar Remote Config

Busque e ative o parâmetro Remote Config para que ele possa começar a usar os novos valores de parâmetros.

Faça essa chamada o quanto antes na fase de carregamento do app, porque ela é assíncrona e vai precisar do valor Remote Config pré-buscado para que o app saiba se vai exibir um anúncio.

Swift 

remoteConfig.fetch() { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate() { (changed, error) in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.loadAdUnit()
}

Kotlin 

remoteConfig.fetchAndActivate()
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                val updated = task.result
                Log.d(TAG, "Config params updated: $updated")
            } else {
                Log.d(TAG, "Config params failed to update")
            }
            loadAdUnit()
        }

Java 

mFirebaseRemoteConfig.fetchAndActivate()
        .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
            @Override
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    boolean updated = task.getResult();
                    Log.d(TAG, "Config params updated: " + updated);
                } else {
                    Log.d(TAG, "Config params failed to update");
                }
                loadAdUnit();
            }
        });

Flutter 

remoteConfig = FirebaseRemoteConfig.instance;

// Fetch and activate the latest Remote Config values.
final updated = await remoteConfig.fetchAndActivate();

// Check if the config params were updated successfully.
if (updated) {
  print('Config params updated');
} else {
  print('Config params failed to update');
}

// Load the ad unit.
_loadAdUnit();

Unity 

remoteConfig.FetchAndActivateAsync().ContinueWithOnMainThread(task => {
  if (task.IsFaulted) {
    Debug.LogWarning("Config params failed to update");
  } else {
    Debug.Log("Config params updated: " + task.Result);
  }
  LoadAdUnit();
});

Agora, seu app está configurado para processar o parâmetro Remote Config que você criou anteriormente nesta etapa.

Usar o valor do parâmetro Remote Config

Use o valor Remote Config pré-buscado na função loadAdUnit() para determinar se a instância do app precisa fazer uma das seguintes ações:

  • O valor do parâmetro ad_control_switch é resolvido como true: mostrar o anúncio intersticial (porque o usuário não paga).

  • O valor do parâmetro ad_control_switch é resolvido como false: não mostrar o anúncio (porque o usuário é pagante).

Swift 

private func loadAdUnit() {
  let showAds = remoteConfig["ad_control_switch"].boolValue

  if showAds {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

Kotlin 

private fun loadAdUnit() {
  var showAds = remoteConfig.getBoolean(ad_control_switch)

  if (showAds) {
      // Load interstitial ad (implemented ad unit)
      // per AdMob instructions (the first step of this tutorial).
    } else {
      // Don't show ads.
    }
}

Java 

private void loadAdUnit() {
    boolean showAds =
      mFirebaseRemoteConfig.getBoolean(ad_control_switch);

    if (showAds) {
      // Load interstitial ad (implemented ad unit)
      // per AdMob instructions (the first step of this tutorial).
    } else {
      // Don't show ads.
    }
}

Flutter 

void _loadAdUnit() {
  bool showAds = remoteConfig.getBool(ad_control_switch);

  if (showAds) {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

Unity 

void LoadAdUnit() {
  bool showAds =
      remoteConfig.GetValue("ad_control_switch").BooleanValue;

  if (showAds) {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

Lançar o app

Como a lógica para mostrar ou não o anúncio está na base de código, é necessário lancar uma nova versão do app que contenha essa lógica.

Se você seguiu as etapas deste tutorial, o app vai começar imediatamente a exibir uma experiência personalizada de anúncios no app para os usuários. É possível monitorar a receita dos seus anúncios na conta do AdMob e nos painéis do Google Analytics (no console do Firebase ou na interface do Google Analytics).


Pronto. Você concluiu o tutorial de como otimizar a monetização híbrida usando AdMob, o Google Analytics e o Firebase.



Etapa 2: configurar o Google Analytics