Skip to content

Intégration de message in-app

Cet article de référence explique comment intégrer les messages in-app dans votre application Android ou FireOS.

Les messages in-app vous aident à transmettre du contenu à vos utilisateurs sans interrompre leur journée avec une notification push. Des messages in-app personnalisés et adaptés améliorent l’expérience utilisateur et aident votre audience à tirer le meilleur parti de votre application. Avec plusieurs mises en page et outils de personnalisation, les messages in-app impliquent plus que jamais vos utilisateurs.

Pour voir des exemples d’envois de messages in-app, consultez nos études de cas.

Types de messages in-app

Braze propose plusieurs types de messages in-app par défaut, chacun personnalisable avec des messages, des images, des icônes Font Awesome, des actions de clic, des analyses, des styles modifiables et des schémas de couleurs. Les types actuellement disponibles sont :

Il est également possible de définir votre propre affichage personnalisé des messages in-app.

Tous les messages in-app implémentent l’interface IInAppMessage, qui définit tous les comportements et caractéristiques de base des messages in-app. InAppMessageBase est une classe abstraite qui implémente IInAppMessage et fournit le socle de l’implémentation des messages in-app. Toutes les classes de messages in-app sont des sous-classes de InAppMessageBase.

En outre, il existe une sous-interface de IInAppMessage appelée IInAppMessageImmersive, qui ajoute des boutons d’action et d’analyse, ainsi qu’un texte d’en-tête et un bouton de fermeture.

InAppMessageImmersiveBase est une classe abstraite qui implémente IInAppMessageImmersive et fournit l’implémentation de base des messages in-app de type immersive. Les messages in-app de type Modal constituent une sous-classe de InAppMessageImmersiveBase.

Les messages in-app HTML sont des instances InAppMessageHtml qui implémentent IInAppMessageHtml, une autre sous-classe de IInAppMessage.

Comportements attendus par type de message

Voilà à quoi ressemble l’ouverture de nos types de messages in-app par défaut pour vos utilisateurs.

Les messages in-app Slideup sont ainsi nommés parce qu’ils « surgissent » du haut ou du bas de l’écran. Ils recouvrent une petite partie de l’écran et offrent une fonctionnalité de messagerie efficace et non intrusive.

Un message in-app surgissant du bas d’un écran de téléphone et affichant « Les humains sont compliqués. L’engagement des clients ne devrait pas l’être. » En arrière-plan, le même message in-app est affiché dans l’angle inférieur droit d'une page web.

Les messages in-app de type Modal apparaissent au centre de l’écran et sont encadrés par un panneau transparent. Ils sont utiles pour les messages plus critiques et peuvent être équipés d’un bouton d’action et d’un bouton activé par analyse.

Un message in-app modal au centre d’un écran de téléphone affichant « Les humains sont compliqués. L’engagement des clients ne devrait pas l’être. » En arrière-plan, le même message in-app est affiché au centre d'une page Web.

Les messages in-app Full sont utiles pour maximiser le contenu et l’impact de votre communication avec les utilisateurs. La moitié supérieure d’un full message in-app contient une image, et la moitié inférieure affiche le texte et deux boutons d’action permettant l’analyse.

Un message in-app plein écran s’affiche sur l’ensemble de l’écran du téléphone et affiche : « Les humains sont compliqués. L’engagement des clients ne devrait pas l’être. » En arrière-plan, le même message in-app est affiché en grand au centre d'une page web.

Les messages in-app HTML sont utiles pour créer un contenu utilisateur entièrement personnalisé. Le contenu du message in-app en HTML défini par l’utilisateur est affiché dans un WebView et peut éventuellement contenir d’autres contenus enrichis, tels que des images et des polices, permettant un contrôle total de l’apparence et de la fonctionnalité du message.

Les messages in-app Android prennent en charge une interface JavaScript brazeBridge pour appeler des méthodes SDK Braze pour le Web depuis votre HTML. Consultez nos meilleures pratiques pour plus de détails.

Un message in-app en HTML avec un carrousel de contenu et des boutons interactifs.

