Guide d'Intégration SDK+ iOS

Platform

WebiOSAndroidFlutterReact NativeMAUICordova

Language

For Rokt Ecommerce partners. This complete guide is for ecommerce businesses integrating Rokt into transaction experiences they own. It is not an advertiser implementation guide. Advertisers should use the Rokt Ads integration guides.

Cette page explique comment implémenter le SDK+ Rokt Ecommerce pour iOS. Le SDK+ transmet les données utilisateur et transactionnelles à Rokt sur les écrans configurés afin que Rokt puisse afficher des expériences pertinentes, telles que des offres sur les écrans de confirmation.

1. Add the Rokt SDK+ to Your iOS App#

Le SDK+ Rokt nécessite une cible de déploiement minimale de iOS 15.0. Utilisez Swift Package Manager ou CocoaPods — selon ce que votre projet utilise déjà.

1Add the Rokt SDK+ to your iOS app#

Install method

Dans Xcode, sélectionnez File → Add Package Dependencies, entrez https://github.com/ROKT/rokt-sdk-plus-ios.git, définissez la règle de dépendance sur Up to Next Major Version, et ajoutez le produit RoktSDKPlus à votre cible d'application. Ou épinglez dans Package.swift :

Package	URL du dépôt	Produit
Rokt SDK+ pour iOS	https://github.com/ROKT/rokt-sdk-plus-ios.git	RoktSDKPlus

Package.swift

dependencies: [
  .package(url: "https://github.com/ROKT/rokt-sdk-plus-ios.git", from: "9.2.0"),
]

2. Initialize the Rokt SDK+#

Insérez le fragment d'initialisation suivant dans votre fichier AppDelegate. Remplacez your-key et your-secret par la clé et le secret fournis par votre équipe Rokt.

AppDelegate initialization

import mParticle_Apple_SDK
import RoktPaymentExtension

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
  // Initialize the SDK+
  let options = MParticleOptions(key: "your-key",
                                 secret: "your-secret")
  // Specify the data environment with environment:
  // Set it to .development if you are still testing your integration.
  // Set it to .production if your integration is ready for production data.
  // The default is .autoDetect which attempts to detect the environment automatically
  options.environment = .development

  // Enter your custom subdomain if you are using a first-party domain configuration (optional)
  let networkOptions = MPNetworkOptions()
  networkOptions.customBaseURL = URL(string: "https://rkt.example.com")
  options.networkOptions = networkOptions

  // Identify the current user:
  let identifyRequest = MPIdentityApiRequest.withEmptyUser()

  // If you're using an un-hashed email address, set it in 'email'.
  identifyRequest.email = "j.smith@example.com"

  // If you're using a hashed email address, set it in 'other' instead of email
  identifyRequest.setIdentity("sha256 hashed email goes here", identityType: .other)
  // Customer phone number in E.164 format.
  identifyRequest.setIdentity("+13125551515", identityType: .phoneNumber)
  // If you can only provide a SHA-256-hashed mobile number, set it in 'other4' instead of 'phoneNumber' — do not pass both.
  identifyRequest.setIdentity("sha256 hashed mobile goes here", identityType: .other2)

  // If the user is identified with their email address, set additional user attributes.
  options.identifyRequest = identifyRequest
  options.onIdentifyComplete = {(result: MPIdentityApiResult?, error: Error?) in
      if let user = result?.user {
          user.setUserAttribute("example attribute key", value: "example attribute value")
      }
  }
  MParticle.sharedInstance().start(with: options)

  // Register after mParticle.start(), before selectShoppableAds
  if let paymentExt = RoktPaymentExtension(
      applePayMerchantId: "merchant.com.yourapp.rokt", // omit if not offering Apple Pay
      urlScheme: "myapp" // omit if not offering Afterpay / Clearpay
  ) {
      MParticle.sharedInstance().rokt.registerPaymentExtension(paymentExt)
  }
  return true
}

remarque

Configurez stripePublishableKey dans vos paramètres mParticle Rokt kit (tableau de bord mParticle). Le kit le transmet à Rokt en tant que stripeKey lors de l'enregistrement — vous ne le passez pas dans le code. Dans votre application, fournissez uniquement l'identifiant marchand Apple Pay et/ou urlScheme lors de la création de RoktPaymentExtension. Au moins l'un de applePayMerchantId ou urlScheme doit être fourni ; l'initialiseur retourne nil si les deux sont omis.

Lors de l'insertion du fragment d'initialisation dans votre AppDelegate, vous verrez des champs personnalisables pour :

1Entering your Rokt key and secret#

Définissez key et secret aux valeurs fournies par votre gestionnaire de compte Rokt.

2Setting your data environment#

Définissez environment sur .development (Swift) ou MPEnvironmentDevelopment (Objective-C) pendant les tests pour acheminer les données vers l'environnement de développement, et .production ou MPEnvironmentProduction pour envoyer l'activité client en direct à la production.

3Entering a custom first-party domain#

Suivez les instructions dans Configuration de domaine de première partie, et définissez customBaseURL sur MPNetworkOptions sur votre sous-domaine personnalisé. Acheminer le SDK+ Rokt via votre propre domaine réduit le risque que les bloqueurs de publicités et les navigateurs bloquent les publicités ou les données. Omettez options.networkOptions pour envoyer le trafic vers les points de terminaison par défaut de Rokt.

4Identifying your user and setting attributes#

Dans identifyRequest, passez l'email brut et non haché de l'utilisateur dans la propriété email. Pour les emails hachés et d'autres identifiants, voir Identifiants utilisateur pris en charge. Une fois identifié, utilisez le rappel onIdentifyComplete pour définir des attributs utilisateur supplémentaires — voir Attributs utilisateur pour la liste recommandée.

onIdentifyComplete

options.onIdentifyComplete = {(result: MPIdentityApiResult?, error: Error?) in
  if let user = result?.user {
      user.setUserAttribute("example attribute key", value: "example attribute value")
  }
}

remarque

Toujours inclure identifyRequest dans le snippet d'initialisation. Si vous n'avez pas l'email de l'utilisateur lors de l'initialisation, omettez l'affectation — le SDK+ s'initialisera quand même, et vous pourrez identifier l'utilisateur plus tard via 3. Identifier l'Utilisateur. Voir Gestion des Erreurs pour savoir comment inspecter l'argument error — sans gestion des erreurs, vous pourriez rencontrer des problèmes de cohérence des données à grande échelle.

