Aller au contenu principal

Guide d'Intégration SDK iOS

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

Votre représentant de compte dédié vous aidera à configurer votre compte pour le SDK iOS. 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 boutiques Shopify peuvent configurer un emplacement Rokt en quelques secondes à l'aide de l'application Rokt Ecommerce — aucun codage nécessaire !

1. Ajouter le SDK Rokt à votre application iOS​

En utilisant soit SPM (Swift Package Manager) soit CocoaPods, incluez le SDK Rokt dans votre application :

CocoaPods​

Pour intégrer le SDK en utilisant CocoaPods, spécifiez-le dans votre Podfile avec :

pod 'mParticle-Apple-SDK', '~> 8.0'
pod 'mParticle-Rokt','~> 8.0'

SPM​

Pour intégrer le SDK en utilisant Swift Package Manager :

  1. Ouvrez votre projet dans Xcode et allez à l'onglet "Package Dependencies".
  2. Cliquez sur le bouton + sous la liste des Packages.
  3. Entrez l'URL du dépôt https://github.com/mParticle/mparticle-apple-sdk dans la boîte de recherche en haut à droite, choisissez mparticle-apple-sdk dans la liste des packages, et changez "Dependency Rule" en "Up to Next Major Version".
  4. Cliquez sur le bouton "Add Package" en bas à droite, et choisissez le "Package Product" appelé mParticle-Apple-SDK. Si vous souhaitez utiliser une version du SDK qui n'inclut pas le support de suivi de localisation, choisissez mParticle-Apple-SDK-NoLocation.
  5. Répétez les étapes 3 et 4 pour l'URL du dépôt Rokt Kit https://github.com/mparticle-integrations/mparticle-apple-integration-rokt.git.
    • Si vous choisissez le package product mParticle-Apple-SDK-NoLocation, vous devrez importer le SDK en utilisant import mParticle_Apple_SDK_NoLocation au lieu de import mParticle_Apple_SDK.

2. Initialiser le SDK Rokt​

Pour initialiser le SDK, insérez l'extrait d'initialisation suivant dans votre fichier AppDelegate :

attention
  • Assurez-vous de remplacer your-key et your-secret par la clé et le secret fournis par votre équipe dédiée Rokt.
import mParticle_Apple_SDK

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // Initialiser le SDK
    let options = MParticleOptions(key: "your-key",
    secret: "your-secret")
    // Spécifiez l'environnement de données avec environment:
    // Réglez-le sur .development si vous testez encore 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 l'environnement automatiquement
    options.environment = .development
    // Identifier l'utilisateur actuel :
    let identifyRequest = MPIdentityApiRequest.withEmptyUser()
    // Si vous utilisez une adresse e-mail non hachée, définissez-la dans 'email'.
    identifyRequest.email = "j.smith@example.com"
    // Si l'utilisateur est identifié avec son adresse e-mail, définissez des attributs utilisateur supplémentaires.
    options.identifyRequest = identifyRequest
    options.onIdentifyComplete =  {(result: MPIdentityApiResult?, error: Error?) in
    if let user = result?.user {
        user.setUserAttribute("example attribute key", value: "example attribute value")
    } else {
        //gérer l'échec - voir la section "Gestion des erreurs" ci-dessous
    }
}
    MParticle.sharedInstance().start(with: options)
    return true
}

2.1 Identifier l'utilisateur lors de l'initialisation​

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 :

let identifyRequest = MPIdentityApiRequest.withEmptyUser()
identifyRequest.email = "j.smith@example.com"
options.identifyRequest = identifyRequest

2.2 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 correctement identifié avec son adresse e-mail :

options.onIdentifyComplete =  {(result: MPIdentityApiResult?, error: Error?) in
    if let user = result?.user {
        user.setUserAttribute("example attribute key", value: "example attribute value")
    } else {
        //gérer l'échec - voir la section "Gestion des erreurs" ci-dessous
    }
}

3. Identifier l'utilisateur lorsque les données deviennent disponibles​

Dès 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, commencez par créer un objet identifyRequest pour contenir l'adresse e-mail de l'utilisateur.

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

