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.
Pour les messages in-app contenant des boutons, le message clickAction
sera également inclus dans la charge utile finale si l’action de clic est ajoutée avant l’ajout du texte du bouton.
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.
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.
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.
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.
Actuellement, nous ne prenons pas en charge l’affichage de messages in-app HTML personnalisés dans un iFrame sur les plateformes iOS et Android.
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
Si vous avez fait l’intégration du cycle de vie de l’activité, vous ne devriez pas réaliser une intégration manuelle 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))
}
}