Android SDK integration for developers

Existen dos maneras de agregar el SDK a tu aplicación:

• Mediante Gradle (opción recomendada)
• Agregar el SDK manualmente 

El referente de instalación de Android mejora la precisión de la atribución, protege contra las instalaciones fraudulentas y mucho más. Es compatible con la versión 4.8.6 del SDK de AppsFlyer para Android.

Agregar el referente de instalación

1. Agrega el referente de instalación de Android como dependencia. Puedes encontrar la última versión aquí.
   

   dependencias

2. Sincroniza el proyecto para recuperar las dependencias: mira la captura de pantalla a continuación.
   
   

Si estás usando ProGuard y quieres usar la nueva API de referencia de Google, establece la siguiente regla de ProGuard: -dontwarn com.android.installreferrer

Si no estás usando Gradle:

1. Descarga el aar del referente de instalación.
2. Agrégalo al proyecto.
3. Agrega el siguiente permiso al manifiesto: com.google.android.finsky.permission.BIND_GET_INSTALL_REFERRER_SERVICE

Al agregar permisos, se ayuda a aumentar la velocidad de atribución mediante fingerprinting. Esto también permite que el SDK envíe más datos como los datos de redes de proveedores y WiFi. Puedes encontrar estos datos en los reportes de raw data (datos sin procesar) y usarlos para analizar y optimizar las campañas.

Agrega los permisos necesarios

1. Agrega los siguientes permisos a AndroidManifest.xml:
   

   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
   <!-- Optional : -->
   <uses-permission android:name="android.permission.READ_PHONE_STATE" />
   

El BroadcastReceiver obtiene información de Google Play que AppsFlyer usa para la atribución. Al usar el BroadcastReceiver, se aumenta la velocidad de atribución.

Las siguientes dos opciones están disponibles para implementar el receptor de transmisión de referencia de instalación:

<application>


	<receiver android:name="com.appsflyer.SingleInstallBroadcastReceiver" android:exported="true">
		<intent-filter>
			 <action android:name="com.android.vending.INSTALL_REFERRER" />
		 </intent-filter>
	</receiver>


</application>

<application>


	<receiver android:name="com.appsflyer.MultipleInstallBroadcastReceiver" android:exported="true">
		<intent-filter>
			<action android:name="com.android.vending.INSTALL_REFERRER" />
		</intent-filter>
	</receiver>


</application>

AppsFlyer usa la clave de desarrollador para identificar tu cuenta de manera exclusiva. La clave de desarrollador es obligatoria porque permite que el SDK envíe y recupere datos que pertenecen a tu cuenta de AppsFlyer de manera segura.

Para hacer esto:

1. Ve al panel de control de tu aplicación. 
2. En el panel de control, en Configuración, haz clic en Configuración de la aplicación.
3. Copia tu clave de desarrollador.
   
   

   

Te recomendamos inicializar el SDK dentro de la clase global de la aplicación. Esto permite que el SDK se inicialice en todos los escenarios, incluidos los enlaces profundos.

Los pasos que se enumeran a continuación tienen lugar dentro de la clase global de la aplicación.

1. Dentro de la clase global de la aplicación, importa las siguientes bibliotecas:
   

   import android.app.Application;
   import com.appsflyer.AppsFlyerLib;
   import com.appsflyer.AppsFlyerConversionListener;
   import java.util.Map;

2. Dentro de la clase global, asigna tu clave de desarrollador a una variable, de preferencia con el nombre AF_DEV_KEY
   
   

   public class AFApplication extends Application {
       private static final String AF_DEV_KEY = "qrdZGj123456789";
       
       //...
       
   }
   