5Registering the payment extension#

Enregistrez RoktPaymentExtension après MParticle.sharedInstance().start() et avant selectShoppableAds pour activer les paiements des Shoppable Ads. L'enregistrement est requis pour tous les placements de Shoppable Ads — passez applePayMerchantId pour Apple Pay, urlScheme pour Afterpay / Clearpay, ou les deux. Voir Annexe E : Configurer les paiements des Shoppable Ads. L'extension est créée et enregistrée en Swift ; dans une application Objective-C, faites cela à partir d'un petit fichier Swift.

3. Identify the User#

Le script d'initialisation du SDK+ identifie l'utilisateur actuel en utilisant les identifiants que vous avez fournis dans l'objet identifyRequest du script. Après l'initialisation du SDK, vous devez garder l'identité de l'utilisateur synchronisée chaque fois qu'il se connecte, se déconnecte, ou fournit un identifiant (par exemple, lors du paiement) en utilisant la méthode appropriée décrite ci-dessous.

Identifiants utilisateur pris en charge

Afficher les identifiants utilisateur pris en charge

Champ	Type	Description
email	string	Assignez l'adresse e-mail brute et non hachée du client à identifyRequest.email.
emailSha256	string	E-mail haché SHA-256 (chemin iOS). Passez via identifyRequest.setIdentity(hashedEmail, identityType: .other). Utilisez à la place de email lorsque seule la forme hachée est disponible.
mobileSha256	string	Numéro de mobile haché SHA-256 (chemin iOS). Passez via identifyRequest.setIdentity(hashedMobile, identityType: .other4).
mobile	string	Numéro de téléphone au format E.164. Passez via identifyRequest.setIdentity(mobileNumber, identityType: .phoneNumber).
customerid	string	Assignez votre identifiant client/compte interne à identifyRequest.customerId.

Pour identifier l'utilisateur :

1Create an identifyRequest object#

Créez un objet identifyRequest contenant les identifiants de l'utilisateur.

2Create an identityCallback#

Créez un identityCallback pour définir des attributs utilisateur supplémentaires une fois l'identification réussie.

3Send the request using the method that matches the user's action#

Passez le identifyRequest (et éventuellement identityCallback) à la méthode qui correspond à l'action de l'utilisateur :

• MParticle.sharedInstance().identity.login : appelez lorsque l'utilisateur se connecte ou crée un compte.
• MParticle.sharedInstance().identity.identify : appelez lorsque vous obtenez l'e-mail de l'utilisateur en cours de session sans transition de connexion (par exemple, un invité entre son e-mail lors du paiement).
• MParticle.sharedInstance().identity.logout : appelez lorsque l'utilisateur se déconnecte.

Appeler ces méthodes fait passer l'état de l'utilisateur actuel dans l'enregistrement du SDK. Les méthodes login et logout enregistrent également automatiquement un événement correspondant pour améliorer l'attribution de Rokt.

Par exemple, pour un utilisateur nommé Jane Smith avec l'e-mail j.smith@example.com, le numéro de mobile +13125551515, et l'ID client cust_10482 :

Identify Jane Smith

// 1. Create the identifyRequest object
let identifyRequest = MPIdentityApiRequest.withEmptyUser()
identifyRequest.email = "j.smith@example.com"
// Customer phone number in E.164 format.
identifyRequest.setIdentity("+13125551515", identityType: .phoneNumber)
// If you can only provide a SHA-256-hashed mobile number, use .other2 instead of .phoneNumber — do not pass both.
identifyRequest.setIdentity("SHA-256 hashed mobile number", identityType: .other2)

// 2. User attributes are set using identityCallback
let identityCallback = {(result: MPIdentityApiResult?) in
  if let user = result?.user {
      user.setUserAttribute("firstname", value: "Jane")
      user.setUserAttribute("lastname", value: "Smith")
  }
}

// 3. Call one of the following methods that best matches the user's action:
MParticle.sharedInstance().identity.login(identifyRequest, completion: identityCallback) // Call when the user logs in or creates an account
MParticle.sharedInstance().identity.identify(identifyRequest, completion: identityCallback) // Call when you obtain the user's email mid-session, but not during a login
MParticle.sharedInstance().identity.logout() // Call when the user logs out

4. Set User Attributes#

Définissez les attributs utilisateur progressivement à mesure que l'utilisateur navigue dans votre application, pas seulement lors du paiement. Plus vous définissez d'attributs, mieux Rokt peut résoudre le client et proposer des offres pertinentes.

Set User Attributes

import mParticle_Apple_SDK

// Retrieve the current user. This will only succeed if you have identified the user during SDK+ initialization or by calling the identify method.
let currentUser = MParticle.sharedInstance().identity.currentUser

// Once you have successfully set the current user to `currentUser`, you can set user attributes with:
currentUser?.setUserAttribute("custom-attribute-name", value: "custom-attribute-value")
// Note: all user attributes (including list attributes and tags) must have distinct names.

// Rokt recommends setting as many of the following user attributes as possible:
currentUser?.setUserAttribute("firstname", value: "John")
currentUser?.setUserAttribute("lastname", value: "Doe")
// Phone numbers can be formatted either as '1234567890', or '+1 (234) 567-8901'
currentUser?.setUserAttribute("mobile", value: "3125551515")
currentUser?.setUserAttribute("age", value: "33")
currentUser?.setUserAttribute("gender", value: "M")
currentUser?.setUserAttribute("billingcity", value: "Brooklyn")
currentUser?.setUserAttribute("billingstate", value: "NY")
currentUser?.setUserAttribute("billingzipcode", value: "123456")
currentUser?.setUserAttribute("dob", value: "yyyymmdd")
currentUser?.setUserAttribute("title", value: "Mr")
currentUser?.setUserAttribute("language", value: "en")
currentUser?.setUserAttribute("predictedltv", value: "136.23")

// You can create a user attribute to contain a list of values
currentUser?.setUserAttributeList("favorite-genres", values: ["documentary", "comedy", "romance", "drama"])