Définir des types de messages in-app personnalisés

L’objet de message in-app slideup étend InAppMessageBase. Les messages de type full et modal s’étendent InAppMessageImmersiveBase. L’extension de l’une de ces classes vous permet d’ajouter des fonctionnalités personnalisées à vos messages in-app générés localement.

Intégration

Étape 1 : Enregistrer le gestionnaire de messages in-app Braze

L’affichage des messages in-app est géré par la classe BrazeInAppMessageManager. Chaque activité de votre application doit être enregistrée avec le BrazeInAppMessageManager pour lui permettre d’ajouter des vues de messages in-app à la hiérarchie de vues. Il existe deux manières de le faire :

Intégration de la fonction de rappel du cycle de vie de l’activité (recommandé)

L’intégration du rappel du cycle de vie de l’activité gère automatiquement l’enregistrement des messages in-app ; aucune intégration supplémentaire n’est nécessaire. Il s’agit de l’intégration recommandée pour la gestion des messages in-app.

Enregistrement manuel des messages in-app

Tout d’abord, dans votre Application.onCreate(), appelez ensureSubscribedToInAppMessageEvents():

1
BrazeInAppMessageManager.getInstance().ensureSubscribedToInAppMessageEvents(context);
1
BrazeInAppMessageManager.getInstance().ensureSubscribedToInAppMessageEvents(context)

Ensuite, dans chaque activité où des messages in-app peuvent être affichés, registerInAppMessageManager() doit être appelé dans le onResume() de cette activité :

1
2
3
4
5
6
7
@Override
public void onResume() {
  super.onResume();
  // Registers the BrazeInAppMessageManager for the current Activity. This Activity will now listen for
  // in-app messages from Braze.
  BrazeInAppMessageManager.getInstance().registerInAppMessageManager(activity);
}
1
2
3
4
5
6
public override fun onResume() {
  super.onResume()
  // Registers the BrazeInAppMessageManager for the current Activity. This Activity will now listen for
  // in-app messages from Braze.
  BrazeInAppMessageManager.getInstance().registerInAppMessageManager(this)
}

Enfin, dans toutes les activités où registerInAppMessageManager() a été appelé, unregisterInAppMessageManager() doit être appelé dans le onPause() de cette activité :

1
2
3
4
5
6
@Override
public void onPause() {
  super.onPause();
  // Unregisters the BrazeInAppMessageManager for the current Activity.
  BrazeInAppMessageManager.getInstance().unregisterInAppMessageManager(activity);
}
1
2
3
4
5
public override fun onPause() {
  super.onPause()
  // Unregisters the BrazeInAppMessageManager.
  BrazeInAppMessageManager.getInstance().unregisterInAppMessageManager(this)
}

Étape 2 : Liste de blocage du gestionnaire des messages in-app (facultatif)

Dans votre intégration, vous pouvez exiger que certaines activités de votre application n’affichent pas de messages in-app. L’intégration du rappel du cycle de vie de l’activité offre un moyen simple d’y parvenir.

L’exemple de code suivant ajoute deux activités à la liste de blocage de l’enregistrement des messages in-app, SplashActivity et SettingsActivity:

1
2
3
4
5
6
7
8
9
10
public class MyApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    Set<Class> inAppMessageBlocklist = new HashSet<>();
    inAppMessageBlocklist.add(SplashActivity.class);
    inAppMessageBlocklist.add(SettingsActivity.class);
    registerActivityLifecycleCallbacks(new BrazeActivityLifecycleCallbackListener(inAppMessageBlocklist));
  }
}
1
2
3
4
5
6
7
8
9
class MyApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    val inAppMessageBlocklist = HashSet<Class<*>>()
    inAppMessageBlocklist.add(SplashActivity::class.java)
    inAppMessageBlocklist.add(SettingsActivity::class.java)
    registerActivityLifecycleCallbacks(BrazeActivityLifecycleCallbackListener(inAppMessageBlocklist))
  }
}
CETTE PAGE A-T-ELLE ÉTÉ UTILE?
New Stuff!