Aller au contenu principal

Guide d'Intégration SDK Android

Cette page explique comment implémenter le SDK Android pour Rokt Ecommerce afin de fournir des expériences client plus pertinentes lors du paiement. Le SDK vous permet de déclencher et de suivre ces expériences (comme l'affichage d'offres sur les pages de confirmation) en se déclenchant sur des pages configurées et en transmettant les données utilisateur et transactionnelles à Rokt pour la personnalisation et la mesure.

Votre représentant de compte dédié vous aidera à configurer votre compte pour le SDK Android. Ils vous fourniront à la fois la clé et le secret nécessaires pour initialiser le SDK ainsi que des ressources supplémentaires nécessaires pour rendre les expériences les plus pertinentes pour vos clients.

remarque

Ces instructions nécessitent des ressources de développement pour être complétées. Si vous avez besoin d'une assistance supplémentaire, veuillez contacter votre gestionnaire de compte Rokt. Les magasins Shopify peuvent configurer un emplacement Rokt en quelques secondes en utilisant l'application Rokt Ecommerce — aucun codage nécessaire !

1. Ajouter des dépendances​

Mettez à jour votre fichier gradle pour inclure les dépendances nécessaires pour le SDK :

dependencies {
    implementation("com.mparticle:android-rokt-kit:5.73.0")
    implementation("com.mparticle:android-core:5.73.0")
}

2. Initialiser le SDK dans votre application​

Le SDK Android peut être configuré en utilisant un objet MParticleOptions et une classe builder dans le onCreate() de la classe Application. Le SDK Android mParticle doit être initialisé avant tout autre appel API du SDK.

attention

Assurez-vous de remplacer your-key et your-secret dans l'exemple de code ci-dessus par la clé et le secret fournis par votre représentant de compte Rokt dédié.

import com.mparticle.MParticle
import com.mparticle.MParticleOptions

class YourApplicationClass : Application() {
    override fun onCreate() {
        super.onCreate()
        // Identifier l'utilisateur actuel :
        // Si vous n'avez pas l'adresse e-mail de l'utilisateur, vous pouvez passer une valeur nulle
        val identifyRequest = IdentityApiRequest.withEmptyUser()
        // Si vous utilisez une adresse e-mail non hachée, définissez-la dans 'email'.
        .email("j.smith@example.com")
        .build()
        // Si l'utilisateur est identifié avec son adresse e-mail, définissez des attributs utilisateur supplémentaires.
        val identifyTask = BaseIdentityTask()
            .addSuccessListener { identityApiResult ->
                val user = identityApiResult.user
                user.setUserAttribute("example attribute key", "example attribute value")
            }
        val options: MParticleOptions = MParticleOptions.builder(this)
        .credentials(
            "your-key",   // La clé fournie par votre représentant de compte Rokt
            "your-secret" // Le secret fourni par votre représentant de compte Rokt
        ).environment(MParticle.Environment.Development)  // Spécifiez l'environnement de données avec environment:
        // Réglez-le sur .development si vous êtes encore en train de tester votre intégration.
        // Réglez-le sur .production si votre intégration est prête pour les données de production.
        // La valeur par défaut est .autoDetect qui tente de détecter automatiquement l'environnement
        .build()

        MParticle.start(options)
    }
}
attention

Assurez-vous de remplacer your-key et your-secret dans l'exemple de code ci-dessus par la clé et le secret fournis par votre représentant de compte Rokt dédié.

Identifier l'utilisateur​

Lorsque le SDK est initialisé, il peut identifier l'utilisateur actuel afin que toutes les données collectées lui soient correctement attribuées et pour s'assurer qu'il voit les publicités les plus pertinentes en fonction de son comportement.

Le script d'initialisation du SDK inclut un objet appelé identifyRequest :

val identifyRequest = IdentityApiRequest.withEmptyUser()
.email("j.smith@example.com")
.build()

Dans identifyRequest, passez l'adresse e-mail de l'utilisateur dans le champ email.

Définir des attributs utilisateur supplémentaires​

Le script d'initialisation inclut une fonction de rappel (callback) qui vous permet de définir des attributs utilisateur supplémentaires si l'utilisateur est identifié avec succès par son adresse e-mail :