3. Dentro de la clase global , después de la llamada a super.onCreate(), implementa el AppsFlyerConversionListener. Consulta el código a continuación en el paso 4.
4. Dentro de la clase global, después del ConversionListener, inicializa el SDK y llama al método startTracking
   

   public class AFApplication extends Application {
       private static final String AF_DEV_KEY = "qrdZGj123456789";
       
       @Override
       public void onCreate() {
           super.onCreate();
           AppsFlyerConversionListener conversionListener = new AppsFlyerConversionListener() {
   
   
               @Override
               public void onInstallConversionDataLoaded(Map<String, String> conversionData) {
               
                       for (String attrName : conversionData.keySet()) {
                       Log.d("LOG_TAG", "attribute: " + attrName + " = " + conversionData.get(attrName));
                   }
               }
   
               @Override
               public void onInstallConversionFailure(String errorMessage) {
   		   Log.d("LOG_TAG", "error getting conversion data: " + errorMessage);
               }
   
               @Override
               public void onAppOpenAttribution(Map<String, String> conversionData) {
               
                   for (String attrName : conversionData.keySet()) {
                       Log.d("LOG_TAG", "attribute: " + attrName + " = " + conversionData.get(attrName));
                   }
   
               }
   
               @Override
               public void onAttributionFailure(String errorMessage) {
                   Log.d("LOG_TAG", "error onAttributionFailure : " + errorMessage);
               }
           };
           
           AppsFlyerLib.getInstance().init(AF_DEV_KEY, conversionListener, getApplicationContext());
           AppsFlyerLib.getInstance().startTracking(this);
   
       }
   }
                 

En el archivo AndroidManifest.xml, dentro de la etiqueta de la aplicación, agrega la siguiente línea:

android:name="APP.PACAKAGE.NAME.AFApplication"

• APP.PACAKGE.NAME: reemplaza esto por el nombre de paquete de la aplicación.
• AFApplication: reemplaza esto por el nombre que estableciste para la clase global de la aplicación.

Esta línea en el manifest.xml indica a la aplicación cuál es la aplicación global. Como mencionamos anteriormente, al hacer esto, el SDK de AppsFlyer SDK queda accesible a nivel global en toda la aplicación.

Antes de comenzar a probar instalaciones, agrega a la lista blanca el dispositivo que vas a usar para las pruebas.

Las instalaciones orgánicas son instalaciones sin atribuir que, por lo general, son instalaciones directas desde tiendas de aplicaciones.

Para simular una instalación orgánica

1. Asegúrate de tener un dispositivo móvil conectado a tu computadora.
2. En Android Studio, abre el Logcat.
3. Desde Android Studio, instala la aplicación en el dispositivo o emulador.
4. Espera a que se inicie la aplicación.
5. En el Logcat, busca el nombre de paquete de tu aplicación.

Deberías ver lo siguiente:

La parte resaltada en la captura de pantalla indica que el SDK notifica una instalación orgánica. Estos datos provienen del método onInstallConversionDataLoaded en la clase AFApplication. Más adelante en esta guía, se explica cómo obtener datos de conversión.

Ahora debería aparecer una instalación orgánica en la página de Información general del panel de control de la aplicación.

Si no ves ninguna instalación en el panel de control, consulta nuestra guía de resolución de problemas del SDK.

Una instalación no orgánica es una instalación atribuida que, por lo general, tiene lugar después de una instancia de captación (engagement) de un anuncio. Para simular una instalación no orgánica, puedes usar enlaces de atribución.

Para hacer esto:

1. En el manifiesto, averigua cuál es el nombre de paquete de tu aplicación, p. ej., com.company.app.
2. En la siguiente URL, reemplaza <PACKAGE_NAME> por el nombre de paquete de tu aplicación:
   

   https://app.appsflyer.com/<PACKAGE_NAME>?pid=sdk_test&c=sdk_test
   

   El parámetro pid representa el nombre de la fuente de medios. El parámetro c representa el nombre de la campaña.
3. Envía esta URL al dispositivo. Por ejemplo, puedes hacer esto por correo electrónico o WhatsApp. 
4. En el dispositivo, haz clic en la URL.
   • Si la aplicación figura en la tienda de aplicaciones, se te redirigirá a la tienda de aplicaciones. No descargues e instales la aplicación desde la tienda de aplicaciones. Sigue con el paso 5.
   • Si la aplicación no figura en la tienda de aplicaciones y aún se encuentra en desarrollo, la pantalla muestra un mensaje de que la aplicación no se encuentra disponible en la tienda de aplicaciones. Simplemente sigue con el paso 5.