// To remove a user attribute, call removeUserAttribute and pass in the attribute name. All user attributes share the same key space.
currentUser?.removeUserAttribute("attribute-to-remove")

Attributs utilisateur

Définissez autant que possible des éléments suivants :

Afficher tous les attributs utilisateur

Champ	Type	Description
firstname	chaîne	Prénom du client. Utilisé pour la personnalisation.
lastname	chaîne	Nom de famille du client. Utilisé pour la personnalisation.
mobile	chaîne	Numéro de téléphone formaté comme 1112345678 ou +1 (222) 345-6789. Utilisé pour la résolution d'identité et la pertinence.
birthyear	entier	Année de naissance du client (par exemple, 1990). Champ de date de naissance préféré. Alternatives : dob, age. Utilisé pour l'éligibilité et la pertinence.
age	entier	Âge du client. Alternative à dob. Utilisé pour l'éligibilité et la pertinence.
dob	chaîne	Date de naissance, yyyymmdd. Alternative à age. Utilisé pour l'éligibilité et la pertinence.
gender	chaîne	Genre du client. Par exemple, M, F, Male, ou Female. Utilisé pour la pertinence.
title	chaîne	Titre honorifique. Par exemple, Mr, Mrs, Ms. Utilisé pour la personnalisation.
language	chaîne	Code de langue ISO 639-1 associé à l'achat. Utilisé pour la pertinence.
billingaddress1	chaîne	Adresse de rue (par exemple, 123 Main St). Utilisé pour la résolution d'identité et la pertinence.
billingaddress2	chaîne	Appartement/unité (par exemple, Apt 4B). Utilisé pour la résolution d'identité.
billingcity	chaîne	Ville de facturation. Utilisé pour la pertinence.
billingstate	chaîne	État / province / région de facturation. Utilisé pour la pertinence et l'éligibilité.
billingzipcode	chaîne	Code postal complet ou ZIP (préférence US est ZIP+4). Utilisé pour la résolution d'identité et la pertinence.
country	chaîne	Code pays ISO 3166-1 alpha-2 (par exemple, US, GB, AU). Utilisé pour l'éligibilité et la pertinence.
newcustomer	booléen	Indique si c'est un premier achat. Utilisé pour la pertinence.
customertype	chaîne	Indique si l'utilisateur est authentifié (guest / logged_in). Utilisé pour la pertinence.
loyaltytier	chaîne	Niveau du programme de fidélité partenaire. Utilisé pour la pertinence et l'éligibilité.
loyaltyid	chaîne	ID de membre du programme de fidélité. Utilisé pour la résolution d'identité.
predictedltv	décimal	Valeur totale à vie prédite, généralement à partir d'un modèle ML partenaire. Utilisé pour la pertinence.
subscriptionstatus	string	État de l'abonnement si applicable (active, trial, churned, paused, none). Utilisé pour la pertinence et l'éligibilité.
customersegment	string	Segmentation interne du partenaire (par exemple, vip, at_risk, new, reactivated). Utilisé pour la pertinence.
acquisitionchannel	string	Comment le client a été initialement acquis. Utilisé pour la pertinence.

Tous les attributs utilisateur (y compris les attributs de liste) doivent avoir des noms distincts.

5. Log Events#

Suivez les vues d'écran, les événements commerciaux et les événements personnalisés pour que Rokt puisse comprendre où se trouve chaque client dans son parcours.

Event category

Appelez logScreen avec le nom de l'écran (par exemple, "homepage", "product_detail_page"). Incluez tous les attributs personnalisés supplémentaires dans eventInfo.

Log a screen view

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

6. Show a Placement#

Appelez selectPlacements sur chaque écran de paiement et de confirmation où vous souhaitez que Rokt rende du contenu. Incluez l'un des identifiants de page suivants pour spécifier le type d'écran et s'il est destiné aux tests ou à la production :

• stg.rokt.conf: A confirmation screen in a staging (or testing) environment.
• prod.rokt.conf: A confirmation screen in a production environment.
• stg.rokt.payments: A payments screen in a staging (or testing) environment.
• prod.rokt.payments: A payments screen in a production environment.

Appelez selectPlacements dès que l'écran se charge et une fois que tous les attributs pertinents sont disponibles. Passez au minimum email, firstname, lastname, billingzipcode, et confirmationref. Voir Placement Attributes pour la liste complète.

Pay+

Pour les placements Pay+, incluez paymenttype et paymentServiceProvider dans l'appel selectPlacements sur chaque page. paymentServiceProvider communique les méthodes de paiement disponibles sur la page de paiement ; paymenttype communique la méthode de paiement utilisée par l'utilisateur.

Placement position

Overlay placement

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)

Configuration supplémentaire

Transmettez des paramètres optionnels tels que RoktConfig pour personnaliser l'interface utilisateur du placement (par exemple, mode sombre/clair). Des paramètres optionnels supplémentaires, y compris les vues intégrées et le rappel onEvent, sont présentés ci-dessous.

selectPlacements with RoktConfig

let roktConfig = RoktConfig.Builder().colorMode(.light).build()

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, config: roktConfig) { _ in }

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

Fonction	Objectif
Rokt.close()	Fermeture automatique des placements en superposition.

remarque

Pour une liste complète des attributs pris en charge, voir Attributs de placement ci-dessous.

Votre équipe Rokt configurera vos mises en page de placement pour correspondre à votre marque.

Attributs de placement

Passez ces attributs dans le dictionnaire attributes de selectPlacements. Fournissez toujours la valeur la plus récente — les attributs passés ici remplacent tout appel antérieur de setUserAttribute.

Afficher tous les attributs de placement