val identifyTask = BaseIdentityTask()
.addSuccessListener { identityApiResult ->
    val user = identityApiResult.user
    user.setUserAttribute("example attribute key", "example attribute value")
}

Initialisation avec des polices​

Au lieu de fournir vos polices souhaitées sur One Platform ou en plus de cela, vous pouvez choisir d'utiliser les polices déjà intégrées à votre application. Cela présente l'avantage d'éliminer la possibilité que les polices soient téléchargées au moment de l'initialisation, réduisant ainsi l'utilisation du réseau et les risques d'erreurs de téléchargement. Vous pouvez choisir d'utiliser soit les ressources de polices situées dans le répertoire assets de votre application, soit de passer vos propres objets Typeface.

Utilisation des polices d'actifs​

Vous pouvez utiliser les polices stockées dans le répertoire assets de votre application. Pour cela, vous pouvez passer une map à la méthode init qui associe les noms postscript des polices au chemin d'accès dans le répertoire des assets (où le répertoire des assets est le répertoire racine). Les noms postscript doivent correspondre à ceux utilisés dans votre mise en page, veuillez vérifier avec votre gestionnaire de compte si vous n'êtes pas sûr.

import com.mparticle.MParticle
import com.mparticle.MParticleOptions

class YourApplication : Application() {
    override fun onCreate() {
        ...
        val options: MParticleOptions = MParticleOptions.builder(this)
            .credentials(
                "your-key",   // La clé fournie par votre représentant de compte Rokt
                "your-secret" // Le secret fourni par votre représentant de compte Rokt
            ).environment(MParticle.Environment.Development)  // Spécifiez l'environnement de données avec environment:
            .roktOptions(RoktOptions(fontFilePathMap = mapOf("Arial-Bold" to "fonts/arialbold.otf")))
            .build()
        MParticle.start(options)
        ...
    }
}

3. Identifier l'utilisateur​

Chaque fois que l'utilisateur fournit son adresse e-mail après l'initialisation du SDK (par exemple, lorsqu'il se connecte ou effectue un achat), vous devez appeler la méthode identify pour transmettre son e-mail à Rokt. Cela garantit que les données sont correctement attribuées à l'utilisateur actuel.

3.1 Créer un identifyRequest​

Pour identifier l'utilisateur, créez d'abord un objet identifyRequest pour contenir l'adresse e-mail de l'utilisateur.

Si vous fournissez une adresse e-mail non hachée, utilisez :

val identifyRequest = IdentityApiRequest.withEmptyUser()
    .email("j.smith@example.com")
    .build()

3.2 Définir des attributs utilisateur supplémentaires​

Ensuite, vous avez la possibilité de définir des attributs utilisateur supplémentaires lors de l'identification d'un utilisateur en créant une fonction de rappel (callback). Si la requête identifyRequest réussit, alors les attributs utilisateur que vous définissez avec setUserAttribute sont assignés à l'utilisateur.

val identifyTask = BaseIdentityTask()
    .addSuccessListener { identityApiResult ->
        val user = identityApiResult.user
        user.setUserAttribute("example attribute key", "example attribute value")
    }

3.3 Appeler la méthode identify​

Enfin, après avoir créé votre identifyRequest et votre identityCallback, pour définir des attributs supplémentaires, appelez la méthode identify, en passant les objets identifyRequest et identityCallback que vous venez de créer :

MParticle.getInstance()?.Identity()?.identify(identifyRequest)

Par exemple, pour identifier un utilisateur nommé Jane Smith avec l'adresse email j.smith@example.com (et vous n'avez pas besoin de hacher son adresse email), vous utiliseriez :

val identifyRequest = IdentityApiRequest.withEmptyUser()
    .email("j.smith@example.com")
    .build()

val identifyTask = BaseIdentityTask()
.addSuccessListener { identityApiResult ->
    val user = identityApiResult.user
    user.setUserAttribute("example attribute key", "example attribute value")
}

MParticle.getInstance()?.Identity()?.identify(identifyRequest)

3. Suivre les attributs utilisateur​

Vous pouvez utiliser le SDK Rokt pour collecter des attributs utilisateur séparément des événements. Les attributs utilisateur sont distincts des attributs personnalisés lors du suivi des événements. Le SDK associera tous les attributs utilisateur collectés dans une session donnée aux événements déclenchés dans la même session.

