Intégration du SDK Android

Étape 1 : Mettez à jour votre build.gradle

Dans votre build.gradle, ajoutez mavenCentral() à votre liste de dépôts.

1
2
3
repositories {
  mavenCentral()
}

Ensuite, ajoutez Braze à vos dépendances.

• base only
• with ui components

1
2
3
4
dependencies {
    implementation 'com.braze:android-sdk-base:SDK_VERSION' // (Required) Adds dependencies for the base Braze SDK.
    implementation 'com.braze:android-sdk-location:SDK_VERSION' // (Optional) Adds dependencies for Braze location services.
}

1
2
3
4
dependencies {
    implementation 'com.braze:android-sdk-ui:SDK_VERSION' // (Required) Adds dependencies for the Braze SDK and Braze UI components. 
    implementation 'com.braze:android-sdk-location:SDK_VERSION' // (Optional) Adds dependencies for Braze location services.
}

Étape 2 : Configurez votre braze.xml

Créez un fichier braze.xml dans le dossier res/values de votre projet. Si vous êtes sur un cluster de données spécifique ou disposez d’un endpoint personnalisé préexistant, vous devez également spécifier l’endpoint dans votre fichier braze.xml.

Le contenu de ce fichier devrait ressembler à l’extrait de code suivant : Veillez à remplacer YOUR_APP_IDENTIFIER_API_KEY par l’identifiant figurant dans la page Gérer les paramètres du tableau de bord Braze. Connectez-vous à dashboard.braze.com pour trouver l’adresse de votre cluster.

1
2
3
4
5
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string translatable="false" name="com_braze_api_key">YOUR_APP_IDENTIFIER_API_KEY</string>
  <string translatable="false" name="com_braze_custom_endpoint">YOUR_CUSTOM_ENDPOINT_OR_CLUSTER</string>
</resources>

Étape 3 : Ajoutez des autorisations à AndroidManifest.xml

Ensuite, ajoutez les permissions suivantes à votre AndroidManifest.xml:

1
2
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Étape 4 : Activer l’initialisation différée (optionnel)

Pour utiliser l’initialisation différée, la version minimale du SDK de Braze est requise :

Étape 4.1 : Mettez à jour votre braze.xml

L’initialisation différée est désactivée par défaut. Pour l’activer, utilisez l’une des options suivantes :

• braze xml file
• at runtime

1
<bool name="com_braze_enable_delayed_initialization">true</bool>

1
Braze.enableDelayedInitialization(context);

1
Braze.enableDelayedInitialization(context)

Étape 4.2 : Configurer l’analyse/analytique push (facultatif)

Lorsque l’initialisation différée est activée, les analyses/analytiques push sont mises en file d’attente par défaut. Cependant, vous pouvez choisir de mettre explicitement en file d’attente ou d’abandonner l’ analyse/analytique push (si vous utilisez l’analyse/analytique push).

File d’attente explicite

Pour mettre explicitement en file d’attente l’analyse/analytique push, choisissez l’une des options suivantes :

• braze xml file
• at runtime

1
<string name="com_braze_delayed_initialization_analytics_behavior">QUEUE</string>

1
Braze.enableDelayedInitialization(context, DelayedInitializationAnalyticsBehavior.QUEUE);

1
Braze.enableDelayedInitialization(context, DelayedInitializationAnalyticsBehavior.QUEUE)

Chute

Pour abandonner l’analyse/analytique push, choisissez l’une des options suivantes :

• braze xml file
• at runtime

1
<string name="com_braze_delayed_initialization_analytics_behavior">DROP</string>

1
Braze.enableDelayedInitialization(context, DelayedInitializationAnalyticsBehavior.DROP);

1
Braze.enableDelayedInitialization(context, DelayedInitializationAnalyticsBehavior.DROP)

Étape 4.3 : Initialiser manuellement le SDK

Après le délai que vous avez choisi, utilisez la méthode Braze.disableDelayedInitialization() pour initialiser manuellement le SDK.

• java
• kotlin

1
Braze.disableDelayedInitialization(context);

1
Braze.disableDelayedInitialization(context)

Étape 5 : Activer le suivi de la session de l’utilisateur

Lorsque vous activez le suivi des sessions utilisateur, les appels à openSession(), closeSession(),ensureSubscribedToInAppMessageEvents()et InAppMessageManager peuvent être traités automatiquement.