Champ	Type	Description
email	string	Email du client (non haché). Utilisé pour la résolution d'identité et la confirmation de commande des publicités Shoppable.
firstname	string	Prénom du client. Utilisé pour la personnalisation et l'exécution des commandes des publicités Shoppable.
lastname	string	Nom de famille du client. Utilisé pour la personnalisation et l'exécution des commandes des publicités Shoppable.
mobile	string	Numéro de mobile du client au format E.164. Utilisé pour la résolution d'identité.
confirmationref	string	Numéro de référence de commande / confirmation. Utilisé pour la pertinence, la déduplication et la réconciliation des commandes des publicités Shoppable.
currency	string	Devise de la transaction (ISO 4217, par ex. USD, GBP, AUD). Utilisé pour la pertinence et les publicités Shoppable.
country	string	Code de pays ISO 3166-1 alpha-2. Utilisé pour l'éligibilité et la pertinence.
language	string	Langue préférée du client (ISO 639-1). Utilisé pour la pertinence.
totalprice	decimal	Valeur totale du panier incluant taxes et livraison. Utilisé pour la pertinence.
amount	decimal	Sous-total du panier avant taxes et livraison. Distinct de totalprice. Utilisé pour la pertinence et les publicités Shoppable.
cartItems	array	Tableau structuré d'objets de ligne de panier. Doit être en camelCase. Utilisé pour la pertinence.
couponcode	string	Code promo appliqué, le cas échéant. Utilisé pour la pertinence.
newcustomer	boolean	Indique si c'est un premier achat. Utilisé pour la pertinence.
customertype	string	guest ou logged_in. Utilisé pour la pertinence.
value	decimal	Valeur cumulative des achats du client. Utilisé pour la pertinence.
subscriptionstatus	string	État de l'abonnement si applicable (active, trial, churned, paused, none). Utilisé pour la pertinence et l'éligibilité.
customersegment	string	Segmentation interne du partenaire (vip, at_risk, new, reactivated). Utilisé pour la pertinence.
paymenttype	string	Méthode de paiement sélectionnée (credit_card, paypal, apple_pay, etc.). Utilisé pour l'éligibilité Pay+ et la priorisation des méthodes de paiement des publicités Shoppable.
paymentServiceProvider	string	Liste des méthodes de paiement acceptées sur la page, séparées par des virgules (par exemple, applepay,paypal,cardpayment). Les valeurs doivent être en minuscules sans espaces. Voir Fournisseur de services de paiement pour la liste complète des valeurs acceptées. Utilisé pour l'éligibilité Pay+.
ccbin	string	BIN de la carte de crédit (6-8 chiffres). Utilisé pour la pertinence.
billingaddress1	string	Adresse de facturation. Utilisé pour la résolution d'identité et la pertinence.
billingaddress2	string	Appartement / unité de facturation. Utilisé pour la résolution d'identité.
billingcity	string	Ville de facturation. Utilisé pour la pertinence.
billingstate	string	État ou province de facturation. Utilisé pour la pertinence.
billingzipcode	string	Code postal / ZIP de facturation. Utilisé pour la résolution d'identité et la pertinence.
billingname	string	Nom complet du titulaire de la carte sur l'adresse de facturation. Utilisé pour la résolution d'identité.
shippingmethod	string	Méthode d'expédition sélectionnée (standard, express, next_day). Utilisé pour la pertinence.
shippingname	string	Nom complet du destinataire sur l'adresse de livraison. Utilisé pour l'exécution des commandes Shoppable Ads.
shippingaddress1	string	Adresse de livraison. Utilisé pour la pertinence et l'exécution des commandes Shoppable Ads.
shippingcity	string	Ville de livraison. Utilisé pour la pertinence et l'exécution des commandes Shoppable Ads.
shippingstate	string	État ou province de livraison. Utilisé pour la pertinence et l'exécution des commandes Shoppable Ads.
shippingzipcode	string	Code postal ou ZIP de livraison. Utilisé pour la pertinence et l'exécution des commandes Shoppable Ads.
shippingcountry	string	Pays de livraison (ISO 3166-1 alpha-2). Utilisé pour la pertinence et l'exécution des commandes Shoppable Ads.
partnerpaymentreference	string	Identifiant non devinable pour la méthode de paiement enregistrée du client. Requis pour le transfert de carte Shoppable Ads.
last4digits	string	Derniers 4 chiffres de la carte utilisée. Affiché au client pendant les Shoppable Ads.
plcc	string	"yes" ou "no" — si le client possède une carte de crédit à étiquette privée. Utilisé pour la pertinence Pay+.
discountamount	decimal	Remise appliquée au niveau de la commande. Utilisé pour la pertinence Pay+.
prescreen	string	"yes" ou "no" — si le client a été préqualifié pour une offre de crédit. Utilisé pour la pertinence Pay+.
adsexperience	string	Obligatoire. Passez "shoppable" pour sélectionner une expérience Shoppable Ads.

Events API

Le SDK+ émet des événements de cycle de vie de placement via l'API Rokt.events. Abonnez-vous pour répondre à l'état de chargement, à l'engagement, aux échecs et aux flux d'achat des Shoppable Ads.

Subscribe to Rokt.events

import mParticle_Apple_SDK

MParticle.sharedInstance().rokt.events("RoktLayout", onEvent: { roktEvent in
  if let event = roktEvent as? RoktEvent.ShowLoadingIndicator {
      // Example showing handling of ShowLoadingIndicator event
      // The full list of events is provided below
  }
})

Événements standards

Afficher tous les événements standards

Événement	Description	Paramètres
ShowLoadingIndicator	Déclenché avant que le SDK+ n'appelle le backend Rokt
HideLoadingIndicator	Déclenché lorsque le SDK+ reçoit un succès ou un échec du backend Rokt
PlacementInteractive	Déclenché lorsqu'un placement a été rendu et est interactif	identifier: String
PlacementReady	Déclenché lorsqu'un placement est prêt à être affiché mais n'a pas encore rendu de contenu	identifier: String
OfferEngagement	Déclenché lorsque l'utilisateur interagit avec l'offre	identifier: String
OpenUrl	Déclenché lorsque l'utilisateur appuie sur une URL configurée pour être envoyée à l'application partenaire	identifier: String, url: String
PositiveEngagement	Déclenché lorsque l'utilisateur interagit positivement avec l'offre	identifier: String
PlacementClosed	Déclenché lorsqu'un placement est fermé par l'utilisateur	identifier: String
PlacementCompleted	Dé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 le placement récupéré ne sera pas affiché car il a été précédemment rejeté	identifier: String
PlacementFailure	Déclenché lorsqu'un placement n'a pas pu être affiché en raison d'un échec ou lorsqu'aucun placement n'est disponible à afficher	identifier: String (optionnel)
FirstPositiveEngagement	Déclenché lorsque l'utilisateur interagit positivement avec l'offre pour la première fois	identifier: String, setFulfillmentAttributes: func (attributes: [String: String])
CartItemInstantPurchase	Déclenché lorsqu'un achat est effectué via un placement	identifier: String, name: String?, cartItemId: String, catalogItemId: String, currency: String, description: String, linkedProductId: String?, providerData: String, quantity: NSDecimalNumber?, totalPrice: NSDecimalNumber?, unitPrice: NSDecimalNumber?
EmbeddedSizeChanged	Déclenché lorsque la hauteur d'un placement intégré change	identifier: String, updatedHeight: CGFloat