let identifyRequest = MPIdentifyApiRequest.withEmptyUser()
identifyRequest.email = "j.smith@example.com"

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.

let identifyCallback = {(result: MPIdentifyApiResult?) in
    if let user = result?.user {
        user.setUserAttribute("example attribute key", value: "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.sharedInstance().identity.identify(identifyRequest, completion: identityCallback)

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

let identifyRequest = MPIdentifyApiRequest.withEmptyUser()
identifyRequest.email = "j.smith@example.com"

let identifyCallback = {(result: MPIdentifyApiResult?) in
    if let user = result?.user {
        user.setUserAttribute("example attribute key", value: "example attribute value")
    }
}

MParticle.sharedInstance().identity.identify(identifyRequest, completion: identityCallback)

4. 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 mParticle_Apple_SDK

// 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.
let currentUser = MParticle.sharedInstance().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", value: "custom-attribute-value")
// Remarque : tous les attributs utilisateur (y compris les attributs de liste et les balises) doivent avoir des noms distincts.

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

// Vous pouvez créer un attribut utilisateur pour contenir une liste de valeurs
currentUser?.setUserAttributeList("favorite-genres", values: ["documentary", "comedy", "romance", "drama"])

// 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?.removeAttribute("attribute-to-remove")

5. 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 les 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 principaux types 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'une page de votre application est chargée.
  • É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​

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 .logScreen, en passant le nom de l'écran sous forme de chaîne de caractères. Le nom que vous passez doit être un ensemble limité de pages, comme 'homepage' ou 'product detail page'. Vous pouvez également inclure des attributs personnalisés supplémentaires dans le tableau eventInfo.

MParticle.sharedInstance().logScreen(
"homepage",
eventInfo: ["custom-attribute": custom-value]
)

6. Afficher un Placement​

La principale valeur du SDK Rokt est débloquée grâce à la méthode selectPlacements, qui sert un placement (ou 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 dès que 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 pour offrir à vos utilisateurs le placement le plus pertinent.

Placements en superposition​

import mParticle_Apple_SDK
let attributes = [
    "email": "test@gmail.com",
    "firstname": "Jenny",
    "lastname": "Smith",
    "billingzipcode": "07762",
    "confirmationref": "54321"
]

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes)

Vous pouvez également souhaiter passer des paramètres optionnels tels que MPRoktConfig 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 (rappels) sont montrés plus bas.

let roktConfig = MPRoktConfig()
roktConfig.colorMode = .light

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, callbacks: nil, config: roktConfig)
remarque

Si vous souhaitez mettre à jour l'identifiant RoktExperience ou l'identifiant intégré 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.

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.

import mParticle_Apple_SDK

let attributes = [
    "email": "test@gmail.com",
    "firstname": "Jenny",
    "lastname": "Smith",
    "billingzipcode": "07762",
    "confirmationref": "54321"
]

let roktFrame = CGRect(x: 0, y: 0, width: 320, height: 50)
let roktView = MPRoktEmbeddedView(frame: roktFrame)
let embeddedViews = ["RoktEmbedded1": roktView]

let roktConfig = MPRoktConfig()
roktConfig.colorMode = .light

let callbacks = MPRoktEventCallback()
callbacks.onLoad = {
    // Callback optionnel pour lorsque le placement Rokt se charge
}
callbacks.onUnLoad = {
    // Callback optionnel pour lorsque le placement Rokt se décharge
}
callbacks.onShouldShowLoadingIndicator = {
    // Callback optionnel pour afficher un indicateur de chargement
}
callbacks.onShouldHideLoadingIndicator = {
    // Callback optionnel pour masquer un indicateur de chargement
}
callbacks.onEmbeddedSizeChange = { (placement: String, size: CGFloat) in
    // Callback optionnel pour obtenir le placement sélectionné et la hauteur requise par le placement chaque fois que la hauteur du placement change
}

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: embeddedViews, config: roktConfig, callbacks: callbacks)
remarque

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

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

#```### API des événements globaux

Le SDK fournit le statut du SDK via l'API Rokt.globalEvents.

import Rokt_Widget

Rokt.globalEvents() { roktEvent in
    if let initEvent = roktEvent as? RoktEvent.InitComplete {
        print("Rokt init completed with status: \(initEvent.success)")
    }
}

API des événements​

Le SDK fournit les événements et le statut de chaque vue via l'API Rokt.events.

import mParticle_Apple_SDK

MParticle.sharedInstance().rokt.events("RoktLayout", onEvent: { roktEvent in
    if let event = roktEvent as? MPRoktEvent.MPRoktShowLoadingIndicator {

    } else if let event = roktEvent as? MPRoktEvent.MPRoktHideLoadingIndicator {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPlacementInteractive {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPlacementReady {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktOfferEngagement {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktOpenUrl {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPositiveEngagement {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPlacementClosed {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPlacementCompleted {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktPlacementFailure {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktFirstPositiveEngagement {
        
    } else if let event = roktEvent as? MPRoktEvent.MPRoktCartItemInstantPurchase {
        
    }
})
ÉvénementDescriptionParamètres
MPRoktShowLoadingIndicatorDéclenché avant que le SDK appelle le backend Rokt
MPRoktHideLoadingIndicatorDéclenché lorsque le SDK reçoit un succès ou un échec du backend Rokt
MPRoktPlacementInteractiveDéclenché lorsqu'un placement a été rendu et est interactifplacementId: String
MPRoktPlacementReadyDéclenché lorsqu'un placement est prêt à être affiché mais n'a pas encore rendu de contenuplacementId: String
MPRoktOfferEngagementDéclenché lorsque l'utilisateur interagit avec l'offreplacementId: String
MPRoktOpenUrlDéclenché lorsque l'utilisateur appuie sur une URL configurée pour être envoyée à l'application partenaireplacementId: String, url: String
MPRoktPositiveEngagementDéclenché lorsque l'utilisateur interagit positivement avec l'offreplacementId: String
MPRoktPlacementClosedDéclenché lorsqu'un emplacement est fermé par l'utilisateurplacementId: String
MPRoktPlacementCompletedDé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 déjà été rejeté		placementId: String
MPRoktPlacementFailureDéclenché lorsqu'un emplacement n'a pas pu être affiché en raison d'une défaillance ou lorsqu'aucun emplacement n'est disponible à afficherplacementId: String (optionnel)
MPRoktFirstPositiveEngagementDéclenché lorsque l'utilisateur interagit positivement avec l'offre pour la première foisplacementId: String, setFulfillmentAttributes: func (attributes: [String: String])
MPRoktCartItemInstantPurchaseDéclenché lorsqu'un achat est effectué via un emplacementplacementId: String, name: String?, cartItemId: String, catalogItemId: String, currency: String, description: String, linkedProductId: String?, providerData: String, quantity: NSDecimalNumber?, totalPrice: NSDecimalNumber?, unitPrice: NSDecimalNumber?

Annexe​

Débogage​

Vous pouvez activer les journaux de débogage en définissant l'option de configuration suivante lors de l'initialisation du SDK :

Rokt.setLoggingEnabled(enable: true)

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

Utilisation des configurations d'application​

Les applications peuvent désormais envoyer des paramètres de configuration depuis leur propre environnement d'application. Cela permet au SDK iOS d'utiliser des 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
// si l'application ne prend en charge que le mode clair.
let roktConfig = MPRoktConfig()
roktConfig.colorMode = .light

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, callbacks: nil, config: roktConfig)

Objet CacheConfig​

ParamètreDescription
cacheDurationIntervalle de temps (TimeInterval) optionnel pendant lequel 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 Rokt.execute seront utilisés comme clé de cache.
// pour mettre en cache l'expérience pendant 1200 secondes, en utilisant les attributs email et orderNumber comme clé de cache.
let roktConfig = MPRoktConfig()
roktConfig.cacheDuration = TimeInterval(1200)
roktConfig.cacheAttributes = ["email": "j.smith@example.com", "orderNumber": "123"]

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, callbacks: nil, config: roktConfig)

Prise en charge de SwiftUI avec MPRoktLayout​

Si votre application est principalement écrite en SwiftUI, nous avons fourni le composant MPRoktLayout pour une approche déclarative plus moderne afin d'intégrer les placements Rokt dans votre application iOS.

La classe MPRoktLayout offre un moyen compatible avec SwiftUI pour afficher les placements Rokt sans appeler manuellement selectPlacements, prenant en charge les types de placements superposés et intégrés.

Ajout du composant SwiftUI​
import SwiftUI
import mParticle_Apple_SDK
import mParticle_Rokt_Swift

struct OrderConfirmationView: View {
    let attributes = [
        "email": "test@gmail.com",
        "firstname": "Jenny",
        "lastname": "Smith",
        "billingzipcode": "07762",
        "confirmationref": "54321"
    ]
    
    @State private var sdkTriggered = true
    
    var body: some View {
        VStack(alignment: .leading) {
            // Autres composants UI
            Text("Confirmation de commande")
                .font(.title)
            
            // Placement Rokt utilisant SwiftUI
            MPRoktLayout(
                sdkTriggered: $sdkTriggered,
                viewName: "RoktExperience",
                locationName: "RoktEmbedded1", // Pour les placements intégrés
                attributes: attributes,
                config: roktConfig, // MPRoktConfig optionnel
                onEvent: { roktEvent in
                    // Optionnel : Gérer différents types d'événements voir ci-dessus
                }
            ).roktLayout
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
    }
}
Paramètres​
ParamètreTypeDescription
sdkTriggeredBoolContrôle quand le placement doit être déclenché
viewNameStringLe nom de la vue/expérience Rokt (par exemple, "RoktExperience")
locationNameString?Nom de l'emplacement optionnel pour les placements intégrés (par exemple, "RoktEmbedded1")
attributes[String: String]Dictionnaire d'attributs à passer au placement
configMPRoktConfig?Objet de configuration optionnel pour le mode couleur, la mise en cache, etc.
onEvent((MPRoktEvent) -> Void)?Callback optionnel pour gérer tous les événements de placement

Suivre les événements personnalisés​

Vous pouvez définir et suivre des événements personnalisés en appelant logEvent et en passant le nom de l'événement, le type d'événement, et un tableau optionnel contenant tous les attributs personnalisés pour l'événement.

if let event = MPEvent(name: "Video Watched", type: .navigation) {
    event.customAttributes = ["category": "Destination Intro", "title": "Paris"]
    MParticle.sharedInstance().logEvent(event)
}

Les types d'événements personnalisés pris en charge 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 l'utilisateur comme les avis, commentaires ou publications
  • userPreference - Enregistrer les paramètres utilisateur, préférences et choix de personnalisation
  • social - Capturer les interactions et activités de partage sur les réseaux sociaux

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 dans une variable en utilisant MPProduct.init
  2. Créer un objet MPTransactionAttributes pour enregistrer les détails qui résument la transaction
  3. Définir le type d'action et d'événement de produit, puis appeler la méthode logEvent, en incluant votre définition de produit et le résumé de la transaction
// 1. Define the product(s)
let product = MPProduct.init(name: "Double Room",
sku: "econ-1",
quantity: 4,
price: 100.00)

// 2. Summarize the transaction
let attributes = MPTransactionAttributes.init()
attributes.transactionId = "foo-transaction-id"
attributes.revenue = 430.00
attributes.tax = 30.00

// 3. Log the commerce event.
// Several types of "actions" are supported, such as AddToCart and Checkout. This example uses the Purchase product action.
let action = MPCommerceEventAction.purchase;
let event = MPCommerceEvent.init(action: action, product: product)
event.transactionAttributes = attributes
MParticle.sharedInstance().logEvent(event)

Lors de l'enregistrement d'une action produit, vous devez spécifier l'un des types d'actions produit suivants :

  • AddToCart
  • RemoveFromCart
  • Checkout
  • CheckoutOption
  • Click
  • ViewDetail
  • Purchase
  • Refund
  • AddToWishlist
  • RemoveFromWishlist
  • Unknown
Cet article vous a-t-il été utile ?
Last updated Oct 29, 2025