Pour enregistrer les rappels de cycle de vie des activités, ajoutez le code suivant à la méthode onCreate() de votre classe Application.

• java
• kotlin

1
2
3
4
5
6
7
public class MyApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(new BrazeActivityLifecycleCallbackListener());
  }
}

1
2
3
4
5
6
class MyApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    registerActivityLifecycleCallbacks(BrazeActivityLifecycleCallbackListener())
  }
}

Tester le suivi de session

Si vous rencontrez des problèmes lors de vos tests, activez la journalisation en mode verbeux, puis utilisez logcat pour détecter les appels openSession et closeSession manquants dans vos activités.

1. Dans Braze, allez dans Aperçu, sélectionnez votre application, puis dans le menu déroulant Afficher les données d’aperçu, choisissez Aujourd’hui.
2. Ouvrez votre appli, puis actualisez le tableau de bord de Braze. Vérifiez que vos indicateurs ont augmenté de 1.
3. Naviguez dans votre application et vérifiez qu’une seule session a été enregistrée sur Braze.
4. Faites passer l’application en arrière-plan pendant au moins 10 secondes, puis ramenez-la au premier plan. Vérifiez qu’une nouvelle session a été enregistrée.

Configurations optionnelles

Configuration du temps d’exécution

Pour définir vos options Braze dans le code plutôt que dans votre fichier braze.xml, utilisez la configuration d’exécution. Si une valeur existe aux deux endroits, c’est la valeur d’exécution qui sera utilisée. Une fois que tous les paramètres requis ont été fournis au moment de l’exécution, vous pouvez supprimer votre fichier braze.xml.

Dans l’exemple suivant, un objet générateur est créé puis transmis à Braze.configure(). Notez que seules quelques-unes des options d’exécution disponibles sont affichées - reportez-vous à notre KDoc pour la liste complète.

• java
• kotlin

1
2
3
4
5
6
7
8
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setApiKey("api-key-here")
        .setCustomEndpoint("YOUR_CUSTOM_ENDPOINT_OR_CLUSTER")
        .setSessionTimeout(60)
        .setHandlePushDeepLinksAutomatically(true)
        .setGreatNetworkDataFlushInterval(10)
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5
6
7
8
val brazeConfig = BrazeConfig.Builder()
        .setApiKey("api-key-here")
        .setCustomEndpoint("YOUR_CUSTOM_ENDPOINT_OR_CLUSTER")
        .setSessionTimeout(60)
        .setHandlePushDeepLinksAutomatically(true)
        .setGreatNetworkDataFlushInterval(10)
        .build()
Braze.configure(this, brazeConfig)

ID publicitaire Google

L’identifiant publicitaire Google (GAID) est un identifiant publicitaire facultatif, spécifique à l’utilisateur, anonyme, unique et réinitialisable, fourni par les services Google Play. Le GAID permet aux utilisateurs de réinitialiser leur identifiant, de désactiver les publicités axées sur les centres d’intérêt dans les applications Google Play et de fournir aux développeurs un système simple et standard pour continuer à monétiser leurs applications.