Événements des Shoppable Ads

Afficher les événements des Shoppable Ads

Événement	Description	Paramètres
CartItemInstantPurchaseInitiated	Flux d'achat démarré — l'utilisateur a appuyé sur "Acheter"	identifier, catalogItemId, cartItemId
CartItemInstantPurchase	Achat complété avec succès	identifier, name, cartItemId, catalogItemId, currency, description, linkedProductId, providerData, quantity, totalPrice, unitPrice
CartItemInstantPurchaseFailure	Échec de l'achat	identifier, catalogItemId, cartItemId, error
CartItemDevicePay	Paiement par Apple Pay / appareil déclenché	identifier, catalogItemId, cartItemId, paymentProvider
InstantPurchaseDismissal	L'utilisateur a rejeté la superposition d'achat	identifier

remarque

Après avoir demandé une Shoppable Ad de Rokt, n'importe lequel des événements suivants peut être émis et doit être utilisé pour déterminer quand faire une demande ultérieure pour Rokt Thanks :

• PlacementClosed
• PlacementCompleted
• PlacementFailure

7. Appendix#

Appendice A : Configuration de l'application

Les applications peuvent envoyer des paramètres de configuration via RoktConfig afin que le SDK+ iOS utilise la configuration personnalisée de votre application au lieu des paramètres par défaut du système.

Objet ColorMode

Valeur	Description
light	L'application est en mode clair
dark	L'application est en mode sombre
system	L'application utilise le mode couleur système par défaut

ColorMode.light

// if application supports only Light Mode.
let roktConfig = RoktConfig.Builder().colorMode(.light).build()

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, config: roktConfig) { _ in }

ColorMode.light

// if application supports only Light Mode.
RoktConfig *roktConfig = [[[RoktConfigBuilder new] colorMode:RoktColorModeLight] build];

[[MParticle sharedInstance].rokt selectPlacements:@"RoktExperience"
                                       attributes:attributes
                                    embeddedViews:nil
                                           config:roktConfig
                                          onEvent:^(RoktEvent *_Nonnull event) {
    // Handle placement events if needed
}];

Objet CacheConfig

Paramètre	Description
cacheDuration	Intervalle de temps 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.
cacheAttributes	Attributs optionnels à utiliser comme clé de cache. Si null, tous les attributs envoyés dans l'appel selectPlacements seront utilisés comme clé de cache.

Cache for 1200 seconds

// to cache the experience for 1200 seconds, using email and orderNumber attributes as the cache key.
let roktConfig = RoktConfig.Builder()
    .cacheConfig(RoktConfig.CacheConfig(
        cacheDuration: TimeInterval(1200),
        cacheAttributes: ["email": "j.smith@example.com", "orderNumber": "123"]
    ))
    .build()

MParticle.sharedInstance().rokt.selectPlacements("RoktExperience", attributes: attributes, embeddedViews: nil, config: roktConfig) { _ in }

Cache for 1200 seconds

// to cache the experience for 1200 seconds, using email and orderNumber attributes as the cache key.
NSDictionary *cacheKeyAttributes = @{
    @"email": @"j.smith@example.com",
    @"orderNumber": @"123"
};
RoktCacheConfig *cacheConfig =
    [[RoktCacheConfig alloc] initWithCacheDuration:1200
                                  cacheAttributes:cacheKeyAttributes];
RoktConfig *roktConfig = [[[RoktConfigBuilder new] cacheConfig:cacheConfig] build];

[[MParticle sharedInstance].rokt selectPlacements:@"RoktExperience"
                                       attributes:attributes
                                    embeddedViews:nil
                                           config:roktConfig
                                          onEvent:^(RoktEvent *_Nonnull event) {
    // Handle placement events if needed
}];

Appendice B : Support SwiftUI avec MPRoktLayout

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

La classe MPRoktLayout offre un moyen compatible avec SwiftUI d'afficher les placements Rokt sans appeler manuellement selectPlacements, prenant en charge à la fois les types de placement en superposition et intégrés.

Ajout du composant SwiftUI

SwiftUI placement with MPRoktLayout

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) {
            // Other UI components
            Text("Order Confirmation")
                .font(.title)
            
            // Rokt placement using SwiftUI
            MPRoktLayout(
                sdkTriggered: $sdkTriggered,
                identifier: "RoktExperience",
                locationName: "RoktEmbedded1", // For embedded placements
                attributes: attributes,
                config: roktConfig, // Optional RoktConfig
                onEvent: { roktEvent in
                    // Optional: Handle different event types see above
                }
            ).roktLayout
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
    }
}

Paramètres

Paramètre	Type	Description
sdkTriggered	Bool	Contrôle quand le placement doit être déclenché
identifier	String	L'identifiant de placement Rokt (par exemple, "RoktExperience")
locationName	String?	Nom de l'emplacement optionnel pour les placements intégrés (par exemple, "RoktEmbedded1")
attributes	[String: String]	Dictionnaire d'attributs à passer au placement
config	RoktConfig?	Objet de configuration optionnel pour le mode couleur, la mise en cache, etc.
onEvent	((RoktEvent) -> Void)?	Callback optionnel pour gérer tous les événements de placement

Appendice C : Gestion des erreurs

L'API IDSync est conçue pour être centrale dans l'état de votre application et est conçue pour être rapide et hautement disponible. De la même manière que votre application peut empêcher les utilisateurs de se connecter, de se déconnecter ou de modifier leur état sans connexion Internet - nous vous encourageons à traiter ces API comme des opérations de contrôle afin de maintenir un état utilisateur cohérent. Le SDK+ ne réessaiera pas automatiquement les appels API, mais fournit des API de rappel vous permettant de le faire selon votre logique métier. La tolérance que vous avez pour le réessai et l'état incohérent dépend de vos exigences produit.