Pour collecter des attributs utilisateur, le code suivant doit être exécuté dans votre application immédiatement après l'initialisation du SDK Rokt, et avant d'enregistrer un événement.

import com.mparticle.MParticle

// Récupérez l'utilisateur actuel. Cela ne réussira que si vous avez identifié l'utilisateur lors de l'initialisation du SDK ou en appelant la méthode identify.
val currentUser = MParticle.getInstance()?.Identity()?.currentUser

// Une fois que vous avez correctement défini l'utilisateur actuel sur `currentUser`, vous pouvez définir des attributs utilisateur avec :
currentUser?.setUserAttribute("custom-attribute-name", "custom-attribute-value")
// Remarque : tous les attributs utilisateur (y compris les attributs de liste et les tags) doivent avoir des noms distincts.

// Rokt recommande de définir autant que possible les attributs utilisateur suivants :
currentUser?.setUserAttribute("firstname", "John")
currentUser?.setUserAttribute("lastname", "Doe")
// Les numéros de téléphone peuvent être formatés soit comme '1234567890', soit comme '+1 (234) 567-8901'
currentUser?.setUserAttribute("mobile", "3125551515")
currentUser?.setUserAttribute("age", "33")
currentUser?.setUserAttribute("gender", "M")
currentUser?.setUserAttribute("city", "Brooklyn")
currentUser?.setUserAttribute("state", "NY")
currentUser?.setUserAttribute("zip", "123456")
currentUser?.setUserAttribute("dob", "yyyymmdd")
currentUser?.setUserAttribute("title", "Mr")
currentUser?.setUserAttribute("language", "en")
currentUser?.setUserAttribute("value", "52.25")
currentUser?.setUserAttribute("predictedltv", "136.23")

// Vous pouvez créer un attribut utilisateur pour contenir une liste de valeurs
val attributeList = ArrayList<String>()
attributeList.add("documentary")
attributeList.add("comedy")
attributeList.add("romance")
attributeList.add("drama")
currentUser?.setUserAttributeList("favorite-genres", attributeList)

// Pour supprimer un attribut utilisateur, appelez removeUserAttribute et passez le nom de l'attribut. Tous les attributs utilisateur partagent le même espace de clés.
currentUser?.removeUserAttribute("attribute-to-remove")

4. Capturer les événements du tunnel de conversion​

Le SDK Rokt vous permet de mettre en œuvre le suivi des événements pour collecter des données décrivant le parcours de vos utilisateurs à travers votre application. Vous pouvez ensuite utiliser ces données pour optimiser l'expérience de vos utilisateurs.

Il existe trois types principaux d'événements que vous pouvez enregistrer avec le SDK :

  • Événements de vue d'écran : Ce sont des événements que vous pouvez déclencher lorsqu'un écran de votre application est chargé.
  • Événements personnalisés : Ce sont des événements libres que vous créez pour suivre des informations spécifiques à votre application.
  • Événements commerciaux : Ce sont des événements spécifiques au commerce électronique qui peuvent décrire les différentes étapes de l'expérience d'achat, y compris l'ajout d'articles à un panier et la réalisation d'un achat final.

Lors de la première intégration avec le SDK Rokt, commencez par mettre en œuvre le suivi des vues d'écran. Pour en savoir plus sur le suivi des événements personnalisés et commerciaux, consultez l'Annexe.

Suivre les vues d'écran​

L'un des types d'événements les plus basiques que vous pouvez suivre est la vue d'écran. Pour enregistrer une vue d'écran, appelez la méthode MParticle.getInstance().logScreen() dès que l'écran se charge, en passant le nom de l'écran sous forme de chaîne et une carte de hachage optionnelle contenant des attributs descriptifs.

Le nom que vous passez doit être l'un d'un ensemble limité d'écrans, comme 'homepage' ou 'product detail page'.

import com.mparticle.MParticle

val screenInfo = HashMap<String, String>()
screenInfo["rating"] = "5"
screenInfo["property_type"] = "hotel"

MParticle.getInstance()?.logScreen("Details", screenInfo)

5. Afficher un Placement​

La principale valeur du SDK Rokt est débloquée par la méthode selectPlacements, qui sert un placement (ou une mise en page) hyper-pertinent pour vos clients en fonction des attributs que vous fournissez.

