Experimenta con estrategias de monetización en Firebase Predictions

Firebase Predictions facilita el proceso de brindar una experiencia diferente a los usuarios de tu app según una predicción del comportamiento de tus usuarios. Por ejemplo, puedes proporcionar una experiencia sin anuncios para los usuarios que probablemente harían compras directas desde la app en el futuro y mostrar anuncios para todos los demás. Sin embargo, antes de implementar esta estrategia de monetización en general, es importante asegurarse de que no afectará la retención de los usuarios existentes de forma negativa.

En esta guía se muestra cómo lograr ambos objetivos con Firebase Predictions y las pruebas A/B de Firebase: habilitarás una estrategia de monetización basada en anuncios para los usuarios que no harían compras directas desde la aplicación según las predicciones y verificarás la efectividad de esta nueva estrategia.

Antes de comenzar

Para comenzar a usar las predicciones y determinar la política de anuncios de tu app, debes usar Google Analytics para Firebase en la app. En particular, debes hacer lo siguiente:

  • Habilita el uso compartido de datos de Analytics en Firebase console.
  • Registra de manera explícita los eventos relacionados con los gastos que no se recopilan de forma automática, como ecommerce_purchase. (Firebase registra el evento in_app_purchase automáticamente para las compras directas desde la aplicación que se procesan mediante App Store y Play Store). Por lo general, también deberías registrar cualquier otro evento que sea relevante para la app, con el fin de maximizar los datos disponibles para hacer las clasificaciones.
  • Asegúrate de tener un volumen de datos de eventos suficiente para que Firebase haga predicciones significativas. Comúnmente, 10,000 usuarios activos al mes, 500 ejemplos positivos y 500 ejemplos negativos proporcionan una cantidad suficiente de datos a Firebase Predictions.

Comienza con la predicción del gasto de los usuarios

El primer paso es configurar el proyecto de Firebase para que comience a predecir el gasto de los usuarios:

  1. En Firebase console, abre la sección Predictions. Si aún no aceptaste las Condiciones del Servicio de Predictions, debes hacerlo.

    Después de aceptar las Condiciones del Servicio, se habilitará Predictions en tu proyecto. La sección Predictions de Firebase console permite definir predicciones personalizadas; sin embargo, para la predicción del gasto, puedes usar las predicciones integradas spend y not_spend, que se calculan a partir de un conjunto de eventos de Analytics. Estas predicciones estarán disponibles en un plazo de 24 horas después de que habilites Predictions y registres algunos eventos de gasto de referencia.

  2. Agrega un parámetro de Remote Config que corresponda a la predicción not_spend:

    1. En Firebase console, haz clic en Remote Config.
    2. Agrega un parámetro nuevo con el nombre will_not_spend (por ejemplo). Crea una condición nueva para este parámetro que se aplique cuando se prediga not_spend. A continuación, configura el valor true para la condición nueva y el valor false como predeterminado.

Crea un experimento de estrategia de monetización

A continuación, crea un experimento de pruebas A/B para tres estrategias de monetización:

  • Nunca mostrar anuncios (grupo de control)
  • Mostrar anuncios siempre
  • Mostrar anuncios solo a los usuarios que no gastarán según la predicción

Para crear el experimento, haz lo siguiente:

  1. En Firebase console, abre la sección Remote Config.
  2. Haz clic en el botón Pruebas A/B.
  3. Crea un nuevo experimento:

    1. Elige la app en la lista y especifica cuántos usuarios quieres incluir en el experimento. También puedes optar por excluir del experimento ciertas categorías de usuarios, como aquellos que gastan más.

    2. Define tres variantes: una para cada estrategia de monetización.

      A continuación, crea un parámetro ads_policy y asigna el valor ads_never a la variante de grupo de control, ads_always a la segunda variante y ads_nonspenders a la variante que se basa en la predicción. Tu app usa este parámetro para decidir si debe mostrar anuncios a un usuario en particular.

    3. Elige Retención (de 2 a 3 días) en la lista de métricas de objetivos y selecciona cualquier métrica adicional que desees seguir, como los ingresos por compras, las eliminaciones de apps y los clics en anuncios.

      Por último, en la sección Opciones avanzadas, selecciona el evento de Analytics ads_policy_set que registras de forma explícita en tu app. Ten en cuenta que este evento no aparecerá en la lista hasta que se registre una vez.

Implementa las estrategias de monetización en tu app

Ahora que configuraste las predicciones y experimentos en Firebase console, implementa las estrategias de monetización para cada una de las variantes de tu experimento.

Por ejemplo, si usas AdMob para los anuncios, haz lo siguiente:

  1. Importa los SDK de Analytics, Remote Config y AdMob:

    iOS (Swift)

    Agrega los SDK a tu Podfile:

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

    Después, impórtalos:

    import Firebase
    

    Android

    implementation 'com.google.firebase:firebase-core:16.0.3'
    implementation 'com.google.firebase:firebase-config:16.0.0'
    implementation 'com.google.firebase:firebase-ads:15.0.1'
    
  2. Recupera la política de anuncios del usuario actual con Remote Config.

    iOS (Swift)

    self.remoteConfig = RemoteConfig.remoteConfig()
    self.remoteConfig.setDefaults(["ads_policy": "ads_never"])
    
    // ...
    
    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()
    
        // ...
    }
    

    Android

    final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
    
    Map remoteConfigDefaults = new HashMap<String, Object>();
    remoteConfigDefaults.put("ads_policy", "ads_never");
    config.setDefaults(remoteConfigDefaults);
    
    // ...
    
    config.fetch(cacheExpiration)
            .addOnCompleteListener(this, new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        config.activateFetched();
                    }
    
                    // Act on the retrieved parameters
    
                    // Show ads based on the ad policy retrieved with Remote Config
                    executeAdsPolicy();
    
                    // ...
                }
            });
    
  3. Por último, oculta o muestra los anuncios según la política de anuncios que recuperaste. Además, en este momento, registra el evento ads_policy_set para indicar que se puede considerar que el usuario participa en el experimento.

    iOS (Swift)

    func executeAdsPolicy() {
        let adsPolicy = self.remoteConfig["ads_policy"].stringValue
        let willNotSpend = self.remoteConfig["will_not_spend"].booleanValue
    
        if adsPolicy == "ads_always"
                || ((adsPolicy == "ads_nonspenders") && willNotSpend) {
            bannerView.load(GADRequest())
            self.bannerView.isHidden = false
        } else {
            self.bannerView.isHidden = true
        }
    
        Analytics.logEvent("ads_policy_set", parameters: nil)
    }
    

    Android

    FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
    String adPolicy = config.getString("ads_policy");
    boolean will_not_spend = config.getBoolean("will_not_spend");
    AdView mAdView = (AdView) findViewById(R.id.adView);
    
    if (adPolicy.equals("ads_always") ||
            (adPolicy.equals("ads_nonspenders") && will_not_spend)) {
        AdRequest adRequest = new AdRequest.Builder().build();
        mAdView.loadAd(adRequest);
        mAdView.setVisibility(View.VISIBLE);
    } else {
        mAdView.setVisibility(View.GONE);
    }
    
    FirebaseAnalytics.getInstance(this).logEvent("ads_policy_set", new Bundle());
    

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.