Si vous ne souhaitez pas gérer les erreurs, vous pourriez rencontrer des problèmes de cohérence des données à grande échelle. Il est recommandé de surveiller au moins les erreurs pendant votre implémentation.

Votre bloc de rappel IDSync sera invoqué avec l'un des deux objets suivants :

• MPIdentityApiResult : Un objet résultat contenant le nouvel objet utilisateur ou l'objet utilisateur mis à jour.
• NSError/Error : Un objet erreur contenant un code et une description si l'appel IDSync a échoué

IDSync error handling

let identityCallback = {(result: MPIdentityApiResult?, error: Error?) in
    if (result?.user != nil) {
        //IDSync request succeeded, mutate attributes or query for the MPID as needed
        result?.user.setUserAttribute("example attribute key", value: "example attribute value")
    } else {
        NSLog(error!.localizedDescription)
        let resultCode = MPIdentityErrorResponseCode(rawValue: UInt((error! as NSError).code))
        switch (resultCode!) {
        case .clientNoConnection,
             .clientSideTimeout:
            //retry the IDSync request
            break;
        case .requestInProgress,
             .retry:
            //inspect your implementation if this occurs frequency
            //otherwise retry the IDSync request
            break;
        default:
            // inspect error.localizedDescription to determine why the request failed
            // this typically means an implementation issue
            break;
        }
    }
}

IDSync error handling

id identityCallback = ^(MPIdentityApiResult *_Nullable apiResult, NSError *_Nullable error) {
    if (apiResult) {
        // IDSync request succeeded, mutate attributes or query for the MPID as needed
        [apiResult.user setUserAttribute:@"example attribute key"
                                   value:@"example attribute value"];
    } else {
        NSLog(@"%@", error.userInfo);
        switch (error.code) {
            case MPIdentityErrorResponseCodeClientNoConnection:
            case MPIdentityErrorResponseCodeClientSideTimeout:
                // Retry the IDSync request
                break;
            case MPIdentityErrorResponseCodeRequestInProgress:
            case MPIdentityErrorResponseCodeRetry:
                // Inspect your implementation if this occurs frequently;
                // otherwise retry the IDSync request
                break;
            default:
                // Inspect error.userInfo to determine why the request failed
                // This typically means an implementation issue
                break;
        }
    }
};

Codes de statut

Lorsqu'un bloc de rappel IDSync est invoqué avec un échec, vous pouvez inspecter la propriété code pour déterminer la cause. Cette propriété est destinée à décrire le résultat de l'invocation de l'API IDSync du SDK+ iOS respectif. Elle peut contenir soit une valeur générée côté client, soit un véritable code de statut HTTP.

Codes côté client

La propriété de code NSError peut contenir les codes côté client suivants, définis dans l'énumération MPIdentityErrorResponseCode :

MPIdentityErrorResponseCode	Description
MPIdentityErrorResponseCodeRequestInProgress	La requête HTTP IDSync n'a pas été effectuée car il y a déjà une requête HTTP IDSync en cours
MPIdentityErrorResponseCodeClientSideTimeout	La requête HTTP IDSync a échoué en raison d'un délai d'attente de connexion TCP.
MPIdentityErrorResponseCodeClientNoConnection	La requête HTTP IDSync a échoué en raison d'un manque de couverture réseau.
MPIdentityErrorResponseCodeSSLError	La requête HTTP IDSync a échoué en raison d'un problème de configuration SSL. Le SDK+ épingle le certificat SSL mParticle, ce qui nécessite une initialisation personnalisée via l'API MPNetworkOptions pour désactiver.
MPIdentityErrorResponseCodeOptOut	La requête HTTP IDSync n'a pas été effectuée car le SDK+ est désactivé en raison d'un désabonnement.
MPIdentityErrorResponseCodeUnknown	La requête HTTP IDSync a échoué en raison d'une erreur inconnue. Cela devrait être rare et pourrait signifier que l'application est dans un mauvais état de mémoire.

Codes de statut HTTP

La propriété de code NSError peut contenir les codes de statut HTTP générés par le serveur suivants, dont certains sont définis dans l'énumération MPIdentityErrorResponseCode pour votre commodité :

Valeur	Description
400	L'appel HTTP IDSync a échoué en raison d'un corps de requête invalide. Inspectez l'objet error.userInfo pour plus d'informations.
401	L'appel HTTP IDSync a échoué en raison d'une erreur d'authentification. Vérifiez que votre clé API est correcte.
403	L'appel HTTP IDSync a échoué car cette opération n'est pas provisionnée pour votre compte. Contactez votre gestionnaire de compte Rokt pour l'activer.
429	L'appel HTTP IDSync a été limité et doit être réessayé. Cela peut indiquer une "touche de raccourci" utilisateur ou une implémentation incorrecte entraînant un volume de requêtes IDSync supérieur à celui attendu.
5xx	L'appel HTTP IDSync a échoué en raison d'un problème côté serveur Rokt. Contactez votre représentant de compte pour plus d'informations.

Proxy du délégué UIApplication

Par défaut, le SDK mParticle remplace votre UIApplication.delegate par sa propre implémentation NSProxy afin de faciliter et simplifier la gestion des notifications à distance, des notifications locales, des interactions avec les actions de notification et du lancement d'applications. Au fil du temps, nous avons constaté que cela est moins intrusif que d'autres SDK qui effectuent à la place du swizzling, mais cela peut causer des complications lorsqu'un client utilise un framework tiers qui le fait.

Recommandation

Nous recommandons aux nouvelles intégrations de désactiver proxyAppDelegate et d'utiliser à la place les méthodes SceneDelegate ci-dessous pour transmettre manuellement les événements de cycle de vie à mParticle. Dans une future version majeure, proxyAppDelegate sera par défaut false.

Vous pouvez désactiver le proxy via le drapeau proxyAppDelegate de l'objet MParticleOptions. Ce faisant, vous devrez auditer individuellement les kits que vous utilisez pour déterminer quelles API UIApplication elles nécessitent. Toute méthode requise doit être invoquée manuellement sur mParticle, de sorte que mParticle puisse transmettre ces API à chaque kit.

Swift

let options = MParticleOptions(key: "REPLACE WITH APP KEY",
                            secret: "REPLACE WITH APP SECRET")