Une fois l'intégration Rokt initialisée, vous pouvez appeler la méthode selectPlacements depuis la page où votre mise en page sera rendue. Elle doit être appelée le plus tôt possible, et une fois que tous les attributs requis sont disponibles, pour garantir la meilleure expérience pour vos utilisateurs.

Lors de l'appel à selectPlacements, vous devez fournir au moins les attributs email, firstname, lastname, billingzipcode et confirmationref.

Placements en superposition​

val attributes = mapOf(
"email" to "j.smith@example.com",
"firstname" to "Jenny",
"lastname" to "Smith",
"billingzipcode" to "90210",
"confirmationref" to "54321",
)

// Si vous souhaitez utiliser des polices personnalisées pour votre placement, créez une map fontTypefaces
val fontTypefaces: MutableMap<String, WeakReference<android.graphics.Typeface>> = HashMap<String, WeakReference<android.graphics.Typeface>>()
fontTypefaces["Arial-Bold"] = WeakReference<android.graphics.Typeface>(yourTypefaceObject)

// Vous pouvez également vouloir passer des paramètres optionnels tels que `RoktConfig` qui vous permettront de personnaliser l'interface utilisateur du placement, principalement pour savoir si l'application est en mode sombre ou clair. Des paramètres optionnels supplémentaires tels que les vues intégrées et les callbacks sont montrés plus bas.

val roktConfig = RoktConfig.Builder().colorMode(RoktConfig.ColorMode.LIGHT).build()

MParticle.getInstance()?.Rokt()?.selectPlacements(
    identifier = "RoktExperience",
    attributes = attributes,
    fontTypefaces = fontTypefaces,
    config = roktConfig,
    embeddedViews = null, // placeHolders optionnels (voir Placements intégrés ci-dessous)
    callbacks = null, // callbacks optionnels (définir comme approprié, voir ci-dessous)
)
remarque

Si vous souhaitez mettre à jour le nom de la vue RoktExperience ou le nom du placeholder RoktEmbedded1 avec une valeur différente, contactez votre gestionnaire de compte Rokt pour vous assurer que les placements Rokt sont configurés de manière cohérente.

Pour une liste complète des attributs pris en charge, voir Attributs de données.

Votre équipe dédiée Rokt configurera vos dispositions de placement pour vous afin qu'elles correspondent à votre marque et à votre guide de style UX.

Fonctions optionnelles​

FonctionObjectif
Rokt.close()Utilisé pour fermer automatiquement les placements en superposition.

Placements intégrés​

Les placements intégrés partagent toutes les mêmes recommandations et exigences que les placements en superposition ci-dessus, mais vous permettent d'intégrer les vues de placement dans votre interface utilisateur (UI). Nous utiliserons également cette section pour fournir des exemples des diverses fonctionnalités avancées permises par Rokt. La classe MpRoktEventCallback, qui est passée à Rokt via le paramètre callbacks, vous permet de répondre à divers événements qui se produisent lors de la génération et de l'affichage d'un placement.

Si votre application Android nécessite une mise en page intégrée, ajoutez le RoktEmbeddedView à votre fichier XML de mise en page :

remarque

Cela s'applique uniquement aux applications qui nécessitent des mises en page intégrées.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout     
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.mparticle.rokt.RoktEmbeddedView
        android:id="@+id/roktEmbeddedView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Nous conseillons de définir la hauteur du placement sur wrap_content afin que le placement puisse ajuster sa hauteur dynamiquement.

import com.mparticle.rokt.RoktConfig
import com.mparticle.rokt.RoktEmbeddedView
import com.mparticle.MpRoktEventCallback
import com.mparticle.UnloadReasons

