Experimento com estratégias para gerar receita usando o Firebase Previsões

Com o Firebase Previsões, é fácil oferecer aos usuários do seu app uma experiência diferente, dependendo do comportamento previsto deles. Por exemplo, é possível oferecer uma experiência sem anúncios para usuários que provavelmente farão compras no app no futuro e exibir anúncios para todos os outros. No entanto, antes de implantar essa estratégia para gerar receita, é importante ter certeza de que ela aumentará a receita geral do seu app.

Veja neste guia como atingir as duas metas usando o Firebase Previsões e o Teste A/B: você habilitará uma estratégia para gerar receita com base em anúncios para usuários com previsão de não fazer compras no app e verificará a eficácia dessa nova estratégia.

Antes de começar

Antes de começar a usar as previsões para determinar a política de anúncios no app, é preciso usar o Google Analytics para Firebase no app. Para isso, é necessário fazer o seguinte:

  • Ativar o compartilhamento de dados do Analytics no Console do Firebase.
  • Registrar explicitamente eventos relacionados a gastos que não são coletados automaticamente, como ecommerce_purchase. O Firebase registra automaticamente o evento in_app_purchase para compras no app processadas pela App Store e Play Store. Geralmente, também é preciso registrar quaisquer outros eventos que sejam relevantes para o app, para maximizar os dados disponíveis e possibilitar a geração de classificações.
  • Ter volume de dados de eventos suficiente para o Firebase fazer previsões significativas. Normalmente, 10.000 usuários ativos mensais, 500 exemplos positivos e 500 negativos oferecem dados suficientes ao Firebase Previsões.

Possibilitar a configuração remota dos seus anúncios

Primeiro, configure seu aplicativo para mostrar ou ocultar anúncios de acordo com o valor de um parâmetro da Configuração remota. Nas etapas a seguir, configuramos o Previsões e o Teste A/B para definir o parâmetro remotamente com base em vários critérios. Por enquanto, seu aplicativo sempre exibirá anúncios.

Por exemplo, usando a AdMob para anúncios:

  1. Importe os SDKs da AdMob, do Configuração remota e do Analytics:

    iOS (Swift)

    Adicione os SDKs ao seu Podfile:

    pod 'Firebase/Core'
    pod 'Firebase/RemoteConfig'
    pod 'Firebase/AdMob'
    

    Então, importe-os:

    import Firebase
    

    Android

    implementation 'com.google.firebase:firebase-core:16.0.8'
    implementation 'com.google.firebase:firebase-config:16.4.0'
    implementation 'com.google.firebase:firebase-ads:17.2.0'
    
  2. Inicialize a Configuração remota e defina o valor padrão da variável ads_enabled como true. Mais tarde, você configurará o Previsões e o Teste A/B para definir remotamente essa variável, mas definir um valor padrão no aplicativo garante que ele funcione corretamente antes de recuperar as variáveis configuradas remotamente.

    iOS (Swift)

    self.remoteConfig = RemoteConfig.remoteConfig()
    self.remoteConfig.setDefaults(["ads_enabled": true])
    

    Java
    Android

    mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
    
    Map<String, Object> remoteConfigDefaults = new HashMap<>();
    remoteConfigDefaults.put("ads_enabled", "true");
    mFirebaseRemoteConfig.setDefaults(remoteConfigDefaults);

    Kotlin
    Android

    firebaseRemoteConfig = FirebaseRemoteConfig.getInstance()
    
    val remoteConfigDefaults = HashMap<String, Any>()
    remoteConfigDefaults["ads_enabled"] = "true"
    firebaseRemoteConfig.setDefaults(remoteConfigDefaults)
  3. Mostre ou oculte anúncios com base no valor de ads_enabled. O valor sempre será true e os anúncios sempre serão exibidos até que você configure o Previsões.

    iOS (Swift)

    self.remoteConfig.fetch() { (status, error) -> Void in
        if status == .success {
          self.remoteConfig.activateFetched()
        }
    
        // Act on the retrieved parameters
    
        // Show ads based on the ad policy retrieved with Remote Config
        self.executeAdsPolicy()
    
        // ...
    }
    
    // ...
    
    func executeAdsPolicy() {
        let showAds = self.remoteConfig["ads_enabled"].booleanValue
        if showAds {
            bannerView.load(GADRequest())
            self.bannerView.isHidden = false
        } else {
            self.bannerView.isHidden = true
        }
    }
    

    Java
    Android

    mFirebaseRemoteConfig.fetch(CACHE_EXPIRATION)
            .addOnCompleteListener(this, new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
            if (task.isSuccessful()) {
                mFirebaseRemoteConfig.activateFetched();
            }
    
            // Act on the retrieved parameters
    
            // Show ads based on the ad policy retrieved with Remote Config
            executeAdsPolicy();
    
            // ...
        }
    });
    // ...
    private void executeAdsPolicy() {
        boolean showAds = mFirebaseRemoteConfig.getBoolean("ads_enabled");
        AdView mAdView = findViewById(R.id.adView);
    
        if (showAds) {
            AdRequest adRequest = new AdRequest.Builder().build();
            mAdView.loadAd(adRequest);
            mAdView.setVisibility(View.VISIBLE);
        } else {
            mAdView.setVisibility(View.GONE);
        }
    }

    Kotlin
    Android

    firebaseRemoteConfig.fetch(CACHE_EXPIRATION)
            .addOnCompleteListener(this) { task ->
                if (task.isSuccessful) {
                    firebaseRemoteConfig.activateFetched()
                }
    
                // Act on the retrieved parameters
    
                // Show ads based on the ad policy retrieved with Remote Config
                executeAdsPolicy()
    
                // ...
            }
    // ...
    private fun executeAdsPolicy() {
        val showAds = firebaseRemoteConfig.getBoolean("ads_enabled")
        val adView = findViewById<AdView>(R.id.adView)
    
        if (showAds) {
            val adRequest = AdRequest.Builder().build()
            adView.loadAd(adRequest)
            adView.visibility = View.VISIBLE
        } else {
            adView.visibility = View.GONE
        }
    }