options.proxyAppDelegate = false
MParticle.sharedInstance().start(with: options)

Objective-C

MParticleOptions *options = [MParticleOptions optionsWithKey:@"REPLACE WITH APP KEY"
                                                      secret:@"REPLACE WITH APP SECRET"];
options.proxyAppDelegate = NO;
[[MParticle sharedInstance] startWithOptions:options];

Méthodes AppDelegate avec Proxy désactivé

Lorsque proxyAppDelegate est désactivé, vous devez transmettre manuellement les méthodes suivantes de votre AppDelegate à mParticle. Ces méthodes sont requises pour les kits qui ont des fonctionnalités de notification à distance ou locale, et pour utiliser mParticle pour s'inscrire aux notifications push.

Swift

// MARK: - Remote Notification Registration

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    MParticle.sharedInstance().didRegisterForRemoteNotifications(withDeviceToken: deviceToken)
}

func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {
    MParticle.sharedInstance().didFailToRegisterForRemoteNotificationsWithError(error)
}

// MARK: - UNUserNotificationCenterDelegate

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    MParticle.sharedInstance().userNotificationCenter(center, willPresent: notification)
    if #available(iOS 14, *) {
        completionHandler([.list, .banner])
    } else {
        completionHandler(.alert)
    }
}

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
    MParticle.sharedInstance().userNotificationCenter(center, didReceive: response)
    completionHandler()
}

Objective-C

#pragma mark - Remote Notification Registration

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    [[MParticle sharedInstance] didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
}

- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
    [[MParticle sharedInstance] didFailToRegisterForRemoteNotificationsWithError:error];
}

#pragma mark - UNUserNotificationCenterDelegate

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
    [[MParticle sharedInstance] userNotificationCenter:center willPresentNotification:notification];
    if (@available(iOS 14.0, *)) {
        completionHandler(UNNotificationPresentationOptionList | UNNotificationPresentationOptionBanner);
    } else {
        completionHandler(UNNotificationPresentationOptionAlert);
    }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {
    [[MParticle sharedInstance] userNotificationCenter:center didReceiveNotificationResponse:response];
    completionHandler();
}

Prise en charge de SceneDelegate (iOS 13+)

Pour les applications utilisant un UISceneDelegate (le cycle de vie moderne introduit dans iOS 13), mParticle fournit des méthodes dédiées pour gérer les contextes d'URL et les activités utilisateur. Ce sont les approches recommandées pour toutes les intégrations.

Gestion des contextes d'URL

Pour gérer les liens profonds et les schémas d'URL personnalisés dans votre SceneDelegate, utilisez la méthode handleURLContext: :

Swift

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    for urlContext in URLContexts {
        MParticle.sharedInstance().handleURLContext(urlContext)
    }
}

Objective-C

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
    for (UIOpenURLContext *urlContext in URLContexts) {
        [[MParticle sharedInstance] handleURLContext:urlContext];
    }
}

Gestion des activités utilisateur (liens universels)

Pour gérer les liens universels dans votre SceneDelegate, utilisez la méthode handleUserActivity: :

Swift

func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    MParticle.sharedInstance().handleUserActivity(userActivity)
}

Objective-C

- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
    [[MParticle sharedInstance] handleUserActivity:userActivity];
}

Annexe D : Transmission de l'ID de session du web au natif

Lorsque le parcours utilisateur s'étend à la fois sur les plateformes web et natives, vous pouvez maintenir une session Rokt cohérente en transmettant l'ID de session du SDK+ Web au SDK+ iOS. Cela est utile pour les flux hybrides où les utilisateurs effectuent une action dans une WebView (comme une page de paiement) et retournent à l'application native pour confirmation.

Obtention de l'ID de session à partir du SDK+ Web

Après avoir appelé selectPlacements, l'ID de session est disponible dans le contexte de sélection :

Retrieve sessionId from the selection context

const selection = await launcher.selectPlacements({
    identifier: "checkout",
    attributes: {
        email: "user@example.com",
        // ... other attributes
    }
});

const sessionId = await selection.context.sessionId;

remarque

The session ID is a unique GUID assigned to the current user journey. It is useful for debugging and for correlating a user's activity across your web and native surfaces.

Transmission à l'application native via un lien profond

Transmettez l'ID de session à votre application native en utilisant un lien profond :

Deep-link to native app

const deepLink = `myapp://confirmation?sessionId=${encodeURIComponent(sessionId)}`;
window.location.href = deepLink;

Définition de l'ID de session

Extrayez l'ID de session du lien profond et transmettez-le au SDK+ avant d'appeler selectPlacements.

Handle deep link and set sessionId

func handleDeepLink(url: URL) {
    let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
    if let sessionId = components?.queryItems?.first(where: { $0.name == "sessionId" })?.value {
        MParticle.sharedInstance().rokt.setSessionId(sessionId: sessionId)
    }
    
    // Proceed with your confirmation flow
}

Handle deep link and set sessionId