L’ID publicitaire Google n’est pas automatiquement collecté par le SDK Braze et doit être défini manuellement via la méthode Braze.setGoogleAdvertisingId().

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
new Thread(new Runnable() {
  @Override
  public void run() {
    try {
      AdvertisingIdClient.Info idInfo = AdvertisingIdClient.getAdvertisingIdInfo(getApplicationContext());
      Braze.getInstance(getApplicationContext()).setGoogleAdvertisingId(idInfo.getId(), idInfo.isLimitAdTrackingEnabled());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}).start();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
suspend fun fetchAndSetAdvertisingId(
  context: Context,
  scope: CoroutineScope = GlobalScope
) {
  scope.launch(Dispatchers.IO) {
    try {
      val idInfo = AdvertisingIdClient.getAdvertisingIdInfo(context)
      Braze.getInstance(context).setGoogleAdvertisingId(
        idInfo.id,
        idInfo.isLimitAdTrackingEnabled
      )
    } catch (e: Exception) {
      e.printStackTrace()
    }
  }
}

Suivi de localisation

Pour activer la collecte d’emplacements/localisations de Braze, définissez com_braze_enable_location_collection comme true dans votre fichier braze.xml:

1
<bool name="com_braze_enable_location_collection">true</bool>

Journalisation

Par défaut, le niveau de journalisation du SDK Android de Braze est défini sur INFO. Vous pouvez supprimer ces journaux ou définir un niveau de journal différent, tel que VERBOSE, DEBUG, ou WARN.

Activation des journaux

Pour faciliter la résolution des problèmes dans votre application ou réduire les délais de résolution des problèmes avec le service d’assistance de Braze, vous devez activer les journaux détaillés pour le SDK. Lorsque vous envoyez des journaux verbeux à l’assistance Braze, veillez à ce qu’ils commencent dès le lancement de votre application et se terminent bien après l’apparition de votre problème.

Gardez à l’esprit que les journaux verbeux ne sont destinés qu’à votre environnement de développement, et que vous devez donc les désactiver avant de rendre votre application publique.

• application
• xml

1
BrazeLogger.setLogLevel(Log.MIN_LOG_LEVEL);

1
BrazeLogger.logLevel = Log.MIN_LOG_LEVEL

1
BrazeLogger.setLogLevel(Log.VERBOSE);

1
BrazeLogger.logLevel = Log.VERBOSE

1
<integer name="com_braze_logger_initial_log_level">MIN_LOG_LEVEL</integer>

1
<integer name="com_braze_logger_initial_log_level">2</integer>

Vérification des journaux de bord (verbose logs)

Pour vérifier que vos journaux sont définis sur VERBOSE, vérifiez si V/Braze apparaît quelque part dans vos journaux. Si c’est le cas, c’est que l’option de journalisation en mode verbeux a été activée avec succès. Par exemple :

1
2077-11-19 16:22:49.591 ? V/Braze v9.0.01 .bo.app.d3: Request started

Suppression des journaux

Pour supprimer tous les journaux pour le SDK Android de Braze, définissez le niveau de journal sur BrazeLogger.SUPPRESS dans la méthode onCreate() de votre application avant toute autre méthode.

• java
• kotlin

1
BrazeLogger.setLogLevel(BrazeLogger.SUPPRESS);

1
BrazeLogger.setLogLevel(BrazeLogger.SUPPRESS)

Plusieurs clés API

Le cas d’usage le plus fréquent pour les clés API multiples est la séparation des clés API entre les variantes de version de débogage et de publication.

Pour basculer facilement entre plusieurs clés API dans vos versions, nous vous recommandons de créer un fichier braze.xml pour chaque variante de version pertinente. Une variante de version est une combinaison du type de version et de la variété du produit. Par défaut, les nouveaux projets Android sont créés avec les types de constructiondebug et release et sans aucun produit.

Pour chaque variante de création concernée, créez un nouveau site braze.xml dans le répertoire src/<build variant name>/res/values/. Lorsque la variante de version est compilée, elle utilisera la nouvelle clé API.

1
2
3
4
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="com_braze_api_key">REPLACE_WITH_YOUR_BUILD_VARIANT_API_KEY</string>
</resources>

Message in-app exclusif TalkBack

Conformément aux directives d’accessibilité d’Android, le SDK Android de Braze propose par défaut Android Talkback. Pour vous assurer que seul le contenu des messages in-app est lu à haute voix, sans inclure d’autres éléments de l’écran tels que la barre de titre de l’application ou la navigation, vous pouvez activer le mode exclusif pour TalkBack.

Pour activer le mode exclusif pour les messages in-app :

• braze xml
• kotlin
• java

1
<bool name="com_braze_device_in_app_message_accessibility_exclusive_mode_enabled">true</bool>

1
2
3
val brazeConfigBuilder = BrazeConfig.Builder()
brazeConfigBuilder.setIsInAppMessageAccessibilityExclusiveModeEnabled(true)
Braze.configure(this, brazeConfigBuilder.build())

1
2
3
BrazeConfig.Builder brazeConfigBuilder = new BrazeConfig.Builder()
brazeConfigBuilder.setIsInAppMessageAccessibilityExclusiveModeEnabled(true);
Braze.configure(this, brazeConfigBuilder.build());

R8 et ProGuard

La configuration de la réduction du code est automatiquement incluse dans votre intégration de Braze.

Les applications client qui obscurcissent le code Braze doivent stocker des fichiers de mappage de libération pour Braze afin d’interpréter les traces de pile. Si vous souhaitez continuer à conserver tous les codes Braze, ajoutez ce qui suit à votre fichier ProGuard :

1
2
-keep class bo.app.** { *; }
-keep class com.braze.** { *; }