Tutorial: Otimize a monetização híbrida usando AdMob, Google Analytics e Firebases

Etapa 3: configurar a Configuração remota do Firebase para mostrar experiências de anúncios específicas


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

Etapa 3: configurar a Configuração remota do Firebase para mostrar experiências de anúncios específicas


Ao final da última etapa, você aprendeu sobre os públicos do Google Analytics. Nesta etapa, você criará um parâmetro controlado por booleano da Configuração remota (chamado ad_control_switch ) que aproveita o público-alvo "Compradores". Em seguida, você adicionará a lógica ao código do seu aplicativo para o que ele deve exibir com base no valor desse parâmetro.

Configurar parâmetros e condições do Configuração remota no console do Firebase

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

  2. No painel esquerdo, expanda a seção Engajar e selecione Configuração remota .

  3. Clique em Criar configuração (ou Adicionar parâmetro se você já usou o Configuração remota).

  4. No painel Criar parâmetro , conclua as etapas a seguir:

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

    2. No menu suspenso Data type , selecione Boolean .

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

  5. Na caixa de diálogo Definir uma nova condição , conclua as etapas a seguir:

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

    2. No menu suspenso Aplica-se se... , selecione Público(s) do(s) usuário(s) .

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

    4. Clique em Salvar condição .

  6. De volta ao painel Criar parâmetro , conclua as etapas a seguir:

    1. Para o grupo Valor dos compradores , selecione falso .

    2. Para o valor padrão , selecione true .

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

Esta configuração irá verificar se o usuário está no público “Compradores” (ou seja, é um usuário pagante):

  • Se o usuário estiver no público "Compradores", o Configuração remota retornará o valor false para o parâmetro ad_control_switch .

  • Se o usuário não estiver no público "Compradores", o Configuração remota retornará o valor true para o parâmetro ad_control_switch .

Nas etapas a seguir, você implementará o Configuração remota no seu aplicativo para lidar com esses valores de parâmetro.

Adicione o SDK do Configuração remota ao seu app

Antes de usar o Configuração remota no código do seu aplicativo, adicione o SDK do Configuração remota à base de código do seu aplicativo. Observe que seu aplicativo já deve ter o SDK dos anúncios para dispositivos móveis do Google (AdMob) e o SDK do Google Analytics para Firebase das etapas anteriores deste tutorial.

Rápido Android Vibração Unidade

Adicione e instale o pod do Configuração remota no seu podfile:

pod 'Firebase/RemoteConfig'

Adicione a dependência da biblioteca do Configuração remota ao arquivo build.gradle :

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

Na raiz do seu projeto Flutter, execute o seguinte comando para instalar o plug-in do Configuração remota:

flutter pub add firebase_remote_config

Faça download e instale o SDK do Firebase Unity mais recente e adicione o pacote do Configuração remota ao seu projeto:
FirebaseRemoteConfig.unitypackage

Configurar a instância do Configuração remota

Para que seu aplicativo possa usar os valores dos parâmetros do Configuração remota, configure a instância do Configuração remota para que ela possa buscar novos valores para a instância do aplicativo cliente.

Neste exemplo, o Configuração remota está configurado para verificar novos valores de parâmetros uma vez a cada hora.

RápidoKotlin+KTXJava Vibração Unidade
remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 3600
remoteConfig.configSettings = settings
remoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)
mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);
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');
  });
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 a Configuração remota

Busque e ative o parâmetro do Configuração remota para que ele possa começar a usar os novos valores dos parâmetros.

Você deseja fazer essa chamada o mais cedo possível na fase de carregamento do seu aplicativo porque ela é assíncrona e você precisa do valor da Configuração remota pré-buscado para que seu aplicativo saiba se deve exibir um anúncio.

RápidoKotlin+KTXJava Vibração Unidade
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()
}
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()
        }
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();
            }
        });
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();
remoteConfig.FetchAndActivateAsync().ContinueWithOnMainThread(task => {
  if (task.IsFaulted) {
    Debug.LogWarning("Config params failed to update");
  } else {
    Debug.Log("Config params updated: " + task.Result);
  }
  LoadAdUnit();
});

Seu aplicativo agora está configurado para lidar com o parâmetro do Configuração remota criado anteriormente nesta etapa.

Usar o valor do parâmetro Configuração remota

Use o valor pré-buscado da Configuração remota na função loadAdUnit() para determinar se a instância do aplicativo deve realizar uma das seguintes ações:

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

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

RápidoKotlin+KTXJava Vibração Unidade
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.
  }
}
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.
    }
}
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.
    }
}
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.
  }
}
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.
  }
}

Libere seu aplicativo

Como a lógica para exibir ou não o anúncio está dentro da sua base de código, você precisa lançar uma nova versão do seu aplicativo que contenha essa lógica.

Se você seguiu as etapas deste tutorial, seu aplicativo deverá começar imediatamente a veicular uma experiência personalizada de anúncios no aplicativo para seus usuários. Você pode monitorar sua receita de anúncios na sua conta da AdMob e nos painéis do Google Analytics (no console do Firebase ou na IU do Google Analytics).


E é isso! Você concluiu o tutorial para otimizar a monetização híbrida usando AdMob, Google Analytics e Firebase.



Etapa 2: configurar o Google Analytics