5. En Android Studio, abre el Logcat.
6. Conecta el dispositivo a tu computadora con un cable USB.
7. Desde Android Studio, instala la aplicación en el dispositivo.
8. En el Logcat, busca el nombre de paquete de tu aplicación.

Deberías ver lo siguiente:

Ahora debería aparecer una instalación no orgánica en la página de Información general del panel de control de la aplicación.

El SDK tiene dos interfaces relacionadas con los eventos in-app:

• AFInAppEventType: constantes para nombres de eventos in-app
• AFInAppEventParameterName: constantes para nombres de parámetros de eventos in-app

Es muy recomendable que uses estas dos interfaces por los siguientes motivos:

• La nomenclatura estándar permite que AppsFlyer asigne automáticamente eventos a redes de autorreporte (SRN) como Facebook, Google, Twitter y Snapchat.
• Compatibilidad con versiones anteriores: si AppsFlyer decide cambiar el nombre de cualquier evento o parámetro de evento, tu implementación será compatible con las versiones anteriores.

Para usar estas dos interfaces, es necesario que las importes:

import com.appsflyer.AFInAppEventParameterName;
import com.appsflyer.AFInAppEventType;

Aquí encontrarás la lista de estructuras y nombres de eventos recomendados.

Puedes enviar los ingresos con cualquier evento in-app. Usa el parámetro de evento af_revenue (AFInAppEventParameterName.REVENUE) para incluir los ingresos en el evento in-app. Puedes llenarlo con cualquier valor numérico, positivo o negativo.

af_revenue es el único parámetro de evento que AppsFlyer cuenta como ingreso real en los raw data (datos sin procesar) y en el panel de control. Para conocer más detalles, haz clic aquí.

Cuando envíes eventos con ingresos, ten en cuenta lo siguiente:

• Si estableces el código de divisa (mira el ejemplo a continuación), debe ser un código ISO 4217 de 3 caracteres. (la opción predeterminada es USD).
• Puedes establecer el código de divisa para todos los eventos llamando al siguiente método: AppsFlyer.setCurrencyCode("ZZZ").  Para obtener información sobre la configuración, visualización y conversión de divisas, consulta nuestra guía sobre ingresos de divisas.
• El valor de los ingresos no debe contener comas separadoras, signos de divisas ni texto. Por ejemplo, un evento de ingresos debe ser similar a 1234.56.

Ejemplo: evento de compra in-app con ingresos