class ConfirmActivity : Activity() {
    val callbacks = object : MpRoktEventCallback {
        override fun onLoad() {
            // Callback optionnel pour lorsque le placement Rokt se charge
        }

        override fun onUnload(reason: UnloadReasons) {
```kotlin
// Callback optionnel pour lorsque le placement Rokt se décharge
}

override fun onShouldShowLoadingIndicator() {
    // Callback optionnel pour afficher un indicateur de chargement
}

override fun onShouldHideLoadingIndicator() {
    // Callback optionnel pour masquer un indicateur de chargement
}
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val instance = MParticle.getInstance()
    setContentView(R.layout.activity_main)
    val attributes = hashMapOf(
        Pair("email", "j.smith@example.com"),
        Pair("firstname", "Jenny"),
        Pair("lastname", "Smith"),
        Pair("mobile", "(323) 867-5309"),
        Pair("postcode", "90210"),
        Pair("country", "US"),
    )
    val roktWidget = findViewById<RoktEmbeddedView>(R.id.roktEmbeddedView)
    val placeHolders = mapOf(Pair("RoktEmbedded1", WeakReference(roktWidget)))
    val fontTypefaces: MutableMap<String, WeakReference<android.graphics.Typeface>> = HashMap<String, WeakReference<android.graphics.Typeface>>()
    fontTypefaces["Arial-Bold"] = WeakReference<android.graphics.Typeface>(yourTypefaceObject)

    val roktConfig = RoktConfig.Builder().colorMode(RoktConfig.ColorMode.LIGHT).build()

    instance?.Rokt()?.selectPlacements(
        identifier = "RoktExperience",
        attributes = attributes,
        fontTypefaces = fontTypefaces,
        callbacks = callbacks,
        embeddedViews = placeHolders,
        config = roktConfig
    )
}
}

API des événements globaux​

Le SDK fournit le statut sous forme de flux via l'API Rokt.globalEvents. Les utilisateurs du SDK peuvent exploiter le mécanisme Kotlin Flow pour consommer le statut.

import com.rokt.roktsdk.RoktEvent

// owner: LifecycleOwner
owner.lifecycleScope.launch {
    Rokt.globalEvents().collect { event ->
        if (event is RoktEvent.InitComplete)
            Log.d("Rokt", "received init completed $event")
    }
}

Événements​

Le SDK fournit également les événements sur chaque page sous forme de flux via l'API MParticle.getInstance()?.Rokt()?.events. Les utilisateurs du SDK peuvent exploiter le mécanisme Kotlin Flow pour consommer les événements produits par le SDK.

import com.mparticle.MParticle

// owner: LifecycleOwner
owner.lifecycleScope.launch {
    owner.lifecycle.repeatOnLifecycle(Lifecycle.State.CREATED) {
        MParticle.getInstance()?.Rokt()?.events("RoktExperience").collect { roktEvent ->
            Log.d("RoktEvent", "Event received $roktEvent")
        }
    }
}
ÉvénementDescriptionParamètres
ShowLoadingIndicatorDéclenché avant que le SDK n'appelle le backend Rokt
HideLoadingIndicatorDéclenché lorsque le SDK reçoit un succès ou un échec du backend Rokt
OfferEngagementDéclenché lorsque l'utilisateur interagit avec l'offreplacementId: String
PositiveEngagementDéclenché lorsque l'utilisateur interagit positivement avec l'offreplacementId: String
FirstPositiveEngagementDéclenché lorsque l'utilisateur interagit positivement avec l'offre pour la première foisplacementId: String, fulfillmentAttributes: FulfillmentAttributes
PlacementInteractiveDéclenché lorsqu'un emplacement a été rendu et est interactifplacementId: String
PlacementReadyDéclenché lorsqu'un emplacement est prêt à être affiché mais n'a pas encore rendu de contenuplacementId: String
PlacementClosedDéclenché lorsque l'utilisateur ferme un emplacementplacementId: String
PlacementCompletedDéclenché lorsque la progression de l'offre atteint la fin et qu'aucune autre offre n'est disponible à afficher.
Également déclenché lorsque le cache est atteint mais que l'emplacement récupéré ne sera pas affiché car il a été précédemment rejeté		placementId: String
PlacementFailureDéclenché lorsqu'un emplacement n'a pas pu être affiché en raison d'un échec ou lorsqu'aucun emplacement n'est disponible à afficherplacementId: String (optionnel)
OpenUrlDéclenché lorsque l'utilisateur appuie sur une URL qui est configurée pour être envoyée à l'application partenaireplacementId: String, url: String
CartItemInstantPurchaseDéclenché lorsque l'achat de l'article du catalogue est initié par l'utilisateurplacementId: String, cartItemId: String, catalogItemId: String, currency: String, description: String, linkedProductId: String, totalPrice: Double, quantity: Int, unitPrice: Double

Annexe​

Débogage​

Utilisez l'API Rokt.setLoggingEnabled(enable = true) pour activer les journaux de débogage du SDK Rokt.

Utilisation des configurations d'application​

Les applications peuvent désormais transmettre les paramètres de configuration de leur propre environnement d'application. Cela permet au SDK Rokt d'utiliser les configurations personnalisées de l'application au lieu de se fier uniquement aux paramètres par défaut du système.

Objet ColorMode​
ValeurDescription
LIGHTL'application est en mode clair
DARKL'application est en mode sombre
SYSTEML'application utilise le mode couleur système par défaut
EdgeToEdgeDisplay Boolean​
ValeurDescription
true(default)L'application prend en charge le mode d'affichage Edge to Edge
falseL'application ne prend pas en charge le mode d'affichage Edge to Edge
import com.mparticle.MParticle
import com.mparticle.rokt.RoktConfig

// si l'application prend en charge uniquement le mode clair et que l'affichage bord à bord est activé.
val roktConfig = RoktConfig.Builder()
    .edgeToEdgeDisplay(true)
    .build()

MParticle.getInstance()?.Rokt()?.selectPlacements(
    identifier = "RoktExperience",
    attributes = attributes,
    config = roktConfig
)
Objet CacheConfig​
ParamètreDescription
cacheDurationDurée optionnelle en secondes pendant laquelle le SDK Rokt doit mettre en cache l'expérience. La valeur maximale autorisée est de 90 minutes et la valeur par défaut (si la valeur n'est pas fournie ou invalide) est de 90 minutes.
cacheAttributesAttributs optionnels à utiliser comme clé de cache. Si null, tous les attributs envoyés dans selectPlacements seront utilisés comme clé de cache.
import com.mparticle.rokt.CacheConfig
import com.mparticle.rokt.RoktConfig

// pour mettre en cache l'expérience pendant 1200 secondes, en utilisant les attributs email et orderNumber comme clé de cache.
val roktConfig = RoktConfig.Builder()
    .cacheConfig(CacheConfig(
        cacheDurationInSeconds = 1200,
        cacheAttributes = mapOf("email" to "j.smith@example.com", "orderNumber" to "123")
    ))
    .build()

MParticle.getInstance()?.Rokt()?.selectPlacements(
    identifier = "RoktExperience",
    attributes = attributes,
    config = roktConfig
)
Support de Jetpack Compose avec RoktLayout​

Pour les écrans implémentés à l'aide de Jetpack Compose, le SDK fournit le composant RoktLayout, permettant une intégration moderne et déclarative des placements Rokt au sein des applications Android.

La classe RoktLayout offre une interface compatible avec Compose pour afficher les placements Rokt, permettant aux développeurs d'utiliser la syntaxe de l'API Compose sans avoir besoin d'invoquer manuellement selectPlacements. Elle supporte les types de placement Overlay, BottomSheet et Embedded.

Ajouter le composant Jetpack Compose

import com.mparticle.kits.RoktLayout
import com.mparticle.MpRoktEventCallback
import com.mparticle.UnloadReasons

@Composable
fun MainScreen(modifier: Modifier = Modifier) {
    Column(
        modifier = modifier
            .background(Color.LightGray)
            .padding(8.dp),
    ) {
        val attributes = mapOf(
            "email" to "j.smith@example.com",
            "firstname" to "Jenny",
            "lastname" to "Smith",
            "mobile" to "(323) 867-5309",
            "postcode" to "90210",
            "country" to "US"
        )
        val callbacks = object : MpRoktEventCallback {
            override fun onLoad() = println("View loaded")
            override fun onUnload(reason: UnloadReasons) = println("View unloaded due to: $reason")
            override fun onShouldShowLoadingIndicator() = println("Show loading indicator")
            override fun onShouldHideLoadingIndicator() = println("Hide loading indicator")
        }
        val roktConfig = RoktConfig.Builder()
            .colorMode(RoktConfig.ColorMode.DARK)
            .cacheConfig(CacheConfig(
                cacheDurationInSeconds = 1200,
                cacheAttributes = mapOf("email" to "j.smith@example.com")
            ))
            .build()

        RoktLayout(
            sdkTriggered = true,
            identifier = "RoktExperience",
            attributes = attributes,
            location = "Location1",
            modifier = Modifier
                .fillMaxWidth()
                .background(Color.Black),
            mpRoktEventCallback = callbacks,
            config = roktConfig
        )
    }
}

Paramètres​
ParamètreTypeDescription
sdkTriggeredBooleanContrôle quand le placement doit être déclenché.
identifierStringL'identifiant de la vue/expérience Rokt (par exemple, "RoktExperience").
locationString?Nom de localisation optionnel pour les placements intégrés (par exemple, "Location1").
attributesMap<String, String>Carte d'attributs à passer au placement (par exemple, ciblage des détails de l'utilisateur).
modifierModifierModifier de Compose pour personnaliser la mise en page, le style et le comportement de l'interface utilisateur.
callbacksMpRoktEventCallbackCallback optionnel pour gérer les événements de placement (chargement, déchargement, état de chargement).

Suivre des événements personnalisés​

Après avoir implémenté les placements et le suivi des vues d'écran en suivant les instructions ci-dessus, vous pouvez souhaiter mettre en œuvre un suivi d'événements supplémentaires.

Vous pouvez définir et suivre des événements personnalisés en utilisant l'objet MPEvent.Builder et en passant le nom de l'événement, le type d'événement et une carte d'attributs personnalisés.

Les types d'événements personnalisés pris en charge pour Kotlin et Java sont :

  • Navigation - Suivre les flux de navigation des utilisateurs et les transitions de page au sein de votre application
  • Location - Enregistrer les interactions et mouvements basés sur la localisation de l'utilisateur
  • Search - Capturer les requêtes de recherche et les actions utilisateur liées à la recherche
  • Transaction - Consigner les transactions financières et les activités liées aux achats
  • UserContent - Suivre le contenu généré par les utilisateurs comme les avis, commentaires ou publications
  • UserPreference - Enregistrer les paramètres, préférences et choix de personnalisation des utilisateurs
  • Social - Capturer les interactions sur les réseaux sociaux et les activités de partage
val customAttributes = mapOf(
"category" to "Destination Intro",
"title" to "Paris",
)

val event = MPEvent.Builder("Video Watched", EventType.Navigation)
.customAttributes(customAttributes)
.build()

MParticle.getInstance()?.logEvent(event)

Suivre les événements commerciaux​

Le suivi d'un événement commercial nécessite trois étapes :

  1. Définir le ou les produits qui sont achetés
  2. Créer un objet pour contenir un résumé de la transaction
  3. Enregistrer l'événement, y compris votre définition de produit et le résumé de la transaction
import com.mparticle.commerce.CommerceEvent
import com.mparticle.commerce.Product
import com.mparticle.commerce.TransactionAttributes

// 1. Créer les produits

// Créer une carte optionnelle d'attributs personnalisés pour le produit sous forme de paires clé/valeur de chaînes
val customAttributes = mutableMapOf<String, String>()
customAttributes["ocean-view"] = "true"
customAttributes["balcony"] = "false"

val product = Product.Builder("Double Room - Econ Rate", "econ-1", 100.00)
    .quantity(4.0)
    // Inclure la carte des attributs personnalisés créée ci-dessus
    .customAttributes(customAttributes)
    .build()

// 2. Résumer la transaction

val attributes = TransactionAttributes("foo-transaction-id")
    .setRevenue(430.00)
    .setTax(30.00)

// 3. Enregistrer l'événement d'achat

val event = CommerceEvent.Builder(Product.PURCHASE, product)
    .transactionAttributes(attributes)
    // Les attributs personnalisés optionnels pour l'événement d'achat peuvent être ajoutés sous forme de carte de paires clé/valeur de chaînes
    .customAttributes(mapOf("sale" to "true", "phone-booking" to "true"))
    // Vous pouvez également créer une carte qui est ensuite passée à la méthode du constructeur customAttributes. Par exemple :
    //    val customTransactionAttributes = mutableMapOf<String, String>()
    //    customTransactionAttributes["sale"] = "true"
    //    customTransactionAttributes["phone-booking"] = "true"
    //    .customAttributes(customTransactionAttributes)
    .build()

MParticle.getInstance()?.logEvent(event)
Cet article vous a-t-il été utile ?
Last updated Oct 29, 2025