- (void)handleDeepLink:(NSURL *)url {
    NSURLComponents *components =
        [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    for (NSURLQueryItem *item in components.queryItems) {
        if ([item.name isEqualToString:@"sessionId"]) {
            [[[MParticle sharedInstance] rokt] setSessionIdWithSessionId:item.value];
            break;
        }
    }

    // Proceed with your confirmation flow
}

Remarques

• Appelez setSessionId avant selectPlacements pour vous assurer que la session est utilisée
• Les chaînes vides sont ignorées et ne mettront pas à jour la session
• Toujours encoder l'ID de session en URL lors de la transmission en tant que paramètre de requête

Appendice E : Configurer les paiements pour les publicités Shoppable

Si vous n'utilisez pas les publicités Shoppable, passez cette étape.

Les publicités Shoppable sur iOS nécessitent un RoktPaymentExtension enregistré et prennent en charge plusieurs méthodes de paiement. L'enregistrement de l'extension est obligatoire pour chaque emplacement de publicité Shoppable, même si vous proposez uniquement des méthodes basées sur la redirection. Le snippet d'enregistrement est inclus dans le code d'initialisation à l'étape 2 — enregistrez-le après MParticle.sharedInstance().start() et avant selectShoppableAds.

Méthode	Configuration iOS
Apple Pay	Identifiant marchand Apple Pay passé comme applePayMerchantId sur RoktPaymentExtension. Optionnel.
PayPal	Intégré dans le SDK Rokt+ — aucune configuration d'extension supplémentaire. Nécessite le transfert d'URL de redirection (ci-dessous).
Afterpay / Clearpay	Schéma d'URL personnalisé enregistré dans Info.plist + urlScheme correspondant sur RoktPaymentExtension + transfert d'URL de redirection (ci-dessous).
Transfert de carte	API de partage de paiement partenaire + attributs partnerpaymentreference / last4digits sur selectShoppableAds.

remarque

Configurez stripePublishableKey dans les paramètres de votre kit mParticle Rokt ; le kit le transfère automatiquement à Rokt. Apple Pay est optionnel — les publicités Shoppable prennent également en charge PayPal intégré et le transfert de carte sans identifiant marchand Apple Pay. Au moins l'un de applePayMerchantId ou urlScheme doit être fourni lors de la création de l'extension.

RoktPaymentExtension est un type Swift, il est donc créé et enregistré en Swift (voir l'onglet Swift dans l'étape 2). Dans une application principalement en Objective-C, faites cela à partir d'un petit fichier Swift ; le reste du flux (selectShoppableAds, handleURLCallback) est disponible depuis Objective-C.

Apple Pay (optionnel)

Pour proposer Apple Pay, créez un identifiant marchand Apple Pay, configurez votre projet Xcode et générez un certificat de traitement de paiement. Suivez les étapes dans Apple Pay — configuration iOS, puis passez l'identifiant marchand comme applePayMerchantId lors de la création de RoktPaymentExtension.

Afterpay / Clearpay (optionnel)

Afterpay et Clearpay sont basés sur la redirection. Pour les activer :

1. Enregistrez un schéma d'URL dans le Info.plist de votre application sous CFBundleURLTypes (par exemple, myapp).
2. Passez le urlScheme correspondant lors de la création de RoktPaymentExtension (par exemple, "myapp"). Le SDK construit l'URL de retour en interne.
3. Transférez les URL de redirection à Rokt — voir ci-dessous.

Transférer les URL de redirection

Afterpay, Clearpay et PayPal envoient les clients vers une vue web et redirigent vers votre application via le schéma d'URL enregistré. Transférez les URL entrantes à Rokt avec handleURLCallback en plus de tout traitement d'URL mParticle existant.

Forward redirect URLs (SceneDelegate)

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  for urlContext in URLContexts {
      if MParticle.sharedInstance().rokt.handleURLCallback(with: urlContext.url) {
          return
      }
      MParticle.sharedInstance().handleURLContext(urlContext)
  }
}

Forward redirect URLs (SwiftUI)

WindowGroup {
  ContentView()
      .onOpenURL { url in
          _ = MParticle.sharedInstance().rokt.handleURLCallback(with: url)
      }
}

8. Test Your Integration#

Pour confirmer que le SDK+ s'initialise et que les événements se connectent correctement :

1Enable verbose SDK+ logging#

Activez la journalisation détaillée du SDK+ avant l'initialisation pour voir ce qui est envoyé.

Enable verbose SDK+ logging

Rokt.setLoggingEnabled(enable: true)

2Build and run against a development key#

Construisez et exécutez votre application avec une clé de développement avec environment = .development (ou MPEnvironmentDevelopment).

3Trigger selectPlacements#

Déclenchez selectPlacements sur l'écran où le placement doit s'afficher et confirmez que le placement se charge.

4Verify events#

Vérifiez que les événements sont enregistrés et que l'appel identifyRequest réussit.

Dépannage

Si le placement ne s'affiche pas ou si les événements n'apparaissent pas, vérifiez la console Xcode pour les erreurs du SDK+ Rokt. Problèmes courants :

Erreurs d'initialisation

• Confirmez que key et secret correspondent aux valeurs de votre gestionnaire de compte Rokt.
• Confirmez que MParticle.sharedInstance().start(with: options) s'exécute avant tout appel à selectPlacements ou logEvent.
• Pour les publicités Shoppable, confirmez que RoktPaymentExtension est enregistré après start() et avant selectShoppableAds. Si vous utilisez PayPal ou Afterpay / Clearpay, confirmez que handleURLCallback est intégré dans votre gestionnaire d'URL.

Erreurs d'identité

Si le onIdentifyComplete ou le rappel d'identification se déclenche avec une erreur au lieu d'un utilisateur, consultez Gestion des erreurs pour les valeurs MPIdentityErrorResponseCode et les conseils de réessai. Sans gestion des erreurs, vous pourriez rencontrer des problèmes de cohérence des données à grande échelle.

Placement ne s'affiche pas

• Confirmez que le placement identifier (par exemple RoktExperience) correspond à ce que votre gestionnaire de compte Rokt a configuré.
• Pour les placements intégrés, confirmez que l'identifiant de la vue intégrée (par exemple RoktEmbedded1) correspond à la configuration de la mise en page.
• Vérifiez que le dictionnaire des attributs contient au moins email, firstname, lastname, billingzipcode, et confirmationref.

Erreurs de poignée de main SSL lors de l'utilisation d'un proxy

Lors des tests dans votre environnement de développement, vous pourriez rencontrer des erreurs de poignée de main SSL lorsqu'un proxy de débogage HTTP comme Charles ou Proxyman est en cours d'exécution, ou lorsque vous êtes derrière un proxy de réseau d'entreprise. Lorsque le SDK+ tente d'identifier l'utilisateur actuel, il signale cela comme MPIdentityErrorResponseCodeSSLError (voir Gestion des erreurs). Cela est attendu : le SDK+ épingle son certificat SSL, et un proxy intercepte HTTPS en présentant son propre certificat, ce qui échoue à l'épingle.

Pour permettre au proxy d'inspecter le trafic du SDK+, désactivez l'épinglage dans votre version de développement en définissant pinningDisabledInDevelopment sur le MPNetworkOptions dans votre script d'initialisation du SDK+.

Disable SSL pinning for proxy debugging

let networkOptions = MPNetworkOptions()
// Only takes effect in the development environment; production builds stay pinned.
networkOptions.pinningDisabledInDevelopment = true
options.networkOptions = networkOptions