Map<String, Object> eventValue = new HashMap<String, Object>();
eventValue.put(AFInAppEventParameterName.REVENUE,1234.56);
eventValue.put(AFInAppEventParameterName.CONTENT_TYPE,"Shirt);
eventValue.put(AFInAppEventParameterName.CONTENT_ID,"1234567");
eventValue.put(AFInAppEventParameterName.CURRENCY,"USD");
AppsFlyerLib.getInstance().trackEvent(getApplicationContext() , AFInAppEventType.PURCHASE , eventValue);

El evento de compra anterior tiene asociados ingresos de $200 y aparece como ingresos en el panel de control.

Registro de ingresos negativos

Puede haber situaciones en las que quieras registrar ingresos negativos.

Por ejemplo, un usuario recibe un reembolso por un par de zapatos que te compró.

Map<String, Object> eventValue = new HashMap<String, Object>();
eventValue.put(AFInAppEventParameterName.REVENUE,-200);
eventValue.put(AFInAppEventParameterName.CONTENT_TYPE,"shoes");
eventValue.put(AFInAppEventParameterName.CONTENT_ID,"4875");
eventValue.put(AFInAppEventParameterName.CURRENCY,"USD");
AppsFlyerLib.getInstance().trackEvent(getApplicationContext() , "cancel_purchase" , eventValue);

El SDK de AppsFlyer proporciona verificación de servidor para las compras in-app. Para validar una compra, llama a validateAndTrackInAppPurchase.

Esta llamada genera automáticamente un evento in-app de tipo af_purchase, dado que la compra está validada.

public static void validateAndTrackInAppPurchase(Context context, 
String publicKey, String signature, String purchaseData, 
String price, String currency, HashMap<String, String> additionalParameters);

Parámetros de método

• String publicKey: clave pública de la consola para desarrolladores de Google
• String signature: firma de transacción (devuelta por la API de Google cuando se finaliza la compra)
• String purchaseData: producto comprado en formato JSON (devuelto por la API de Google cuando se finaliza la compra)
• String revenue: ingresos del evento in-app que deben notificarse a AppsFlyer
• String currency: divisa del evento in-app que debe notificarse a AppsFlyer
• HashMap<String, String> additionalParameters: parámetros adicionales del evento in-app que aparecen en el campo event_value de los raw data del evento in-app.

Devoluciones de llamadas para indicar intentos de validación de compras satisfactorios o con errores

Si quieres saber si el intento de validar la compra es satisfactorio o no, implementa registerValidatorListener en la clase de tu aplicación. Este elemento de escucha tiene dos bloques de devolución de llamada, uno para indicar que el intento es "satisfactorio" y otro para indicar que hubo un "error" (por cualquier motivo, incluido un error de validación).

AppsFlyerLib.getInstance().registerValidatorListener(this,new
   AppsFlyerInAppPurchaseValidatorListener() {
     public void onValidateInApp() {
       Log.d(TAG, "Purchase validated successfully");
     }
     public void onValidateInAppFailure(String error) {
       Log.d(TAG, "onValidateInAppFailure called: " + error);
     }
});

Ejemplo de uso de la validación de compra:

// Purchase object is returned by Google API in onPurchasesUpdated() callback
private void handlePurchase(Purchase purchase) {
    Log.d(LOG_TAG, "Purchase successful!");
    Map<String, String> additional_event_values = new HashMap<>();
    additional_event_values.put("some_parameter", "some_value");
    String revenue = "10";
    String currency = "USD";
    AppsFlyerLib.getInstance().validateAndTrackInAppPurchase(getApplicationContext(), PUBLIC_KEY, purchase.getSignature(), purchase.getOriginalJson(), revenue, currency, additional_event_values);
}

Al validar una compra in-app, se envía automáticamente un evento de compra in-app a AppsFlyer. Mira a continuación una muestra de los datos que se pasan en el parámetro event_value:

{
   "some_parameter":"some_value", // from additional_event_values
   "af_currency":"USD", // from currency
   "af_content_id":"test_id", // from purchase
   "af_revenue":"10", // from revenue
   "af_quantity":"1", // from purchase
   "af_validated":true // flag that AF verified the purchase
}

• El nombre de un evento in-app puede tener hasta 45 caracteres.
• Para precios e ingresos, usa solo dígitos y decimales, p. ej., 5 o 5.2.
• Los valores de precios e ingresos pueden tener hasta 5 dígitos después del punto, p. ej., 5.12345
• AppsFlyer admite caracteres no ingleses con eventos in-app o con cualquier otra API de SDK a partir de la versión 4.8.1 del SDK de Android.

Puedes registrar eventos in-app al llamar a trackEvent con el nombre de evento y los parámetros de valor. Consulta la documentación sobre eventos in-app para conocer más detalles.

A continuación, te mostramos un ejemplo de cómo registrar un evento de compra. Para ver una lista completa de fragmentos de código listos por segmento vertical, consulta nuestra guía de eventos in-app enriquecidos por segmento vertical.

Ejemplo: evento de compra in-app

Map<String,Object> eventValues = new HashMap<>();
eventValues.put(AFInAppEventParameterName.REVENUE, 1200);
eventValues.put(AFInAppEventParameterName.CURRENCY, "JPY");
eventValues.put(AFInAppEventParameterName.CONTENT_TYPE, "Shoes");
AppsFlyerLib.getInstance().trackEvent(this, AFInAppEventType.PURCHASE, eventValues);

OneLink detecta el tipo de dispositivo al hacer clic y redirige al usuario al destino correspondiente, p. ej., Google Play, tienda de aplicaciones iOS, mercados fuera de la tienda o páginas web.

En la guía sobre redireccionamiento de OneLink, analizamos la implementación de enlaces de atribución multiplataforma (sin necesidad de codificación del SDK). También es la base para los enlaces profundos.

Los enlaces profundos te permiten enviar a usuarios hacia actividades específicas y ofrecerles contenido personalizado. Esto resulta particularmente útil cuando se ejecutan campañas de retargeting.

Para configurar enlaces profundos con OneLink, un marketer con acceso al panel de control de AppsFlyer y un desarrollador con acceso a la aplicación deben trabajar juntos.

Consulta nuestra guía sobre configuración de enlaces profundos con OneLink.

Los enlaces profundos diferidos te permiten establecer enlaces profundos con usuarios nuevos y ofrecerles contenido personalizado después de que instalen la aplicación. Esto es diferente con respecto a los enlaces profundos normales, en los que la aplicación ya debe estar instalada en el dispositivo del usuario.

Para configurar enlaces profundos diferidos con OneLink, el desarrollador también necesita acceso al panel de control de AppsFlyer.

La configuración de enlaces profundos diferidos es prácticamente igual a la de los enlaces profundos regulares. La única diferencia es que necesitas implementar una lógica adicional en la aplicación a fin de establecer enlaces profundos con los usuarios y ofrecerles contenido personalizado después de que instalen e inicien la aplicación.

Consulta nuestra guía sobre enlaces profundos diferidos para aprender más.

El SDK te proporciona los datos de conversión o captación (engagement) después de cada instalación o evento de enlaces profundos. Puedes usar estos datos para personalizar el contenido y el comportamiento de la aplicación de manera programática.

Consulta nuestra guía sobre datos de enlaces profundos para aprender más.

Con AppsFlyer, puedes atribuir instalaciones para aplicaciones Android fuera de la tienda. Esto te permite promocionar tus aplicaciones y llegar a audiencias más grandes en mercados en los que Google Play no está disponible. 

Para conocer más detalles sobre cómo atribuir instalaciones para aplicaciones fuera de la tienda, lee aquí.

En las campañas de instalación previa, los propietarios de aplicaciones pueden solicitarles a los fabricantes de dispositivos que preinstalen sus aplicaciones en los dispositivos antes de salir de fábrica.

Con AppsFlyer, puedes atribuir instalaciones de aplicaciones preinstaladas con facilidad. Cuando los usuarios inician tu aplicación por primera vez, AppsFlyer atribuye la instalación al fabricante como fuente de medios.

Para conocer más detalles, haz clic aquí.

Para saber cómo configurar la medición de desinstalaciones, lee aquí.

Si quieres recibir una confirmación de que los servidores de AppsFlyer recibieron la solicitud de rastreo correctamente, es posible implementar el agente de escucha AppsFlyerTrackingRequestListener.

El método de devolución de llamada onTrackingRequestSuccess() se invoca para cada respuesta 200 a una solicitud de atribución por parte del SDK.

El método de devolución de llamada onTrackingRequestFailure(String error) se invoca para cualquier otra respuesta y devuelve la respuesta como la cadena de error.

Ejemplo de implementación

AppsFlyerLib.getInstance().startTracking(this.getApplication(),"devKey", myListener());
private AppsFlyerTrackingRequestListener myListener() {  
  return new AppsFlyerTrackingRequestListener() { 
    @Override public void onTrackingRequestSuccess() { 
      Log.d("Debug", "Got 200 response from server");  
    }  @Override public void onTrackingRequestFailure(String error) { 
      Log.d("Debug", error); 
      }  
    }; 
  }

La API setAdditionalData es necesaria para integrarse a nivel del SDK con varias plataformas de partners externos, como Segment, Adobe y Urban Airship.
Usa esta API solo si el artículo de integración de la plataforma indica específicamente que se necesita la API setAdditionalData.

Ejemplo de código de setAdditionalData:

HashMap<String,Object> CustomDataMap = new HashMap<>();
CustomDataMap.put("custom_param_1","value_of_param_1");
AppsFlyerLib.getInstance().setAdditionalData(CustomDataMap);

De manera predeterminada, deben pasar por lo menos 5 segundos entre 2 instancias de inicio de la aplicación para que cuenten como 2 sesiones separadas (más información acerca del recuento de sesiones).

Usa la siguiente API para establecer el tiempo mínimo entre sesiones:

AppsFlyerLib.setMinTimeBetweenSessions(int seconds);

Establecer un valor alto para el tiempo personalizado entre inicios podría afectar negativamente las API que dependen de los datos de sesión, como los enlaces profundos.

Puedes usar este método de SDK para notificar sobre nuevas sesiones de usuario. Por ejemplo, esto puede resultar útil para aplicaciones utilitarias que se ejecutan en segundo plano.

Usa esta API en la función onCreate() de tu actividad:

public void reportTrackSession (Context context);

Ejemplo de Uso:

AppsFlyerLib.getInstance (). ReportTrackSession (context);

Algunos servicios de terceros, como los proveedores de servicio de correo electrónico encapsulan enlaces en los mensajes de correo electrónico con sus propios dominios de registro de clics. Algunos incluso te permiten configurar tus propios dominios de registro de clics. Si OneLink está encapsulado en tales dominios, su funcionalidad podría verse limitada.

Para resolver este problema, puedes usar la API setResolveDeepLinkURLs. Usa esta API para obtener el OneLink de los dominios de clics que inician la aplicación. Asegúrate de llamar a esta API antes de la inicialización del SDK.

Por ejemplo, tienes tres dominios de clics que redirigen a tu OneLink, que es https://mysubdomain.onelink.me/abCD. Usa esta API para obtener el OneLink al cual redirigen tus dominios de clics. Este método de API recibe una lista de dominios que el SDK resolverá.

AppsFlyerLib.getInstance().setResolveDeepLinkURLs("clickdomain.com", "myclickdomain.com", "anotherclickdomain.com");

El código anterior te permite usar tu dominio de clics y, al mismo tiempo, preservar la funcionalidad del OneLink. Los dominios de clics son responsables de iniciar la aplicación. A su vez, la API obtiene el OneLink de estos dominios de clics y, a continuación, tú puedes usar los datos de este OneLink para establecer enlaces profundos y personalizar el contenido de los usuarios.

Con AppsFlyer, puedes medir notificaciones push como parte de las campañas de retargeting.

Para activar esta función, llama al método sendPushNotificationData dentro del método onCreate de cada actividad que se inicia tras hacer clic en la notificación:

AppsFlyerLib.getInstance().sendPushNotificationData(this);

Para obtener más información sobre la medición de notificaciones push, lee aquí.

Permitir que tus usuarios actuales inviten a sus amigos y contactos como nuevos usuarios de tu aplicación puede ser un factor de crecimiento clave para tu aplicación. Con AppsFlyer, puedes atribuir y registrar instalaciones que se originen a partir de invitaciones de usuarios dentro de tu aplicación.

Para conocer más detalles, consulta el artículo sobre atribución de invitaciones de usuarios.

El ID de dispositivo exclusivo de AppsFlyer se crea para cada nueva instalación de una aplicación. Puedes usar este ID de dispositivo exclusivo de AppsFlyer con diversos fines:

• Enviar eventos in-app de servidor a servidor.
• Vincular el ID de dispositivo exclusivo de AppsFlyer con los registros de usuarios en tus sistemas de backend.
• Asignar entradas cuando se fusionan datos de las API de extracción y envío (Pull/Push API).

Usa el siguiente API para obtener el ID único de AppsFlyer:

public String getAppsFlyerUID(Context context);

Ejemplo de uso:

String appsFlyerId = AppsFlyerLib.getInstance().getAppsFlyerUID(this);

Para configurar tu ID de usuario de cliente:

public void setCustomerUserId(String id);

Ejemplo de uso:

AppsFlyerLib.getInstance().setCustomerUserId("myId");

Te recomendamos configurar el ID de usuario de cliente lo antes posible en el flujo de tu aplicación, ya que solo se asocia con los eventos reportados después de su configuración:

• Si se llama a setCustomerUserId antes de llamar a startTracking, el ID de usuario de cliente aparece en los reportes de raw data de instalaciones y eventos.
• Si se configura después, el ID de usuario de cliente se asocia solo con eventos registrados después de configurar dicho ID.

Cómo obtener un ID de usuario de cliente:

Para evitar configurar el valor del ID de usuario de cliente nuevamente después del primer inicio, y reducir las llamadas a tu servidor para obtener el ID de usuario de cliente, puedes verificar si su valor está vacío, o no, de la siguiente forma:

AppsFlyerProperties.getInstance().getString(AppsFlyerProperties.APP_USER_ID)

Para obtener más información sobre el ID de usuario de cliente, haz clic aquí.

Retrasar la inicialización del SDK para customerUserID

Puedes retrasar la inicialización del SDK hasta que se configure el customerUserID.

Para indicar que el SDK debe retrasar la inicialización en espera del ID de usuario de cliente, llama a:

AppsFlyerLib.getInstance().waitForCustomerUserId(true);

inmediatamente antes del método init(). El resto de la inicialización del SDK debe mantenerse sin cambios.

Una vez proporcionado el customerUserID, llama a

AppsFlyerLib.getInstance().setCustomerIdAndTrack("customer_id", this);

Para proporcionar al SDK el ID de usuario de cliente correspondiente e iniciar el SDK.

El código debería verse como se muestra a continuación:

public class AFApplication extends Application {
  private static final String AF_DEV_KEY = "qrdZGj123456789";
  @Override
  public void onCreate() {
    super.onCreate();
    AppsFlyerConversionListener conversionDataListener = 
    new AppsFlyerConversionListener() {
      ...
    };
    AppsFlyerLib.getInstance().waitForCustomerUserId(true); 
    AppsFlyerLib.getInstance().init(AF_DEV_KEY, getConversionListener(), getApplicationContext());
    AppsFlyerLib.getInstance().startTracking(this);
    // Do your magic to get the customerUserID
    // ...
    // any AppsFlyer SDK code invoked here will be discarded
   //Call the following API once the customerUserID is available:
 AppsFlyerLib.getInstance().setCustomerIdAndTrack("customer_id", this);
  }
}

Para aprender más acerca de cómo retrasar la inicialización del SDK hasta que esté disponible el ID de usuario de cliente, ve aquí.

Desde la versión 4.8.0 del SDK, AppsFlyer recopila automáticamente el google_advertising_id.

El requisito de recopilar el ID de Publicidad de Google solo es relevante para SDK versiones 4.7.X e inferiores.

De manera predeterminada, el SDK no recopila el IMEI ni el ID de Android si la versión del sistema operativo es superior a KitKat (4.4) y el dispositivo contiene servicios de Google Play.

Para enviar de manera explícita estos ID a AppsFlyer, los desarrolladores pueden llamar a las siguientes API antes de llamar al método startTracking:

AppsFlyerLib.getInstance().setImeiData("IMEI_DATA_HERE");
AppsFlyerLib.getInstance().setAndroidIdData("ANDROID_ID_DATA_HERE");

Si la aplicación NO contiene Google Play Services, el SDK recopila el IMEI y el ID de Android. Sin embargo, las aplicaciones con Google Play Services deberían evitar la recopilación del IMEI, ya que esto viola la política de Google Play.

Los desarrolladores pueden optar por no recopilar el IMEI y el ID de Android mediante el uso de estas API:

AppsFlyerLib.getInstance().setCollectIMEI(false);
AppsFlyerLib.getInstance().setCollectAndroidID(false);

En algunos casos extremos, tal vez necesites desactivar todo el tracking del SDK para cumplir con la ley y las políticas de privacidad. Puedes hacer esto con la API isStopTracking. Una vez invocada esta API, el SDK deja de funcionar y ya no se comunica con los servidores de AppsFlyer.

AppsFlyerLib.getInstance().stopTracking(true, context);

Existen varias situaciones diferentes para que un usuario opte por la exclusión. Es muy recomendable que sigas las instrucciones exactas para la situación correspondiente a tu aplicación.

En cualquier evento, se puede reactivar el SDK llamando a la misma API y pasando un valor falso.

AppsFlyerLib.getInstance().trackAppLaunch(getApplicationContext(), AF_DEV_KEY);

Usa esta API durante la Inicialización del SDK para anonimizar explícitamente las instalaciones, los eventos y las sesiones de un usuario:

public void setDeviceTrackingDisabled(boolean isDisabled);

Ejemplo de uso:

AppsFlyerLib.getInstance().setDeviceTrackingDisabled(true);

Para reiniciar el tracking, puedes llamar a deviceTrackingDisabled configurado en false (falso).