Neste ponto, você pode implantar o aplicativo na App Store ou na Play Store. Os usuários receberão a experiência de anúncios padrão (anúncios sempre exibidos), mas como a exibição de anúncios é controlada por uma variável que pode ser configurada remotamente, é possível alterar e testar o comportamento dos anúncios usando apenas o Console do Firebase. Tudo sem precisar publicar atualizações do aplicativo para os usuários.

Começar a prever os gastos dos usuários

Em seguida, configure seu projeto do Firebase para começar a prever o comportamento dos gastos dos usuários.

No Console do Firebase, abra a seção Previsões. Se você ainda não concordou com os termos de serviço do Previsões, faça isso.

Depois de ter concordado com os termos de serviço, o Previsões será ativado para o projeto. Na seção "Previsões" do Console do Firebase, é possível definir previsões personalizadas. No entanto, use as previsões integradas spend e not_spend para as previsões de gastos. Elas aplicam uma agregação de eventos do Google Analytics para prever se um usuário fará uma compra no aplicativo ou uma compra de comércio eletrônico. No momento, compras de assinatura não são consideradas nesta previsão. Essas previsões ficarão disponíveis depois que você tiver ativado o Previsões e registrado eventos de gastos por algumas semanas.

Criar um experimento de estratégia para gerar receita

Agora, crie um experimento de teste A/B para comparar as estratégias de sempre exibir anúncios e de usar previsões e verificar o efeito sobre a geração de receita.

Os experimentos funcionam melhor com três variantes: um grupo de controle, um grupo em que o parâmetro é definido incondicionalmente e um grupo com base em previsões. Dessa forma, o experimento pode determinar se as previsões apresentam um benefício maior do que simplesmente aplicar o tratamento a todos.

Para criar o experimento:

  1. No Console do Firebase, abra a seção Testes A/B.

  2. Crie um novo experimento:

    1. Clique em Criar experimento > Configuração remota.

    2. Escolha seu app na lista e especifique quantos usuários você quer incluir no experimento. Você também pode optar por excluir determinadas categorias de usuários do experimento, como pessoas que gastam muito.

    3. Escolha Receita total estimada na lista de métricas de objetivo e selecione outras métricas que você quer rastrear, como engajamento de usuários, retenção, remoções do aplicativo e cliques em anúncios.

    4. Defina três variantes:

      • grupo de controle (criado automaticamente)
      • nunca exibir anúncios
      • não exibir anúncios para usuários que provavelmente farão compras no aplicativo

      Para o grupo de controle, crie um parâmetro ads_enabled e defina-o como (no change). Os usuários atribuídos ao grupo de controle receberão o comportamento padrão, ou seja, sempre verão anúncios.

      Na variante em que nunca serão exibidos anúncios, defina o parâmetro ads_enabled como false. Os usuários atribuídos a essa variante nunca verão anúncios.

      Na variante em que os usuários que provavelmente farão compras não verão anúncios, defina o parâmetro ads_enabled como false. Além disso, defina a condição de destino como Prever: gasto - tolerância de risco média. Os usuários atribuídos a essa variante não verão anúncios se a previsão determinar a alta probabilidade de gastos.

Inicie e execute o experimento por vários dias ou mais, até que o teste A/B apresente um líder. Poderá ser necessário expandir a experiência para mais usuários se o experimento não determinar um líder.

Distribuir a variante vencedora para todos os usuários

Depois que o teste A/B coletar informações suficientes para apresentar um líder (neste caso, a variante que maximizou a receita do aplicativo), você poderá decidir se quer distribuir a variante vencedora, ou qualquer outra, para todos os usuários.

Na seção Testes A/B do Console do Firebase, abra a visualização de detalhes do experimento concluído. Nela você pode ver o desempenho de cada variante de acordo com sua métrica de objetivo e outras métricas secundárias selecionadas. Com essas informações, você pode decidir pela distribuição da variante líder ou de outra variante.

Para distribuir uma variante a todos os usuários, clique em more_vert > Aplicar líder na página de detalhes do experimento.

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.