Adapty utilise le namespace `AdaptySDK`. En haut de vos fichiers de script qui utilisent le SDK Adapty, vous pouvez ajouter :
```csharp showLineNumbers title="C#"
using AdaptySDK;
```
Abonnez-vous aux événements Adapty :
```csharp showLineNumbers title="C#"
using UnityEngine;
using AdaptySDK;
public class AdaptyListener : MonoBehaviour, AdaptyEventListener {
public void OnLoadLatestProfile(AdaptyProfile profile) {
// handle updated profile data
}
public void OnInstallationDetailsSuccess(AdaptyInstallationDetails details) { }
public void OnInstallationDetailsFail(AdaptyError error) { }
}
```
Nous recommandons d'ajuster l'ordre d'exécution des scripts pour placer l'AdaptyListener avant Default Time. Cela garantit qu'Adapty s'initialise le plus tôt possible.
Configurez maintenant les paywalls dans votre application :
- Si vous utilisez le [Paywall Builder d'Adapty](adapty-paywall-builder), commencez par [activer le module AdaptyUI](#activate-adaptyui-module-of-adapty-sdk) ci-dessous, puis suivez le [guide de démarrage rapide du Paywall Builder](unity-quickstart-paywalls).
- Si vous créez votre propre interface de paywall, consultez le [guide de démarrage rapide pour les paywalls personnalisés](unity-quickstart-manual).
## Activer le module AdaptyUI du SDK Adapty \{#activate-adaptyui-module-of-adapty-sdk\}
Si vous prévoyez d'utiliser le [Paywall Builder](adapty-paywall-builder) et avez installé le module AdaptyUI, vous devez activer AdaptyUI. Vous pouvez l'activer lors de la configuration :
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetActivateUI(true);
```
## Configuration optionnelle \{#optional-setup\}
### Journalisation \{#logging\}
#### Configurer le système de journalisation \{#set-up-the-logging-system\}
Adapty enregistre les erreurs et d'autres informations importantes pour vous aider à comprendre ce qui se passe. Les niveaux suivants sont disponibles :
| Level | Description |
| ---------- | ------------------------------------------------------------ |
| `error` | Seules les erreurs seront journalisées |
| `warn` | Les erreurs et les messages du SDK qui ne causent pas d'erreurs critiques, mais méritent attention, seront journalisés |
| `info` | Les erreurs, avertissements et divers messages d'information seront journalisés |
| `verbose` | Toute information supplémentaire pouvant être utile lors du débogage, comme les appels de fonctions, les requêtes API, etc., sera journalisée |
Vous pouvez définir le niveau de log dans votre application lors de la configuration d'Adapty :
```csharp showLineNumbers title="C#"
// 'verbose' is recommended for development and the first production release
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY");
builder.LogLevel = AdaptyLogLevel.Verbose;
```
Vous pouvez également modifier le niveau de log à l'exécution :
```csharp showLineNumbers title="C#"
Adapty.SetLogLevel(AdaptyLogLevel.Verbose, (error) => {
// handle result
});
```
### Politiques de données \{#data-policies\}
Adapty ne stocke pas les données personnelles de vos utilisateurs sauf si vous les envoyez explicitement, mais vous pouvez mettre en place des politiques de sécurité des données supplémentaires pour vous conformer aux directives du store ou des pays.
#### Désactiver la collecte et le partage des adresses IP \{#disable-ip-address-collection-and-sharing\}
Lors de l'activation du module Adapty, définissez `SetIPAddressCollectionDisabled` sur `true` pour désactiver la collecte et le partage des adresses IP des utilisateurs. La valeur par défaut est `false`.
Utilisez ce paramètre pour renforcer la confidentialité des utilisateurs, vous conformer aux réglementations régionales de protection des données (comme le RGPD ou le CCPA), ou réduire la collecte de données inutiles lorsque les fonctionnalités basées sur l'adresse IP ne sont pas nécessaires pour votre application.
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetIPAddressCollectionDisabled(true);
```
#### Désactiver la collecte et le partage de l'identifiant publicitaire \{#disable-advertising-id-collection-and-sharing\}
Lors de l'activation du module Adapty, définissez `SetAppleIDFACollectionDisabled` et/ou `SetGoogleAdvertisingIdCollectionDisabled` à `true` pour désactiver la collecte des identifiants publicitaires. La valeur par défaut est `false`.
Utilisez ce paramètre pour respecter les politiques de l'App Store/Google Play, éviter de déclencher l'invite App Tracking Transparency, ou si votre application n'a pas besoin d'attribution publicitaire ni d'analytiques basées sur les identifiants publicitaires.
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetAppleIDFACollectionDisabled(true)
.SetGoogleAdvertisingIdCollectionDisabled(true);
```
#### Configurer le cache média pour AdaptyUI \{#set-up-media-cache-configuration-for-adaptyui\}
Par défaut, AdaptyUI met en cache les médias (images et vidéos) pour améliorer les performances et réduire la consommation réseau. Vous pouvez personnaliser ces paramètres en fournissant une configuration personnalisée.
Utilisez `SetAdaptyUIMediaCache` pour remplacer les paramètres de cache par défaut :
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetAdaptyUIMediaCache(
100 * 1024 * 1024, // MemoryStorageTotalCostLimit 100MB
null, // MemoryStorageCountLimit
100 * 1024 * 1024 // DiskStorageSizeLimit 100MB
);
```
Paramètres :
| Paramètre | Requis | Description |
|-----------------------------|----------|-----------------------------------------------------------------------------------------------|
| memoryStorageTotalCostLimit | optionnel | Taille totale du cache en mémoire en octets. Valeur par défaut spécifique à la plateforme. |
| memoryStorageCountLimit | optionnel | Nombre maximal d'éléments dans le stockage en mémoire. Valeur par défaut spécifique à la plateforme. |
| diskStorageSizeLimit | optionnel | Taille limite des fichiers sur disque en octets. Valeur par défaut spécifique à la plateforme. |
### Activer les niveaux d'accès locaux (Android) \{#enable-local-access-levels-android\}
Par défaut, les [niveaux d'accès locaux](local-access-levels) sont activés sur iOS et désactivés sur Android. Pour les activer également sur Android, définissez `SetGoogleLocalAccessLevelAllowed` sur `true` :
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetGoogleLocalAccessLevelAllowed(true);
```
### Effacer les données lors d'une restauration de sauvegarde \{#clear-data-on-backup-restore\}
Lorsque `SetAppleClearDataOnBackup` est défini sur `true`, le SDK détecte quand l'application est restaurée depuis une sauvegarde iCloud et supprime toutes les données SDK stockées localement, notamment les informations de profil en cache, les détails des produits et les paywalls. Le SDK s'initialise ensuite dans un état propre. La valeur par défaut est `false`.
:::note
Seul le cache local du SDK est supprimé. L'historique des transactions avec Apple et les données utilisateur sur les serveurs Adapty restent inchangés.
:::
```csharp showLineNumbers title="C#"
var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY")
.SetAppleClearDataOnBackup(true);
```
## Dépannage \{#troubleshooting\}
#### Règles de sauvegarde Android (configuration Auto Backup) \{#android-backup-rules-auto-backup-configuration\}
Certains SDKs (dont Adapty) embarquent leur propre configuration Android Auto Backup. Si vous utilisez plusieurs SDKs qui définissent des règles de sauvegarde, la fusion du manifeste Android peut échouer avec une erreur mentionnant `android:fullBackupContent`, `android:dataExtractionRules` ou `android:allowBackup`.
Symptômes typiques : `Manifest merger failed: Attribute application@dataExtractionRules value=(@xml/your_data_extraction_rules)
is also present at [com.other.sdk:library:1.0.0] value=(@xml/other_sdk_data_extraction_rules)`
:::note
Ces modifications doivent être effectuées dans votre répertoire de la plateforme Android (généralement situé dans le dossier `android/` de votre projet).
:::
Pour résoudre ce problème, vous devez :
- Indiquer au gestionnaire de fusion de manifeste d'utiliser les valeurs de votre application pour les attributs liés à la sauvegarde.
- Créer des fichiers de règles de sauvegarde qui fusionnent les règles d'Adapty avec celles des autres SDKs.
#### 1. Ajoutez l'espace de noms `tools` à votre manifeste \{#1-add-the-tools-namespace-to-your-manifest\}
Dans votre fichier `AndroidManifest.xml`, assurez-vous que la balise racine `
2. Ajoutez la ligne suivante à `/Assets/Plugins/Android/launcherTemplate.gradle` :
```groovy showLineNumbers
apply plugin: 'com.android.application'
// highlight-next-line
apply plugin: 'kotlin-android'
apply from: 'setupSymbols.gradle'
apply from: '../shared/keepUnitySymbols.gradle'
```
3. Ajoutez la ligne suivante dans `/Assets/Plugins/Android/baseProjectTemplate.gradle` :
```groovy showLineNumbers
plugins {
// If you are changing the Android Gradle Plugin version, make sure it is compatible with the Gradle version preinstalled with Unity
// See which Gradle version is preinstalled with Unity here https://docs.unity3d.com/Manual/android-gradle-overview.html
// See official Gradle and Android Gradle Plugin compatibility table here https://developer.android.com/studio/releases/gradle-plugin#updating-gradle
// To specify a custom Gradle version in Unity, go do "Preferences > External Tools", uncheck "Gradle Installed with Unity (recommended)" and specify a path to a custom Gradle version
id 'com.android.application' version '8.3.0' apply false
id 'com.android.library' version '8.3.0' apply false
// highlight-next-line
id 'org.jetbrains.kotlin.android' version '1.8.0' apply false
**BUILD_SCRIPT_DEPS**
}
```
---
# File: unity-quickstart-paywalls
---
---
title: "Activer les achats avec Flow Builder dans le SDK Unity"
description: "Guide de démarrage rapide pour activer les achats intégrés avec Adapty Flow Builder."
---
Ce guide utilise les APIs du SDK Adapty Unity v4 (bêta). Si vous utilisez la v3, consultez le [guide de migration](migration-to-unity-sdk-v4) pour les noms de méthodes correspondants.
Pour activer les achats intégrés, vous devez comprendre trois concepts clés :
- [**Produits**](product) – tout ce que les utilisateurs peuvent acheter (abonnements, consommables, accès à vie)
- [**Flows**](adapty-flow-builder) – séquences d'écrans qui présentent des produits aux utilisateurs, construites dans le Flow Builder sans code. Le SDK les récupère via `GetFlow`. Si vous préférez créer l'interface dans votre propre code, utilisez un paywall à la place — voir [Implémenter des paywalls manuellement](unity-quickstart-manual).
- [**Placements**](placements) – où et quand vous affichez des flows dans votre application (par exemple `main`, `onboarding`, `settings`). Vous associez des flows à des placements dans le tableau de bord, puis vous les demandez par ID de placement dans votre code. Cela facilite l'exécution de tests A/B et l'affichage de flows différents selon les utilisateurs.
Adapty vous propose trois façons d'activer les achats dans votre application. Choisissez celle qui correspond à vos besoins :
| Implémentation | Complexité | Quand l'utiliser |
|---|---|---|
| Adapty Flow Builder | ✅ Facile | Vous [créez un flow complet et prêt à l'achat dans le builder no-code](quickstart-paywalls). Adapty le rend automatiquement et gère en coulisses tout le flow d'achat, la validation des reçus et la gestion des abonnements. |
| Paywalls créés manuellement | 🟡 Moyen | Vous implémentez l'interface de votre paywall dans le code de votre application, mais récupérez tout de même l'objet flow depuis Adapty pour conserver une flexibilité dans les offres de produits. Consultez le [guide](unity-quickstart-manual). |
| Mode Observer | 🔴 Difficile | Vous disposez déjà de votre propre infrastructure de gestion des achats et souhaitez continuer à l'utiliser. Notez que le mode Observer présente certaines limitations dans Adapty. Consultez l'[article](observer-vs-full-mode). |
:::important
**Les étapes ci-dessous montrent comment implémenter un flow créé dans l'Adapty Flow Builder.**
Si vous préférez construire l'UI du paywall vous-même, consultez [Implémenter les paywalls manuellement](unity-quickstart-manual).
:::
Pour afficher un flow créé dans l'Adapty Flow Builder, dans le code de votre application, il vous suffit de :
1. **Récupérer le flow** : Obtenez-le depuis Adapty.
2. **L'afficher et Adapty gérera les achats pour vous** : Affichez la vue dans votre application.
3. **Gérer les actions des boutons** : Associez les interactions utilisateur aux réponses de votre application. Par exemple, ouvrir des liens ou fermer le flow lorsque les utilisateurs cliquent sur des boutons.
## Avant de commencer \{#before-you-start\}
Avant de commencer, effectuez ces étapes :
1. Connectez votre application à l'[App Store](initial_ios) et/ou à [Google Play](initial-android) dans Adapty Dashboard.
2. [Créez vos produits](create-product) dans Adapty.
3. [Créez un flow et ajoutez-y des produits](create-paywall).
4. [Créez un placement et ajoutez votre flow](create-placement).
5. [Installez et activez le SDK Adapty](sdk-installation-unity) dans le code de votre application.
:::tip
Le moyen le plus rapide d'effectuer ces étapes est de suivre le [guide de démarrage rapide](quickstart) ou de créer des flows et des placements à l'aide du [CLI développeur](developer-cli-quickstart).
:::
## 1. Récupérer le flow \{#1-get-the-flow\}
Vos flows sont associés à des placements configurés dans le tableau de bord. Les placements vous permettent d'afficher des flows différents selon les audiences ou de lancer des [tests A/B](ab-tests).
Pour récupérer un flow créé dans l'Adapty Flow Builder, vous devez :
1. Récupérer l'objet `flow` par l'ID du [placement](placements) en utilisant la méthode `GetFlow`.
2. Créer la vue du flow à l'aide de la méthode `CreateFlowView`. La vue contient les éléments d'interface et le style nécessaires à l'affichage du flow. Si le flow n'a pas de vue configurée, `CreateFlowView` retourne une erreur — gérez-la dans le callback.
:::important
Pour afficher la vue, vous devez activer le bouton **Show on device** dans le Flow Builder. Sinon, `CreateFlowView` retournera une erreur et le flow ne s'affichera pas.
:::
```csharp showLineNumbers
Adapty.GetFlow("YOUR_PLACEMENT_ID", (flow, error) => {
if (error != null) {
// handle the error
return;
}
// Create the flow view
AdaptyUI.CreateFlowView(flow, (view, error) => {
if (error != null) {
// the flow has no view configured, or view creation failed
return;
}
// view - the flow view ready to be presented
});
});
```
:::info
Ce démarrage rapide fournit la configuration minimale requise pour afficher un flow. Pour les détails de configuration avancée, consultez notre [guide sur la récupération des flows](unity-get-pb-paywalls).
:::
## 2. Afficher le flow \{#2-display-the-flow\}
Maintenant que vous avez la vue du flow, il suffit d'ajouter quelques lignes pour l'afficher.
Pour afficher le flow, utilisez la méthode `view.Present()` sur le `view` créé par la méthode `CreateFlowView`. Chaque `view` ne peut être utilisé qu'une seule fois : après l'avoir fermé, appelez à nouveau `CreateFlowView` pour afficher le flow une nouvelle fois.
```csharp showLineNumbers title="Unity"
view.Present((error) => {
// handle the error
});
```
:::info
Pour plus de détails sur la façon d'afficher un flow, consultez notre [guide](unity-present-paywalls).
:::
## 3. Gérer les actions des boutons \{#handle-button-actions\}
Lorsque les utilisateurs cliquent sur des boutons dans le flow, le SDK Unity gère automatiquement les achats et la restauration. Cependant, d'autres boutons ont des identifiants personnalisés ou prédéfinis et nécessitent une gestion des actions dans votre code.
Par exemple, votre flow dispose probablement d'un bouton de fermeture et d'URLs à ouvrir (par exemple, les conditions d'utilisation et la politique de confidentialité). Pour gérer ces actions, votre classe doit implémenter l'interface `IAdaptyFlowsEventsListener` et s'enregistrer en tant qu'écouteur.
Notez que le flow reste ouvert après un achat réussi. Si vous souhaitez le fermer une fois l'achat terminé, fermez la vue dans le callback `FlowViewDidFinishPurchase`.
:::tip
Consultez nos guides sur la gestion des [actions](unity-handle-paywall-actions) et des [événements](unity-handling-events) de bouton.
:::
```csharp showLineNumbers title="Unity"
public class YourClass : MonoBehaviour, IAdaptyFlowsEventsListener
{
void Start()
{
// Register this class as the flows events listener
Adapty.SetFlowsEventsListener(this);
}
// IAdaptyFlowsEventsListener method - handles button actions
public void FlowViewDidPerformAction(
AdaptyUIFlowView view,
AdaptyUIUserAction action
) {
switch (action.Type) {
case AdaptyUIUserActionType.Close:
view.Dismiss(null);
break;
case AdaptyUIUserActionType.OpenUrl:
AdaptyUI.OpenUrl(action.Value, AdaptyWebPresentation.ExternalBrowser, null);
break;
default:
break;
}
}
// IAdaptyFlowsEventsListener method - dismiss the flow after a purchase
public void FlowViewDidFinishPurchase(
AdaptyUIFlowView view,
AdaptyPaywallProduct product,
AdaptyPurchaseResult purchasedResult
) {
if (purchasedResult.Type != AdaptyPurchaseResultType.UserCancelled) {
view.Dismiss(null);
}
}
}
```
## Prochaines étapes
:::tip
Des questions ou des problèmes ? Consultez notre [forum d'assistance](https://adapty.featurebase.app/) où vous trouverez des réponses aux questions fréquentes ou pourrez poser les vôtres. Notre équipe et notre communauté sont là pour vous aider !
:::
Votre flow est prêt à être affiché dans l'application. Testez vos achats dans le [sandbox App Store](test-purchases-in-sandbox) ou sur [Google Play Store](testing-on-android) pour vous assurer de pouvoir effectuer un achat test depuis le flow.
Ensuite, vous devez [vérifier le niveau d'accès des utilisateurs](unity-check-subscription-status) pour vous assurer d'afficher un flow ou de donner accès aux fonctionnalités payantes aux bons utilisateurs.
## Exemple complet \{#full-example\}
Voici comment intégrer toutes ces étapes dans votre application.
```csharp showLineNumbers
using System;
using System.Collections.Generic;
using UnityEngine;
using AdaptySDK;
public class FlowManager : MonoBehaviour, IAdaptyFlowsEventsListener
{
[SerializeField] private string placementId = "YOUR_PLACEMENT_ID";
void Start()
{
// Register for flow events
Adapty.SetFlowsEventsListener(this);
GetAndDisplayFlow();
}
private void GetAndDisplayFlow()
{
Adapty.GetFlow(placementId, (flow, error) => {
if (error != null) {
Debug.LogError("Error getting flow: " + error.Message);
return;
}
CreateAndPresentFlowView(flow);
});
}
private void CreateAndPresentFlowView(AdaptyFlow flow)
{
AdaptyUI.CreateFlowView(flow, (view, error) => {
if (error != null) {
// the flow has no view configured — use custom logic
Debug.LogError("Error creating flow view: " + error.Message);
return;
}
view.Present((presentError) => {
if (presentError != null) {
Debug.LogError("Error presenting flow: " + presentError.Message);
return;
}
Debug.Log("Flow presented successfully");
});
});
}
// IAdaptyFlowsEventsListener implementation
public void FlowViewDidPerformAction(
AdaptyUIFlowView view,
AdaptyUIUserAction action
) {
switch (action.Type) {
case AdaptyUIUserActionType.Close:
Debug.Log("Close button pressed");
view.Dismiss(null);
break;
case AdaptyUIUserActionType.OpenUrl:
AdaptyUI.OpenUrl(action.Value, AdaptyWebPresentation.ExternalBrowser, null);
break;
default:
break;
}
}
public void FlowViewDidFinishPurchase(
AdaptyUIFlowView view,
AdaptyPaywallProduct product,
AdaptyPurchaseResult purchasedResult
) {
if (purchasedResult.Type != AdaptyPurchaseResultType.UserCancelled) {
view.Dismiss(null);
}
}
// Required interface methods (implement as needed)
public void FlowViewDidAppear(AdaptyUIFlowView view) { }
public void FlowViewDidDisappear(AdaptyUIFlowView view) { }
public void FlowViewDidSelectProduct(AdaptyUIFlowView view, string productId) { }
public void FlowViewDidStartPurchase(AdaptyUIFlowView view, AdaptyPaywallProduct product) { }
public void FlowViewDidFailPurchase(AdaptyUIFlowView view, AdaptyPaywallProduct product, AdaptyError error) { }
public void FlowViewDidStartRestore(AdaptyUIFlowView view) { }
public void FlowViewDidFinishRestore(AdaptyUIFlowView view, AdaptyProfile profile) { }
public void FlowViewDidFailRestore(AdaptyUIFlowView view, AdaptyError error) { }
public void FlowViewDidReceiveError(AdaptyUIFlowView view, AdaptyError error) { }
public void FlowViewDidFailLoadingProducts(AdaptyUIFlowView view, AdaptyError error) { }
public void FlowViewDidFinishWebPaymentNavigation(AdaptyUIFlowView view, AdaptyPaywallProduct product, AdaptyError error) { }
public void FlowViewDidReceiveAnalyticEvent(AdaptyUIFlowView view, string name, IDictionary
### Lors de la connexion/inscription \{#during-loginsignup\}
Si vous identifiez les utilisateurs après le lancement de l'application (par exemple, après qu'ils se soient connectés à votre application ou inscrits), utilisez la méthode `identify` pour définir leur customer user ID.
- Si vous **n'avez jamais utilisé ce customer user ID auparavant**, Adapty le liera automatiquement au profil actuel.
- Si vous **avez déjà utilisé ce customer user ID pour identifier l'utilisateur**, Adapty basculera vers le profil associé à ce customer user ID.
:::important
Les customer user IDs doivent être uniques pour chaque utilisateur. Si vous codez en dur la valeur du paramètre, tous les utilisateurs seront considérés comme un seul.
:::
Attendez le callback de complétion d'`Identify` avant d'appeler d'autres méthodes du SDK. Les appels simultanés produisent `#3006 profileWasChanged` ou atterrissent sur le profil anonyme. Consultez [Ordre des appels dans le SDK Unity](unity-sdk-call-order).
```csharp showLineNumbers
Adapty.Identify("YOUR_USER_ID", (error) => { // Unique for each user
if(error == null) {
// successful identify
}
});
```
### Lors de l'activation du SDK \{#during-the-sdk-activation\}
Si vous connaissez déjà un customer user ID lors de l'activation du SDK, vous pouvez l'envoyer dans la méthode `activate` plutôt que d'appeler `identify` séparément.
Si vous connaissez un customer user ID mais ne le définissez qu'après l'activation, cela signifie que, lors de l'activation, Adapty créera un nouveau profil anonyme et ne basculera vers le profil existant qu'après l'appel à `identify`.
Vous pouvez passer un customer user ID existant (que vous avez déjà utilisé auparavant) ou un nouveau. Si vous en passez un nouveau, le nouveau profil créé lors de l'activation sera automatiquement lié au customer user ID.
:::note
Par défaut, la création de profils anonymes n'affecte pas les tableaux de bord des analyses, car les installations sont comptées par ID d'appareils.
Un ID d'appareil représente une seule installation de l'application depuis le store sur un appareil et n'est régénéré qu'après la réinstallation de l'application.
Il ne dépend pas du fait qu'il s'agisse d'une première ou d'une nouvelle installation, ni de l'utilisation d'un customer user ID existant.
La création d'un profil (lors de l'activation du SDK ou de la déconnexion), la connexion ou la mise à jour de l'application sans la réinstaller ne génèrent pas d'événements d'installation supplémentaires.
Si vous souhaitez comptabiliser les installations par utilisateurs uniques plutôt que par appareils, accédez à **App settings** et configurez [**Installs definition for analytics**](general#4-installs-definition-for-analytics).
:::
```csharp showLineNumbers
using UnityEngine;
using AdaptySDK;
var builder = new AdaptyConfiguration.Builder("YOUR_API_KEY")
.SetCustomerUserId("YOUR_USER_ID"); // Customer user IDs must be unique for each user. If you hardcode the parameter value, all users will be considered as one.
Adapty.Activate(builder.Build(), (error) => {
if (error != null) {
// handle the error
return;
}
});
```
### Déconnecter les utilisateurs \{#log-users-out\}
Si vous avez un bouton pour déconnecter les utilisateurs, utilisez la méthode `logout`.
:::important
La déconnexion d'un utilisateur crée un nouveau profil anonyme pour cet utilisateur.
:::
```csharp showLineNumbers
Adapty.Logout((error) => {
if(error == null) {
// successful logout
}
});
```
:::info
Pour reconnecter les utilisateurs à l'application, utilisez la méthode `identify`.
:::
### Autoriser les achats sans connexion \{#allow-purchases-without-login\}
Si vos utilisateurs peuvent effectuer des achats aussi bien avant qu'après s'être connectés à votre application, vous devez vous assurer qu'ils conserveront leur accès après la connexion :
1. Lorsqu'un utilisateur déconnecté effectue un achat, Adapty le lie à son ID de profil anonyme.
2. Lorsque l'utilisateur se connecte à son compte, Adapty bascule vers son profil identifié.
- S'il s'agit d'un nouveau customer user ID (par exemple, l'achat a été effectué avant l'inscription), Adapty attribue le customer user ID au profil actuel, de sorte que tout l'historique des achats est conservé.
- S'il s'agit d'un customer user ID existant (le customer user ID est déjà lié à un profil), vous devez récupérer le niveau d'accès réel après le changement de profil. Vous pouvez soit appeler [`getProfile`](unity-check-subscription-status) juste après l'identification, soit [écouter les mises à jour du profil](unity-check-subscription-status) pour que les données se synchronisent automatiquement.
## Prochaines étapes \{#next-steps\}
Félicitations ! Vous avez implémenté la logique de paiement intégré dans votre application ! Nous vous souhaitons tout le succès possible pour la monétisation de votre application !
Pour tirer encore plus parti d'Adapty, vous pouvez explorer ces sujets :
- [**Tests**](troubleshooting-test-purchases) : Assurez-vous que tout fonctionne comme prévu
- [**Onboardings**](onboardings) : Engagez les utilisateurs avec des onboardings et favorisez la rétention
- [**Intégrations**](configuration) : Intégrez des services d'attribution marketing et d'analyses en une seule ligne de code
- [**Définir des attributs de profil personnalisés**](unity-setting-user-attributes) : Ajoutez des attributs personnalisés aux profils utilisateurs et créez des segments pour lancer des tests A/B ou afficher différents paywalls à différents utilisateurs
---
# File: adapty-sdk-integration-skill-unity
---
---
title: "Intégrer Adapty dans votre application Unity avec la compétence d'intégration SDK"
description: "Utilisez la compétence adapty-sdk-integration pour intégrer le SDK Adapty dans votre application Unity de bout en bout avec votre outil de codage IA."
---
:::important
La compétence est en version bêta. Si elle se bloque ou se comporte de manière inattendue, suivez le [guide d'intégration étape par étape](adapty-cursor-unity) à la place — il guide votre outil IA à travers chaque étape avec la documentation appropriée.
:::
Le [skill adapty-sdk-integration](https://github.com/adaptyteam/adapty-sdk-integration-skill) automatise l'intégration d'Adapty de bout en bout : configuration du tableau de bord, installation du SDK, paywall et vérification à chaque étape. Il détecte automatiquement votre plateforme et récupère la documentation Adapty pertinente à chaque étape.
**Outils pris en charge** : Claude Code, GitHub Copilot CLI, OpenAI Codex, Gemini CLI.
Pour l'installer, choisissez le formulaire correspondant à votre outil. La liste complète se trouve dans le [README du skill](https://github.com/adaptyteam/adapty-sdk-integration-skill).
Le dépôt contient deux skills — `adapty-sdk-integration` et `ads-manager`, qui exécute Apple Search Ads via le CLI Adapty. Chaque commande ci-dessous installe les deux.
**Claude Code**
```
claude plugin marketplace add adaptyteam/adapty-sdk-integration-skill
claude plugin install adapty-sdk-integration@adapty
```
**GitHub Copilot CLI**
```
git clone https://github.com/adaptyteam/adapty-sdk-integration-skill.git
cp -r adapty-sdk-integration-skill/skills/* ~/.copilot/skills/
```
**Gemini CLI**
```
gemini skills install https://github.com/adaptyteam/adapty-sdk-integration-skill
```
**OpenAI Codex ou tout autre outil** — utilisez le [skills CLI](https://skills.sh) (notez que les skills installés de cette façon ne se mettent pas à jour automatiquement) :
```
npx skills add adaptyteam/adapty-sdk-integration-skill --all
```
`--all` installe les deux skills dans chaque agent détecté. Sans ce paramètre, le CLI vous demande lequel des deux vous souhaitez installer.
Vous pouvez aussi cloner le dépôt et copier les répertoires sous `skills/` dans le répertoire des skills de votre outil.
Après l'installation, exécutez le skill dans votre projet :
```
/adapty-sdk-integration
```
Le skill pose quelques questions de configuration, puis guide à travers la configuration du tableau de bord, l'installation du SDK, le paywall et la vérification.
---
# File: adapty-cursor-unity
---
---
title: "Intégrer Adapty dans votre application Unity avec l'aide de l'IA"
description: "Un guide étape par étape pour intégrer Adapty dans votre application Unity avec Cursor, Context7, ChatGPT, Claude ou d'autres outils IA."
---
Ce guide vous accompagne étape par étape dans l'intégration d'Adapty dans votre application Unity à l'aide d'un outil IA — vous lui fournissez les bonnes docs Adapty dans le bon ordre.
For a fully automated integration, use the [adapty-sdk-integration skill](https://github.com/adaptyteam/adapty-sdk-integration-skill): it runs the whole integration from your AI coding tool in one command.
## Avant de commencer : configuration du tableau de bord \{#before-you-start-dashboard-setup\}
Adapty nécessite quelques réglages dans le tableau de bord avant d'écrire la moindre ligne de code SDK. Vous pouvez le faire via un skill LLM interactif, ou manuellement depuis le Dashboard.
### Approche par skill (recommandée) \{#skill-approach-recommended\}
Le skill Adapty CLI permet à votre LLM de configurer votre application, vos produits, niveaux d'accès, paywalls et placements directement — sans ouvrir le Dashboard à chaque étape. Vous n'avez qu'à [connecter vos stores](integrate-payments) dans le Dashboard.
```
npx skills add adaptyteam/adapty-cli --skill adapty-cli
```
Une fois le skill ajouté, lancez `/adapty-cli` dans votre agent. Il vous guidera à chaque étape — y compris quand ouvrir le Dashboard pour connecter vos stores.
### Approche manuelle \{#dashboard-approach\}
Si vous préférez tout configurer manuellement, voici ce qu'il vous faut avant d'écrire du code. Votre LLM ne peut pas récupérer les valeurs du tableau de bord à votre place — vous devrez les lui fournir.
1. **Connectez vos stores** : Dans l'Adapty Dashboard, allez dans **App settings → General**. Connectez l'App Store et Google Play si votre application Unity cible les deux plateformes. C'est indispensable pour que les achats fonctionnent.
[Connecter les stores](integrate-payments)
2. **Copiez votre clé SDK publique** : Dans l'Adapty Dashboard, allez dans **App settings → General**, puis repérez la section **API keys**. Dans le code, c'est la chaîne que vous passez au builder de configuration Adapty.
3. **Créez au moins un produit** : Dans l'Adapty Dashboard, accédez à la page **Products**. Vous ne référencez pas les produits directement dans le code — Adapty les livre via les paywalls.
[Ajouter des produits](quickstart-products)
4. **Créez un paywall et un placement** : Dans l'Adapty Dashboard, créez un paywall sur la page **Paywalls**, puis assignez-le à un placement sur la page **Placements**. Dans le code, l'ID de placement est la chaîne que vous passez à `Adapty.GetPaywall("YOUR_PLACEMENT_ID")`.
[Créer un paywall](quickstart-paywalls)
5. **Configurez les niveaux d'accès** : Dans l'Adapty Dashboard, configurez-les par produit sur la page **Products**. Dans le code, la chaîne vérifiée dans `profile.AccessLevels["premium"]?.IsActive`. Le niveau d'accès `premium` par défaut convient à la plupart des applications. Si les utilisateurs payants accèdent à des fonctionnalités différentes selon le produit (par exemple, un plan `basic` vs. un plan `pro`), [créez des niveaux d'accès supplémentaires](assigning-access-level-to-a-product) avant de commencer à coder.
:::tip
Une fois ces cinq éléments en place, vous êtes prêt à écrire du code. Indiquez à votre LLM : « Ma clé SDK publique est X, mon ID de placement est Y » pour qu'il génère un code d'initialisation et de récupération de paywall correct.
:::
### À configurer quand vous serez prêt \{#set-up-when-ready\}
Ces éléments ne sont pas indispensables pour démarrer, mais vous en aurez besoin à mesure que votre intégration mûrit :
- **Tests A/B** : Configurez-les sur la page **Placements**. Aucun changement de code nécessaire.
[Tests A/B](ab-tests)
- **Paywalls et placements supplémentaires** : Ajoutez d'autres appels `GetPaywall` avec des ID de placement différents.
- **Intégrations analytics** : Configurez-les sur la page **Integrations**. La mise en place varie selon l'intégration. Voir [intégrations analytics](analytics-integration) et [intégrations attribution](attribution-integration).
## Fournir la documentation Adapty à votre LLM \{#feed-adapty-docs-to-your-llm\}
### Utiliser Context7 (recommandé) \{#use-context7-recommended\}
[Context7](https://context7.com) est un serveur MCP qui donne à votre LLM un accès direct à la documentation Adapty à jour. Votre LLM récupère automatiquement les bonnes docs selon vos questions — pas besoin de coller des URL manuellement.
Context7 fonctionne avec **Cursor**, **Claude Code**, **Windsurf** et d'autres outils compatibles MCP. Pour le configurer, lancez :
```
npx ctx7 setup
```
Cette commande détecte votre éditeur et configure le serveur Context7. Pour une configuration manuelle, consultez le [dépôt GitHub Context7](https://github.com/upstash/context7).
Une fois configuré, référencez la bibliothèque Adapty dans vos prompts :
```
Use the adaptyteam/adapty-docs library to look up how to install the Unity SDK
```
:::warning
Même si Context7 évite de coller des liens de docs manuellement, l'ordre d'implémentation est important. Suivez le [parcours d'implémentation](#implementation-walkthrough) ci-dessous étape par étape pour que tout fonctionne correctement.
:::
### Utiliser les docs en texte brut \{#use-plain-text-docs\}
Vous pouvez accéder à n'importe quelle doc Adapty en texte brut Markdown. Ajoutez `.md` à la fin de son URL, ou cliquez sur **Copy for LLM** sous le titre de l'article. Par exemple : [adapty-cursor-unity.md](https://adapty.io/docs/fr/adapty-cursor-unity.md).
Chaque étape du [parcours d'implémentation](#implementation-walkthrough) ci-dessous inclut un bloc « À envoyer à votre LLM » avec des liens `.md` à coller.
Pour accéder à plus de documentation en une fois, consultez les [fichiers d'index et sous-ensembles par plateforme](#plain-text-doc-index-files) ci-dessous.
## Parcours d'implémentation \{#implementation-walkthrough\}
La suite de ce guide décrit l'intégration d'Adapty dans l'ordre d'implémentation. Chaque étape inclut les docs à envoyer à votre LLM, ce que vous devez observer une fois terminé, et les problèmes courants.
### Planifier votre intégration \{#plan-your-integration\}
Avant de plonger dans le code, demandez à votre LLM d'analyser votre projet et de créer un plan d'implémentation. Si votre outil IA dispose d'un mode planification (comme le mode plan de Cursor ou Claude Code), utilisez-le pour que le LLM puisse lire à la fois la structure de votre projet et les docs Adapty avant d'écrire du code.
Indiquez à votre LLM quelle approche vous utilisez pour les achats — cela détermine les guides à suivre :
- [**Adapty Paywall Builder**](adapty-paywall-builder) : Vous créez des paywalls dans le builder no-code d'Adapty, et le SDK les affiche automatiquement.
- [**Paywalls créés manuellement**](unity-making-purchases) : Vous construisez votre propre interface de paywall dans le code, mais utilisez toujours Adapty pour récupérer les produits et gérer les achats.
- [**Mode observateur**](observer-vs-full-mode) : Vous conservez votre infrastructure d'achat existante et utilisez Adapty uniquement pour l'analytics et les intégrations.
Vous ne savez pas lequel choisir ? Lisez le [tableau comparatif dans le quickstart](unity-quickstart-paywalls).
### Installer et configurer le SDK \{#install-and-configure-the-sdk\}
Ajoutez le package SDK Adapty via Unity Package Manager et activez-le avec votre clé SDK publique. C'est le socle — rien d'autre ne fonctionne sans ça.
**Guide :** [Installer et configurer le SDK Adapty](sdk-installation-unity)
À envoyer à votre LLM :
```
Read these Adapty docs before writing code:
- https://adapty.io/docs/fr/sdk-installation-unity.md
```
:::tip[Checkpoint]
- **Attendu :** Le projet se compile et s'exécute. La console Unity affiche le log d'activation Adapty.
- **Point d'attention :** « Public API key is missing » → vérifiez que vous avez remplacé le placeholder par votre vraie clé depuis App settings.
:::
### Afficher les paywalls et gérer les achats \{#show-paywalls-and-handle-purchases\}
Récupérez un paywall par ID de placement, affichez-le et gérez les événements d'achat. Les guides dont vous avez besoin dépendent de la façon dont vous gérez les achats.
Testez chaque achat en sandbox au fur et à mesure — n'attendez pas la fin. Consultez [Tester les achats en sandbox](test-purchases-in-sandbox) pour les instructions de configuration.
Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `AdaptyPlacementFetchPolicy.ReturnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs n'obtiendront peut-être pas les toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, ce qui permet de l'utiliser en toute sécurité pendant la session pour éviter les requêtes réseau.
Notez que le cache reste intact après le redémarrage de l'application et n'est effacé que lors de la réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les flows et les paywalls localement en deux couches : le cache mis à jour régulièrement décrit ci-dessus et les [paywalls de secours](fallback-paywalls). Nous utilisons également un CDN pour les récupérer plus rapidement et un serveur de secours indépendant en cas d'indisponibilité du CDN. Ce système est conçu pour garantir que vous obtenez toujours la dernière version tout en assurant la fiabilité, même lorsque la connexion internet est limitée.
| | **loadTimeout** | défaut : 5 sec |Cette valeur limite le délai d'expiration de cette méthode. Si le délai est dépassé, les données en cache ou le fallback local sont renvoyés.
Notez que dans de rares cas, cette méthode peut expirer légèrement après le délai spécifié dans `loadTimeout`, car l'opération peut impliquer différentes requêtes en interne.
| | Paramètre | Description | | :-------- | :---------- | | Flow | Un objet `AdaptyFlow` contenant le placement, les identifiants (`InstanceIdentity`, `VariationId`), le nom, les variantes de paywall (`Paywalls` — une liste d'`AdaptyFlowPaywall`) et les Remote Configs (`RemoteConfigs` — une liste avec une entrée par locale). Pour récupérer les produits réels en vue d'un préchargement, d'une UI personnalisée ou de vérifications programmatiques, appelez `GetPaywallProducts(flow)`. | ## Récupérer la configuration de la vue \{#fetch-the-view-configuration\} Après avoir récupéré le flow ou le paywall, chargez sa configuration de vue et créez la vue en une seule étape avec la méthode `CreateFlowView`. Il n'y a pas d'indicateur distinct à vérifier : si le placement a été conçu dans le **Flow Builder** (un flow) ou le **Paywall Builder** (un paywall), `CreateFlowView` retourne la vue prête à être affichée. Si le placement est un paywall personnalisé sans interface Builder, `CreateFlowView` retourne une erreur — [gérez-la comme un paywall Remote Config](present-remote-config-paywalls-unity). :::important Assurez-vous d'activer le bouton **Show on device** dans le Flow Builder. Si cette option n'est pas activée, la configuration de la vue ne sera pas disponible pour être récupérée. ::: ```csharp showLineNumbers var parameters = new AdaptyUICreateFlowViewParameters() .SetPreloadProducts(true) .SetLoadTimeout(TimeSpan.FromSeconds(5)); AdaptyUI.CreateFlowView(flow, parameters, (view, error) => { if (error != null) { // the flow has no view configured, or view creation failed return; } // use view }); ``` | Paramètre | Présence | Description | | :--------------------------- | :------------- | :----------------------------------------------------------- | | **flow** | requis | Un objet `AdaptyFlow` obtenu via `Adapty.GetFlow`. | | **Locale** | optionnel | L'identifiant de la [localisation du Builder](add-paywall-locale-in-adapty-paywall-builder) à utiliser pour afficher le flow ou le paywall, par exemple `en` ou `pt-br`. Un flow est localisé au moment de la création de sa vue, c'est donc le seul endroit où choisir sa localisation. Le SDK ne lit pas la locale de l'appareil : si vous omettez ce paramètre, le flow s'affiche en `en`, ou dans sa locale par défaut si le flow ne possède pas de localisation `en`. Le code doit correspondre exactement à un code de localisation du flow. Voir [Utiliser les localisations et les codes de locale](unity-localizations-and-locale-codes). | | **LoadTimeout** | optionnel | Cette valeur limite le délai d'attente de cette méthode. Si le délai est atteint, les données en cache ou le fallback local sont renvoyés. Notez que dans de rares cas, cette méthode peut expirer légèrement après la valeur indiquée dans `LoadTimeout`, car l'opération peut s'appuyer sur plusieurs requêtes en coulisses. | | **PreloadProducts** | optionnel | Définissez à `true` pour précharger les produits et améliorer les performances. Lorsque cette option est activée, les produits sont chargés à l'avance, ce qui réduit le temps nécessaire à l'affichage du flow ou du paywall. | | **ProductPurchaseParameters** | optionnel | Android uniquement (ignoré sur iOS). Un dictionnaire associant `AdaptyProductIdentifier` à `AdaptyPurchaseParameters`. Utilisez ce paramètre pour configurer des options d'achat spécifiques, comme les offres personnalisées ou les paramètres de mise à jour d'abonnement pour des produits individuels dans le flow ou le paywall. | | **EnableSafeAreaPaddings** | optionnel | Android uniquement (ignoré sur iOS). Lorsque `true`, la vue du flow applique les marges de zone sécurisée. Valeur par défaut : `true`. La valeur par défaut convient à la plupart des cas. | :::note Si vous utilisez plusieurs langues, découvrez comment ajouter une [localisation dans le Builder](add-paywall-locale-in-adapty-paywall-builder). ::: Une fois chargé, [présentez le flow ou le paywall](unity-present-paywalls). ## Obtenez un flow ou un paywall pour l'audience par défaut afin d'accélérer la récupération \{#get-a-flow-or-paywall-for-a-default-audience-to-fetch-it-faster\} En général, les flows et les paywalls sont récupérés quasi instantanément, vous n'avez donc pas à vous soucier d'optimiser ce processus. Cependant, si vous avez de nombreuses audiences et placements et que vos utilisateurs ont une connexion internet faible, la récupération d'un flow ou d'un paywall peut prendre plus de temps que souhaité. Dans ce cas, vous pouvez afficher un flow ou un paywall par défaut pour garantir une expérience utilisateur fluide plutôt que de ne rien afficher. Pour y remédier, vous pouvez utiliser la méthode `GetFlowForDefaultAudience`, qui récupère le flow ou le paywall du placement spécifié pour l'audience **All Users**. Il est cependant essentiel de comprendre que l'approche recommandée est de récupérer le flow ou le paywall via la méthode `GetFlow`, comme expliqué dans la section [Récupérer un flow/paywall](#fetch-flowpaywall) ci-dessus. :::warning Pourquoi nous recommandons d'utiliser `GetFlow` La méthode `GetFlowForDefaultAudience` présente plusieurs inconvénients majeurs : - **Problèmes potentiels de compatibilité ascendante** : si vous devez afficher des flows différents selon les versions de l'application (version actuelle et versions futures), vous pourriez rencontrer des difficultés. Vous devrez soit concevoir des flows compatibles avec la version actuelle (héritée), soit accepter que les utilisateurs de cette version puissent rencontrer des problèmes avec des flows qui ne s'affichent pas correctement. - **Perte de ciblage** : tous les utilisateurs verront le même flow conçu pour l'audience **All Users**, ce qui signifie que vous perdez le ciblage personnalisé (notamment par pays, attribution marketing ou attributs personnalisés). Si vous acceptez ces inconvénients pour bénéficier d'une récupération plus rapide du flow ou du paywall, utilisez la méthode `GetFlowForDefaultAudience` comme suit. Sinon, utilisez `GetFlow` décrit [ci-dessus](#fetch-flowpaywall). ::: ```csharp showLineNumbers Adapty.GetFlowForDefaultAudience( "YOUR_PLACEMENT_ID", AdaptyPlacementFetchPolicy.Default, (flow, error) => { if (error != null) { // handle the error return; } // flow - the requested flow } ); ``` | Paramètre | Présence | Description | |---------|--------|-----------| | **placementId** | obligatoire | L'identifiant du [Placement](placements). C'est la valeur que vous avez indiquée lors de la création d'un placement dans votre Adapty Dashboard. | | **fetchPolicy** | par défaut : `AdaptyPlacementFetchPolicy.Default` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs disposent toujours des données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `AdaptyPlacementFetchPolicy.ReturnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs n'auront peut-être pas les toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sans risque de l'utiliser pendant la session pour éviter des requêtes réseau.
Notez que le cache est conservé après le redémarrage de l'application et n'est effacé que lors de la désinstallation de celle-ci ou par un nettoyage manuel.
| ## Personnaliser les ressources \{#customize-assets\} Pour personnaliser les images et vidéos dans votre flow ou paywall, implémentez des ressources personnalisées. Les images et vidéos hero ont des IDs prédéfinis : `hero_image` et `hero_video`. Dans un bundle de ressources personnalisées, vous ciblez ces éléments par leurs IDs et personnalisez leur comportement. Pour les autres images et vidéos, vous devez [définir un ID personnalisé](custom-media) dans l'Adapty Dashboard. Par exemple, vous pouvez : - Afficher une image ou vidéo différente à certains utilisateurs. - Afficher une image de prévisualisation locale pendant le chargement d'une image principale distante. - Afficher une image de prévisualisation avant de lancer une vidéo. Voici un exemple montrant comment fournir des ressources personnalisées via un dictionnaire simple : ```csharp showLineNumbers var customAssets = new Dictionaryoptionnel
défaut : `en`
|L'identifiant de la [localisation du paywall](add-paywall-locale-in-adapty-paywall-builder). Ce paramètre doit être un code de langue composé d'un ou deux sous-tags séparés par le caractère moins (**-**). Le premier sous-tag désigne la langue, le second la région.
Exemple : `en` signifie l'anglais, `pt-br` représente le portugais brésilien.
Consultez [Localisations et codes de langue](localizations-and-locale-codes) pour plus d'informations sur les codes de langue et nos recommandations d'utilisation.
| | **fetchPolicy** | défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs obtiennent toujours les données les plus récentes.
Toutefois, si vous pensez que vos utilisateurs sont confrontés à une connexion internet instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache lorsqu'elles existent. Dans ce cas, les utilisateurs ne recevront peut-être pas les toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser pendant la session afin d'éviter des requêtes réseau.
Notez que le cache est conservé lors du redémarrage de l'application et n'est effacé que lors d'une réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les paywalls localement sur deux couches : le cache mis à jour régulièrement décrit ci-dessus et les [paywalls de secours](fallback-paywalls). Nous utilisons également un CDN pour récupérer les paywalls plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'inaccessibilité du CDN. Ce système est conçu pour vous garantir toujours la dernière version de vos paywalls, tout en assurant la fiabilité même lorsque la connexion internet est limitée.
| | **loadTimeout** | défaut : 5 sec |Cette valeur limite le délai d'expiration de cette méthode. Si le délai est atteint, les données en cache ou le fallback local sont renvoyés.
Notez que dans de rares cas, cette méthode peut expirer légèrement après le délai spécifié dans `loadTimeout`, car l'opération peut regrouper différentes requêtes en coulisses.
| Paramètres de réponse : | Paramètre | Description | | :-------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------- | | Paywall | Un objet [`AdaptyPaywall`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_paywall.html) contenant une liste d'identifiants de produits, l'identifiant du paywall, la Remote Config, et plusieurs autres propriétés. | ## Récupérer la configuration d'affichage d'un paywall créé avec Paywall Builder \{#fetch-the-view-configuration-of-paywall-designed-using-paywall-builder\} :::important Assurez-vous d'activer le bouton **Show on device** dans le Paywall Builder. Si cette option n'est pas activée, la configuration d'affichage ne sera pas disponible pour la récupération. ::: Après avoir récupéré le paywall, vérifiez s'il inclut une `ViewConfiguration`, ce qui indique qu'il a été créé avec Paywall Builder. Cela vous guidera sur la façon d'afficher le paywall. Si la `ViewConfiguration` est présente, traitez-le comme un paywall Paywall Builder ; sinon, [gérez-le comme un paywall Remote Config](present-remote-config-paywalls-unity). Dans le SDK Unity, appelez directement la méthode `CreatePaywallView` sans récupérer manuellement la configuration de la vue au préalable. :::warning Le résultat de la méthode `CreatePaywallView` ne peut être utilisé qu'une seule fois. Si vous devez l'utiliser à nouveau, appelez de nouveau la méthode `CreatePaywallView`. L'appeler deux fois sans recréer peut entraîner l'erreur `AdaptyUIError.viewAlreadyPresented`. ::: ```csharp showLineNumbers var parameters = new AdaptyUICreatePaywallViewParameters() .SetPreloadProducts(preloadProducts) .SetLoadTimeout(new TimeSpan(0, 0, 3)); AdaptyUI.CreatePaywallView(paywall, parameters, (view, error) => { // handle the result }); ``` Paramètres : | Paramètre | Présence | Description | | :------------------ | :------------- | :----------------------------------------------------------- | | **paywall** | obligatoire | Un objet `AdaptyPaywall` permettant d'obtenir un contrôleur pour le paywall souhaité. | | **loadTimeout** | défaut : 5 sec | Cette valeur limite le délai d'attente de cette méthode. Si le délai est dépassé, les données en cache ou le fallback local seront retournés. Notez que dans de rares cas, cette méthode peut expirer légèrement après la valeur spécifiée dans `loadTimeout`, car l'opération peut impliquer différentes requêtes en interne. | | **PreloadProducts** | optionnel | Fournissez un tableau d'`AdaptyPaywallProducts` pour optimiser le moment d'affichage des produits à l'écran. Si `nil` est passé, AdaptyUI récupérera automatiquement les produits nécessaires. | | **CustomTags** | optionnel | Définissez un dictionnaire de tags personnalisés et leurs valeurs résolues. Les tags personnalisés servent de balises dans le contenu du paywall, remplacées dynamiquement par des chaînes spécifiques pour un contenu personnalisé. Consultez la rubrique Tags personnalisés dans le Paywall Builder pour plus de détails. | | **CustomTimers** | optionnel | Définissez un dictionnaire de minuteries personnalisées et leurs dates de fin. Les minuteries personnalisées permettent d'afficher des comptes à rebours dans votre paywall. | :::note Si vous utilisez plusieurs langues, découvrez comment ajouter une [localisation Paywall Builder](add-paywall-locale-in-adapty-paywall-builder) et comment utiliser correctement les codes de langue [ici](localizations-and-locale-codes). ::: Une fois que vous avez la vue, [affichez le paywall](unity-present-paywalls). ## Personnaliser les assets \{#customize-assets\} Pour personnaliser les images et vidéos de votre paywall, implémentez des assets personnalisés. Les images et vidéos hero ont des IDs prédéfinis : `hero_image` et `hero_video`. Dans un bundle d'assets personnalisé, vous ciblez ces éléments par leurs IDs et personnalisez leur comportement. Pour les autres images et vidéos, vous devez [définir un ID personnalisé](custom-media) dans l'Adapty Dashboard. Par exemple, vous pouvez : - Afficher une image ou vidéo différente à certains utilisateurs. - Afficher une image de prévisualisation locale pendant le chargement d'une image principale distante. - Afficher une image de prévisualisation avant de lancer une vidéo. :::important Pour utiliser cette fonctionnalité, mettez à jour le SDK Unity d'Adapty vers la version 3.8.0 ou supérieure. ::: Voici un exemple de la façon dont vous pouvez fournir des ressources personnalisées via un simple dictionnaire : ```csharp showLineNumbers var customAssets = new Dictionaryoptionnel
par défaut : `en`
|L'identifiant de la localisation du paywall. Ce paramètre doit être un code de langue composé d'un ou deux sous-tags séparés par le caractère moins (**-**). Le premier sous-tag désigne la langue, le second désigne la région.
Exemple : `en` signifie l'anglais, `pt-br` représente le portugais brésilien.
| | **fetchPolicy** | par défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Toutefois, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs pourraient ne pas obtenir les toutes dernières données, mais ils bénéficieront de temps de chargement plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sans risque de l'utiliser pendant la session pour éviter les requêtes réseau.
Notez que le cache reste intact après un redémarrage de l'application et n'est effacé que lors d'une réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les paywalls localement sur deux couches : le cache mis à jour régulièrement décrit ci-dessus et les paywalls de secours. Nous utilisons également un CDN pour récupérer les paywalls plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'inaccessibilité du CDN. Ce système est conçu pour garantir que vous disposez toujours de la dernière version de vos paywalls, tout en assurant la fiabilité même lorsque la connexion internet est limitée.
|
## Le nombre d'affichages du paywall est trop élevé \{#the-paywall-view-number-is-too-big\}
**Problème** : Le nombre d'affichages du paywall est deux fois plus élevé que prévu.
**Raison** : Vous appelez peut-être `LogShowFlow` (SDK v4+) / `LogShowPaywall` dans votre code, ce qui duplique le compteur d'affichages si vous utilisez le Paywall Builder ou le Flow Builder. Pour les flows et les paywalls créés avec ces outils, l'analyse est suivie automatiquement et vous n'avez pas besoin d'utiliser cette méthode.
**Solution** : Vérifiez que vous n'appelez pas `LogShowFlow` (SDK v4+) / `LogShowPaywall` dans votre code si vous utilisez le Paywall Builder ou le Flow Builder.
## Autres problèmes \{#other-issues\}
**Problème** : Vous rencontrez d'autres problèmes liés au Paywall Builder qui ne sont pas couverts ci-dessus.
**Solution** : Mettez à jour le SDK vers la dernière version en utilisant les [guides de migration](unity-sdk-migration-guides) si nécessaire. De nombreux problèmes sont résolus dans les versions plus récentes du SDK.
---
# File: unity-implement-paywalls-manually
---
---
title: "Implémenter les paywalls manuellement dans le SDK Unity"
description: "Découvrez comment implémenter les paywalls manuellement dans votre application Unity avec le SDK Adapty."
---
## Accepter les achats \{#accept-purchases\}
Si vous travaillez avec des paywalls que vous avez implémentés vous-même, vous pouvez déléguer la gestion des achats à Adapty en utilisant la méthode `makePurchase`. Adapty prendra alors en charge tous les scénarios utilisateur, et vous n'aurez qu'à gérer les résultats des achats.
:::important
`makePurchase` fonctionne avec les produits créés dans l'Adapty Dashboard. Assurez-vous de configurer les produits et les moyens de les récupérer dans le tableau de bord en suivant le [guide de démarrage rapide](quickstart).
:::
Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `AdaptyPlacementFetchPolicy.ReturnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs risquent de ne pas obtenir les toutes dernières données, mais ils bénéficieront de temps de chargement plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sans risque de l'utiliser pendant la session pour éviter les requêtes réseau.
Notez que le cache reste intact après le redémarrage de l'application et n'est effacé que lors d'une réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les flows et les paywalls sur deux couches : le cache mis à jour régulièrement décrit ci-dessus et les [paywalls de secours](unity-use-fallback-paywalls). Nous utilisons également un CDN pour récupérer les flows et les paywalls plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'inaccessibilité du CDN. Ce système est conçu pour vous garantir en permanence la dernière version de vos flows et paywalls, tout en assurant la fiabilité même lorsque la connexion internet est limitée.
| | **loadTimeout** | par défaut : 5 sec |Cette valeur limite le délai d'expiration de cette méthode. Si le délai est atteint, les données en cache ou le fallback local sont renvoyés.
Notez que dans de rares cas, cette méthode peut expirer légèrement après la valeur spécifiée dans `loadTimeout`, car l'opération peut comprendre plusieurs requêtes en coulisses.
| Ne codez pas les identifiants de produit en dur ! Puisque les flows sont configurés à distance, les produits disponibles, leur nombre et les offres spéciales (comme les essais gratuits) peuvent changer au fil du temps. Assurez-vous que votre code gère bien ces scénarios. Par exemple, si vous récupérez initialement 2 produits, votre application doit afficher ces 2 produits. Mais si vous en récupérez ensuite 3, votre application doit tous les afficher sans nécessiter de modification du code. La seule chose à coder en dur est l'identifiant du placement. Paramètres de réponse : | Paramètre | Description | | :-------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- | | Flow | Un objet `AdaptyFlow` contenant : l'identifiant du flow, les variantes de paywall (`Paywalls` — chacune avec ses propres identifiants de produits), une liste `RemoteConfigs` (une entrée par locale configurée), et plusieurs autres propriétés. Pour récupérer les produits du flow, appelez `GetPaywallProducts(flow)`. | :::note Dans la v4, `GetFlow` n'a pas de paramètre `locale`. Lorsque vous affichez un flow avec `CreateFlowView`, la localisation est résolue automatiquement. Pour les paywalls personnalisés, toutes les localisations disponibles sont retournées ensemble dans `flow.RemoteConfigs` — choisissez la locale correspondant à l'appareil de l'utilisateur ou au paramètre de votre application. Consultez [Localisations et codes de langue](unity-localizations-and-locale-codes) pour plus de détails. ::: ## Récupérer les produits \{#fetch-products\} Une fois que vous avez le flow, vous pouvez récupérer le tableau de produits qui lui correspond : ```csharp showLineNumbers Adapty.GetPaywallProducts(flow, (products, error) => { if (error != null) { // handle the error return; } // products - the requested products array }); ``` Paramètres de la réponse : | Paramètre | Description | | :-------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Products | Liste d'objets `AdaptyPaywallProduct` contenant : identifiant du produit, nom du produit, prix, devise, durée de l'abonnement et plusieurs autres propriétés. | Lors de la mise en œuvre de votre propre design de flow, vous aurez probablement besoin d'accéder à ces propriétés depuis l'objet `AdaptyPaywallProduct`. Les propriétés les plus couramment utilisées sont illustrées ci-dessous. | Propriété | Description | |-------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | **Title** | Pour afficher le titre du produit, utilisez `product.LocalizedTitle`. La localisation se base sur le pays du store sélectionné par l'utilisateur, et non sur la locale de l'appareil. | | **Price** | Pour afficher une version localisée du prix, utilisez `product.Price.LocalizedString`. Cette localisation se base sur les informations de locale de l'appareil. Vous pouvez également accéder au prix sous forme numérique via `product.Price.Amount` — la valeur est fournie dans la devise locale. Pour obtenir le symbole de devise associé, utilisez `product.Price.CurrencySymbol`. | | **Subscription Period** | Pour afficher la période (ex. : semaine, mois, année, etc.), utilisez `product.Subscription?.LocalizedPeriod`. Cette localisation se base sur la locale de l'appareil. Pour récupérer la période d'abonnement par programmation, utilisez `product.Subscription?.Period`. Vous pouvez ensuite accéder à l'enum `Unit` pour obtenir la durée (c'est-à-dire `AdaptySubscriptionPeriodUnit.Day`, `AdaptySubscriptionPeriodUnit.Week`, `AdaptySubscriptionPeriodUnit.Month`, `AdaptySubscriptionPeriodUnit.Year`, ou `AdaptySubscriptionPeriodUnit.Unknown`). La valeur `NumberOfUnits` vous donne le nombre d'unités de période. Par exemple, pour un abonnement trimestriel, vous verrez `AdaptySubscriptionPeriodUnit.Month` dans la propriété `Unit`, et `3` dans la propriété `NumberOfUnits`. | | **Introductory Offer** | Pour afficher un badge ou tout autre indicateur signalant qu'un abonnement contient une offre de lancement, consultez la propriété `product.Subscription?.Offer?.Phases`. Il s'agit d'une liste pouvant contenir jusqu'à deux phases de remise : la phase d'essai gratuit et la phase de prix de lancement. Chaque objet de phase expose les propriétés suivantes :Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `AdaptyPlacementFetchPolicy.ReturnCacheDataElseLoad` pour renvoyer les données en cache lorsqu'elles existent. Dans ce cas, les utilisateurs ne disposeront peut-être pas des toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser pendant la session pour éviter les requêtes réseau.
Notez que le cache reste intact lors du redémarrage de l'application et n'est effacé que lors de la réinstallation de l'application ou via un nettoyage manuel.
|optionnel
par défaut : `en`
|L'identifiant de la [localisation du paywall](add-remote-config-locale). Ce paramètre doit être un code de langue composé d'un ou plusieurs sous-tags séparés par le caractère moins (**-**). Le premier sous-tag correspond à la langue, le second à la région.
Exemple : `en` désigne l'anglais, `pt-br` représente le portugais brésilien.
Consultez [Localisations et codes de langue](unity-localizations-and-locale-codes) pour en savoir plus sur les codes de langue et notre approche recommandée.
| | **fetchPolicy** | par défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Toutefois, si vous pensez que vos utilisateurs ont une connexion instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs ne bénéficieront peut-être pas des toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser pendant la session pour éviter les requêtes réseau.
Notez que le cache est conservé lors du redémarrage de l'application et n'est effacé que lors d'une réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les paywalls sur deux couches : le cache mis à jour régulièrement décrit ci-dessus et les [paywalls de secours](unity-use-fallback-paywalls). Nous utilisons également un CDN pour récupérer les paywalls plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'indisponibilité du CDN. Ce système est conçu pour garantir que vous obtenez toujours la dernière version de vos paywalls, tout en assurant la fiabilité même lorsque la connexion internet est limitée.
| | **loadTimeout** | par défaut : 5 sec |Cette valeur limite le délai d'attente de cette méthode. Si le délai est dépassé, les données en cache ou le fallback local sont renvoyés.
Notez que dans de rares cas, cette méthode peut expirer légèrement après le délai indiqué dans `loadTimeout`, car l'opération peut comprendre différentes requêtes en arrière-plan.
| N'écrivez pas les identifiants de produits en dur ! Puisque les paywalls sont configurés à distance, les produits disponibles, leur nombre et les offres spéciales (comme les essais gratuits) peuvent changer à tout moment. Assurez-vous que votre code gère ces scénarios. Par exemple, si vous récupérez initialement 2 produits, votre application doit afficher ces 2 produits. Mais si vous en récupérez ensuite 3, votre application doit tous les afficher sans nécessiter de modifications du code. La seule chose à écrire en dur est l'identifiant du placement. Paramètres de réponse : | Paramètre | Description | | :-------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- | | Paywall | Un objet [`AdaptyPaywall`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_paywall.html) contenant : une liste d'identifiants de produits, l'identifiant du paywall, le Remote Config, et plusieurs autres propriétés. | ## Récupérer les produits \{#fetch-products\} Une fois que vous avez le paywall, vous pouvez récupérer le tableau de produits qui lui correspond : ```csharp showLineNumbers Adapty.GetPaywallProducts(paywall, (products, error) => { if(error != null) { // handle the error return; } // products - the requested products array }); ``` Paramètres de réponse : | Paramètre | Description | | :-------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Products | Liste d'objets [`AdaptyPaywallProduct`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_paywall_product.html) contenant : l'identifiant du produit, le nom du produit, le prix, la devise, la durée de l'abonnement, ainsi que d'autres propriétés. | Lors de l'implémentation de votre propre design de paywall, vous aurez probablement besoin d'accéder à ces propriétés depuis l'objet [`AdaptyPaywallProduct`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_paywall_product.html). Les propriétés les plus couramment utilisées sont illustrées ci-dessous, mais consultez le document lié pour obtenir des informations complètes sur toutes les propriétés disponibles. | Propriété | Description | |-------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | **Title** | Pour afficher le titre du produit, utilisez `product.LocalizedTitle`. La localisation est basée sur le pays du store sélectionné par l'utilisateur et non sur la langue de l'appareil. | | **Price** | Pour afficher le prix dans une version localisée, utilisez `product.Price.LocalizedString`. Cette localisation est basée sur les informations de langue de l'appareil. Vous pouvez également accéder au prix sous forme numérique via `product.Price.Amount`. La valeur sera fournie dans la devise locale. Pour obtenir le symbole de devise associé, utilisez `product.Price.CurrencySymbol`. | | **Subscription Period** | Pour afficher la période (ex. : semaine, mois, année, etc.), utilisez `product.Subscription?.LocalizedPeriod`. Cette localisation est basée sur la langue de l'appareil. Pour récupérer la période d'abonnement par programmation, utilisez `product.Subscription?.Period`. Vous pouvez ensuite accéder à l'enum `Unit` pour obtenir la durée (c'est-à-dire `AdaptySubscriptionPeriodUnit.Day`, `AdaptySubscriptionPeriodUnit.Week`, `AdaptySubscriptionPeriodUnit.Month`, `AdaptySubscriptionPeriodUnit.Year` ou `AdaptySubscriptionPeriodUnit.Unknown`). La valeur `NumberOfUnits` indique le nombre d'unités de période. Par exemple, pour un abonnement trimestriel, vous obtiendrez `AdaptySubscriptionPeriodUnit.Month` dans la propriété Unit et `3` dans la propriété NumberOfUnits. | | **Introductory Offer** | Pour afficher un badge ou un autre indicateur signalant qu'un abonnement contient une offre de lancement, consultez la propriété `product.Subscription?.Offer?.Phases`. Il s'agit d'une liste pouvant contenir jusqu'à deux phases de remise : la phase d'essai gratuit et la phase de prix de lancement. Chaque objet de phase contient les propriétés utiles suivantes :optionnel
par défaut : `en`
|L'identifiant de la localisation du paywall. Ce paramètre doit être un code de langue composé d'un ou deux sous-tags séparés par le caractère moins (**-**). Le premier sous-tag désigne la langue, le second désigne la région.
Exemple : `en` signifie anglais, `pt-br` représente le portugais brésilien.
| | **fetchPolicy** | par défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs reçoivent toujours les données les plus récentes.
Toutefois, si vous pensez que vos utilisateurs ont une connexion instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs ne disposeront peut-être pas des toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser en cours de session pour éviter les requêtes réseau.
Notez que le cache reste intact après un redémarrage de l'application et n'est effacé que lors d'une réinstallation ou d'un nettoyage manuel.
Le SDK Adapty stocke les paywalls localement en deux couches : le cache mis à jour régulièrement décrit ci-dessus et les paywalls de secours. Nous utilisons également un CDN pour récupérer les paywalls plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'inaccessibilité du CDN. Ce système est conçu pour vous garantir toujours la dernière version de vos paywalls, tout en assurant la fiabilité même lorsque la connexion internet est limitée.
|Si la requête a réussi, la réponse contient cet objet. Un objet [AdaptyProfile](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_profile.html) fournit des informations complètes sur les niveaux d'accès, les abonnements et les achats uniques d'un utilisateur dans l'application.
Vérifiez le statut du niveau d'accès pour déterminer si l'utilisateur dispose de l'accès requis à l'application.
| :::warning **Remarque :** si vous utilisez encore StoreKit en version inférieure à v2.0 et le SDK Adapty en version inférieure à v2.9.0, vous devez fournir le [secret partagé de l'App Store Apple](app-store-connection-configuration#step-5-enter-app-store-shared-secret) à la place. Cette méthode est actuellement dépréciée par Apple. ::: ## Changer d'abonnement lors d'un achat \{#change-subscription-when-making-a-purchase\} Lorsqu'un utilisateur choisit un nouvel abonnement plutôt que de renouveler celui en cours, le fonctionnement dépend du store : - Sur l'App Store, l'abonnement est automatiquement mis à jour au sein du groupe d'abonnements. Si un utilisateur souscrit à un abonnement d'un groupe alors qu'il en a déjà un d'un autre groupe, les deux abonnements seront actifs en même temps. - Sur Google Play, l'abonnement n'est pas mis à jour automatiquement. Vous devrez gérer le changement dans le code de votre application mobile comme décrit ci-dessous. Pour remplacer un abonnement par un autre sur Android, appelez la méthode `.makePurchase()` avec le paramètre supplémentaire suivant : ```csharp showLineNumbers // Create subscription update parameters var subscriptionUpdateParams = new AdaptySubscriptionUpdateParameters( "old_product_id", // Product ID of the current subscription AdaptySubscriptionUpdateReplacementMode.WithTimeProration ); Adapty.MakePurchase(product, subscriptionUpdateParams, (profile, error) => { if(error != null) { // Handle the error return; } // successful cross-grade }); ``` Paramètre de requête supplémentaire : | Paramètre | Présence | Description | | :--------------------------- | :------- |:-------------------------------------------------------------------------------------------------------| | **subscriptionUpdateParams** | requis | un objet [`AdaptySubscriptionUpdateParameters`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_subscription_update_parameters.html). | Vous pouvez en apprendre davantage sur les abonnements et les modes de remplacement dans la documentation Google pour les développeurs : - [À propos des modes de remplacement](https://developer.android.com/google/play/billing/subscriptions#replacement-modes) - [Recommandations de Google pour les modes de remplacement](https://developer.android.com/google/play/billing/subscriptions#replacement-recommendations) - Mode de remplacement [`CHARGE_PRORATED_PRICE`](https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.SubscriptionUpdateParams.ReplacementMode#CHARGE_PRORATED_PRICE()). Remarque : cette méthode est disponible uniquement pour les mises à niveau d'abonnement. Les rétrogradations ne sont pas prises en charge. - Mode de remplacement [`DEFERRED`](https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.SubscriptionUpdateParams.ReplacementMode#DEFERRED()). Remarque : le changement d'abonnement effectif n'aura lieu qu'à la fin de la période de facturation en cours. ## Utiliser des codes d'offre sur iOS \{#redeem-offer-codes-in-ios\}Un objet [`AdaptyProfile`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_profile.html). Ce modèle contient des informations sur les niveaux d'accès, les abonnements et les achats uniques.
Vérifiez le **statut du niveau d'accès** pour déterminer si l'utilisateur a accès à l'application.
| :::tip Vous souhaitez voir un exemple concret d'intégration du SDK Adapty dans une application mobile ? Consultez nos [exemples d'applications](sample-apps), qui illustrent la configuration complète, notamment l'affichage des paywalls, les achats et d'autres fonctionnalités de base. ::: --- # File: implement-observer-mode-unity --- --- title: "Implémenter le mode Observateur dans le SDK Unity" description: "Implémentez le mode observateur dans Adapty pour suivre les événements d'abonnement utilisateur dans le SDK Unity." --- Si vous disposez déjà de votre propre infrastructure d'achat et n'êtes pas prêt à passer entièrement à Adapty, vous pouvez explorer le [mode Observateur](observer-vs-full-mode). Dans sa forme de base, le mode Observateur offre des analyses avancées et une intégration transparente avec les systèmes d'attribution et d'analyse. Si cela correspond à vos besoins, il vous suffit de : 1. L'activer lors de la configuration du SDK en définissant le paramètre `observerMode` sur `true`. Suivez les instructions de configuration pour [Unity](sdk-installation-unity#activate-adapty-module-of-adapty-sdk). 2. [Signaler les transactions](report-transactions-observer-mode-unity) depuis votre infrastructure d'achat existante à Adapty. :::tip Dans la version 4 du SDK, vous pouvez également présenter des flows et des paywalls rendus par Adapty en mode Observer : lorsqu'un utilisateur appuie sur le bouton d'achat ou de restauration, le SDK transmet l'action à votre code afin que vous puissiez effectuer l'achat ou la restauration vous-même. Voir [Présenter des flows en mode Observer](unity-present-flows-in-observer-mode). ::: ### Configuration du mode Observateur \{#observer-mode-setup\} Activez le mode Observateur si vous gérez vous-même les achats et le statut des abonnements, et que vous utilisez Adapty uniquement pour l'envoi d'événements d'abonnement et l'analytique. :::important En mode Observateur, le SDK Adapty ne clôture aucune transaction — assurez-vous de les gérer vous-même. ::: :::note Dans le SDK 4.0, les interfaces de listener suivent la convention C# avec le préfixe I : implémentez `IAdaptyEventListener` plutôt que `AdaptyEventListener`. Les méthodes restent inchangées. Consultez le [guide de migration](migration-to-unity-sdk-v4). ::: ```csharp showLineNumbers title="C#" using UnityEngine; using AdaptySDK; public class AdaptyListener : MonoBehaviour, AdaptyEventListener { void Start() { DontDestroyOnLoad(this.gameObject); Adapty.SetEventListener(this); var builder = new AdaptyConfiguration.Builder("YOUR_PUBLIC_SDK_KEY") .SetObserverMode(true); // Enable observer mode Adapty.Activate(builder.Build(), (error) => { if (error != null) { // handle the error return; } }); } public void OnLoadLatestProfile(AdaptyProfile profile) { } public void OnInstallationDetailsSuccess(AdaptyInstallationDetails details) { } public void OnInstallationDetailsFail(AdaptyError error) { } } ``` | Paramètre | Description | |--------------|---------------------------------------------------------------------------------------------------------------------| | observerMode | Une valeur booléenne qui contrôle le [mode Observateur](observer-vs-full-mode). La valeur par défaut est `false`. | ## Utiliser les paywalls Adapty en mode Observer \{#using-adapty-paywalls-in-observer-mode\} Si vous souhaitez également utiliser les paywalls et les fonctionnalités de test A/B d'Adapty, c'est possible — mais cela nécessite une configuration supplémentaire en mode Observer. Voici ce que vous devrez faire en plus des étapes ci-dessus : 1. Affichez les paywalls normalement pour les [paywalls avec Remote Config](present-remote-config-paywalls-unity). 3. [Associez les paywalls](report-transactions-observer-mode-unity) aux transactions d'achat. --- # File: report-transactions-observer-mode-unity --- --- title: "Signaler les transactions en Observer Mode dans le SDK Unity" description: "Signalez les transactions d'achat en Observer Mode Adapty pour obtenir des informations utilisateurs et suivre les revenus dans le SDK Unity." ---Pour iOS, StoreKit 1 : un objet [SKPaymentTransaction](https://developer.apple.com/documentation/storekit/skpaymenttransaction).
Pour iOS, StoreKit 2 : un objet [Transaction](https://developer.apple.com/documentation/storekit/transaction).
Pour Android : identifiant de type String (purchase.getOrderId de l'achat, où l'achat est une instance de la classe [Purchase](https://developer.android.com/reference/com/android/billingclient/api/Purchase) de la bibliothèque de facturation.
| | variationId | requis | L'identifiant de type String de la variante. Vous pouvez l'obtenir via la propriété `variationId` de l'objet [AdaptyPaywall](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_paywall.html). |phoneNumber
firstName
lastName
| String | | gender | Enum, les valeurs autorisées sont : `female`, `male`, `other` | | birthday | Date | ### Attributs utilisateur personnalisés \{#custom-user-attributes\} Vous pouvez définir vos propres attributs personnalisés, généralement liés à l'utilisation de votre application. Par exemple, pour une application de fitness, il peut s'agir du nombre d'exercices par semaine ; pour une application d'apprentissage des langues, du niveau de connaissance de l'utilisateur, etc. Vous pouvez les utiliser dans des segments pour créer des paywalls et des offres ciblés, ainsi que dans les analyses pour identifier quelles métriques produit influencent le plus les revenus. ```csharp showLineNumbers try { builder = builder.SetCustomStringAttribute("string_key", "string_value"); builder = builder.SetCustomDoubleAttribute("double_key", 123.0f); } catch (Exception e) { // handle the exception } ``` Pour supprimer une clé existante, utilisez la méthode `.withRemoved(customAttributeForKey:)` : ```csharp showLineNumbers try { builder = builder.RemoveCustomAttribute("key_to_remove"); } catch (Exception e) { // handle the exception } ``` Il peut parfois être utile de connaître les attributs personnalisés déjà définis. Pour cela, utilisez le champ `customAttributes` de l'objet `AdaptyProfile`. :::warning Gardez à l'esprit que la valeur de `customAttributes` peut ne pas être à jour, car les attributs utilisateur peuvent être envoyés depuis différents appareils à tout moment — les attributs sur le serveur peuvent donc avoir été modifiés depuis la dernière synchronisation. ::: ### Limites \{#limits\} - Jusqu'à 30 attributs personnalisés par utilisateur - Les noms de clés peuvent comporter jusqu'à 30 caractères. Le nom de clé peut contenir des caractères alphanumériques ainsi que les caractères suivants : `_` `-` `.` - La valeur peut être une chaîne de caractères ou un nombre décimal (float) d'au plus 50 caractères. --- # File: unity-listen-subscription-changes --- --- title: "Vérifier le statut d'abonnement dans le SDK Unity" description: "Suivez et gérez le statut d'abonnement des utilisateurs dans Adapty pour améliorer la rétention client dans votre application Unity." --- Avec Adapty, suivre le statut d'un abonnement est simple. Vous n'avez pas besoin d'insérer manuellement des ID de produits dans votre code. Il vous suffit de vérifier l'existence d'un [niveau d'accès](access-level) actif pour confirmer le statut d'abonnement d'un utilisateur.Un objet [AdaptyProfile](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_profile.html). En général, il suffit de vérifier le statut du niveau d'accès du profil pour déterminer si l'utilisateur dispose d'un accès premium à l'application.
La méthode `.getProfile` fournit le résultat le plus à jour, car elle interroge toujours l'API. Si, pour une raison quelconque (par exemple, absence de connexion internet), le SDK ne parvient pas à récupérer les informations depuis le serveur, les données du cache sont renvoyées. Il est également important de noter que le SDK met régulièrement à jour le cache `AdaptyProfile` afin de maintenir ces informations aussi récentes que possible.
| La méthode `.getProfile()` vous fournit le profil utilisateur à partir duquel vous pouvez obtenir le statut du niveau d'accès. Vous pouvez avoir plusieurs niveaux d'accès par application. Par exemple, si vous avez une application de presse et vendez des abonnements à différentes thématiques indépendamment, vous pouvez créer des niveaux d'accès « sports » et « science ». Mais la plupart du temps, un seul niveau d'accès suffira ; dans ce cas, vous pouvez simplement utiliser le niveau d'accès par défaut « premium ». Voici un exemple pour vérifier le niveau d'accès par défaut « premium » : ```csharp showLineNumbers Adapty.GetProfile((profile, error) => { if (error != null) { // handle the error return; } // "premium" is an identifier of default access level var accessLevel = profile.AccessLevels["premium"]; if (accessLevel != null && accessLevel.IsActive) { // grant access to premium features } }); ``` ### Écouter les mises à jour du statut d'abonnement \{#listening-for-subscription-status-updates\} Chaque fois que l'abonnement d'un utilisateur change, Adapty déclenche un événement. Pour recevoir des messages d'Adapty, vous devez effectuer quelques configurations supplémentaires : :::note Dans le SDK 4.0, les interfaces de listener suivent la convention C# avec préfixe I : implémentez `IAdaptyEventListener` plutôt que `AdaptyEventListener`. Les méthodes restent inchangées. Consultez le [guide de migration](migration-to-unity-sdk-v4). ::: ```csharp showLineNumbers // Extend `AdaptyEventListener ` with `OnLoadLatestProfile ` method: public class AdaptyListener : MonoBehaviour, AdaptyEventListener { public void OnLoadLatestProfile(AdaptyProfile profile) { // handle any changes to subscription state } } ``` Adapty déclenche également un événement au démarrage de l'application. Dans ce cas, le statut d'abonnement mis en cache sera transmis. ### Cache du statut d'abonnement \{#subscription-status-cache\} Le cache implémenté dans le SDK Adapty stocke le statut d'abonnement du profil. Ainsi, même si le serveur est indisponible, les données en cache restent accessibles pour fournir les informations sur le statut d'abonnement du profil. Cependant, il est important de noter qu'il n'est pas possible d'effectuer des requêtes directes sur le cache. Le SDK interroge périodiquement le serveur toutes les minutes pour vérifier s'il existe des mises à jour ou des modifications liées au profil. Si des changements sont détectés, comme de nouvelles transactions ou d'autres mises à jour, ils seront envoyés aux données en cache afin de les maintenir synchronisées avec le serveur. --- # File: unity-deal-with-att --- --- title: "Gérer l'ATT dans le SDK Unity" description: "Démarrez avec Adapty sur Unity pour simplifier la configuration et la gestion des abonnements." --- Si votre application utilise le framework AppTrackingTransparency et présente une demande d'autorisation de suivi à l'utilisateur, vous devez envoyer le [statut d'autorisation](https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/authorizationstatus/) à Adapty. ```csharp showLineNumbers var builder = new Adapty.ProfileParameters.Builder() .SetAppTrackingTransparencyStatus(IOSAppTrackingTransparencyStatus.Authorized); Adapty.UpdateProfile(builder.Build(), (error) => { if(error != null) { // handle the error } }); ``` :::warning Nous vous recommandons vivement d'envoyer cette valeur le plus tôt possible dès qu'elle change — c'est la seule façon de garantir que les données sont transmises en temps opportun aux intégrations que vous avez configurées. ::: --- # File: kids-mode-unity --- --- title: "Mode Enfants dans le SDK Unity" description: "Activez facilement le Mode Enfants pour respecter les politiques d'Apple et de Google. Pas de collecte d'IDFA, GAID ou de données publicitaires dans le SDK Unity." ---optionnel
défaut : `en`
|L'identifiant de la localisation de l'onboarding. Ce paramètre doit être un code de langue composé d'un ou deux sous-tags séparés par le caractère moins (**-**). Le premier sous-tag correspond à la langue, le second à la région.
Exemple : `en` désigne l'anglais, `pt-br` représente le portugais brésilien.
Consultez [Localisations et codes de langue](unity-localizations-and-locale-codes) pour plus d'informations sur les codes de langue et leur utilisation recommandée.
| | **fetchPolicy** | défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option, car elle garantit que vos utilisateurs disposent toujours des données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs pourraient ne pas obtenir les toutes dernières données, mais les temps de chargement seront plus rapides, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser durant la session pour éviter des requêtes réseau.
Notez que le cache reste intact après le redémarrage de l'application et n'est effacé qu'à la désinstallation de celle-ci ou lors d'un nettoyage manuel.
Le SDK Adapty stocke les onboardings localement sur deux couches : le cache mis à jour régulièrement décrit ci-dessus, et les onboardings de secours. Nous utilisons également un CDN pour récupérer les onboardings plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'inaccessibilité du CDN. Ce système est conçu pour vous garantir toujours la dernière version de vos onboardings, tout en assurant une fiabilité même lorsque la connexion internet est limitée.
| | **loadTimeout** | défaut : 5 sec |Cette valeur limite le délai d'attente de cette méthode. Si le délai est dépassé, les données en cache ou le fallback local sont renvoyés.
Notez que dans de rares cas, cette méthode peut expirer légèrement après le délai indiqué dans `loadTimeout`, car l'opération peut impliquer différentes requêtes en coulisses.
| Paramètres de réponse : | Paramètre | Description | |:----------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Onboarding | Un objet [`AdaptyOnboarding`](https://unity.adapty.io/class_adapty_s_d_k_1_1_adapty_onboarding.html) contenant : l'identifiant et la configuration de l'onboarding, le Remote Config, ainsi que plusieurs autres propriétés. | Après avoir récupéré l'onboarding, appelez la méthode `CreateOnboardingView`. :::warning Le résultat de la méthode `CreateOnboardingView` ne peut être utilisé qu'une seule fois. Si vous en avez besoin à nouveau, appelez de nouveau la méthode `CreateOnboardingView`. L'appeler deux fois sans recréer peut entraîner l'erreur `AdaptyUIError.viewAlreadyPresented`. ::: ```csharp showLineNumbers AdaptyUI.CreateOnboardingView(onboarding, (view, error) => { // handle the result }); ``` Paramètres : | Paramètre | Présence | Description | |:---------------| :------------- |:-----------------------------------------------------------------------------| | **onboarding** | requis | Un objet `AdaptyOnboarding` pour obtenir une vue pour l'onboarding souhaité. | | **externalUrlsPresentation** |optionnel
par défaut : `InAppBrowser`
|Contrôle la façon dont les liens de l'onboarding sont ouverts. Options disponibles :
- `AdaptyWebPresentation.InAppBrowser` - Ouvre les liens dans un navigateur intégré à l'application (par défaut)
- `AdaptyWebPresentation.ExternalBrowser` - Ouvre les liens dans le navigateur externe de l'appareil
Consultez [Personnaliser l'ouverture des liens dans les onboardings](unity-present-onboardings#customize-how-links-open-in-onboardings) pour des exemples d'utilisation.
| Une fois que vous avez chargé avec succès l'onboarding et sa configuration d'affichage, vous pouvez [le présenter dans votre application mobile](unity-present-onboardings). ## Accélérer la récupération des onboardings avec l'onboarding de l'audience par défaut \{#speed-up-onboarding-fetching-with-default-audience-onboarding\} En général, les onboardings sont récupérés presque instantanément, vous n'avez donc pas à vous soucier d'accélérer ce processus. Cependant, si vous avez de nombreuses audiences et onboardings, et que vos utilisateurs disposent d'une connexion internet faible, la récupération d'un onboarding peut prendre plus de temps que souhaité. Dans ces situations, vous pouvez afficher un onboarding par défaut pour garantir une expérience fluide plutôt que de ne rien afficher du tout. Pour résoudre ce problème, vous pouvez utiliser la méthode `GetOnboardingForDefaultAudience`, qui récupère l'onboarding du placement spécifié pour l'audience **All Users**. Cependant, il est essentiel de comprendre que l'approche recommandée est de récupérer l'onboarding via la méthode `getOnboarding`, comme détaillé dans la section [Récupérer l'onboarding](#fetch-onboarding-and-create-view) ci-dessus. :::warning Préférez `GetOnboarding` à `GetOnboardingForDefaultAudience`, car cette dernière présente des limitations importantes : - **Problèmes de compatibilité** : Peut créer des problèmes lors de la prise en charge de plusieurs versions de l'application, nécessitant soit des conceptions rétrocompatibles, soit d'accepter que les anciennes versions s'affichent incorrectement. - **Pas de personnalisation** : Affiche uniquement le contenu pour l'audience « Tous les utilisateurs », supprimant le ciblage basé sur le pays, l'attribution ou les attributs personnalisés. Si une récupération plus rapide compense ces inconvénients pour votre cas d'utilisation, utilisez `GetOnboardingForDefaultAudience` comme indiqué ci-dessous. Sinon, utilisez `GetOnboarding` comme décrit [ci-dessus](#fetch-onboarding-and-create-view). ::: ```csharp showLineNumbers Adapty.GetOnboardingForDefaultAudience("YOUR_PLACEMENT_ID", (onboarding, error) => { if (error != null) { // handle the error return; } // the requested onboarding }); ``` Paramètres : | Paramètre | Présence | Description | |---------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | **placementId** | requis | L'identifiant du [Placement](placements) souhaité. C'est la valeur que vous avez spécifiée lors de la création d'un placement dans l'Adapty Dashboard. | | **locale** |optionnel
défaut : `en`
|L'identifiant de la localisation de l'onboarding. Ce paramètre doit être un code de langue composé d'un ou deux sous-tags séparés par le caractère moins (**-**). Le premier sous-tag correspond à la langue, le second à la région.
Exemple : `en` désigne l'anglais, `pt-br` représente le portugais brésilien.
| | **fetchPolicy** | défaut : `.reloadRevalidatingCacheData` |Par défaut, le SDK tente de charger les données depuis le serveur et renvoie les données en cache en cas d'échec. Nous recommandons cette option car elle garantit que vos utilisateurs obtiennent toujours les données les plus récentes.
Cependant, si vous pensez que vos utilisateurs ont une connexion internet instable, envisagez d'utiliser `.returnCacheDataElseLoad` pour renvoyer les données en cache si elles existent. Dans ce cas, les utilisateurs n'auront peut-être pas les toutes dernières données, mais le chargement sera plus rapide, quelle que soit la qualité de leur connexion. Le cache est mis à jour régulièrement, il est donc sûr de l'utiliser pendant la session pour éviter les requêtes réseau.
Notez que le cache reste intact après le redémarrage de l'application et n'est effacé que lors de la désinstallation ou via un nettoyage manuel.
Le SDK Adapty stocke les onboardings localement en deux couches : le cache mis à jour régulièrement décrit ci-dessus et les onboardings de secours. Nous utilisons également un CDN pour récupérer les onboardings plus rapidement, ainsi qu'un serveur de secours indépendant en cas d'indisponibilité du CDN. Ce système est conçu pour garantir que vous obtenez toujours la dernière version de vos onboardings tout en assurant la fiabilité même lorsque la connexion internet est limitée.
| --- # File: unity-present-onboardings --- --- title: "Présenter les onboardings dans le SDK Unity" description: "Apprenez à présenter les onboardings efficacement pour augmenter vos conversions." --- :::warning **Les onboardings sont dépréciés dans le SDK v4 et seront supprimés dans une prochaine version.** Ils ne reçoivent plus de correctifs ni d'améliorations. Utilisez les [flows](unity-get-pb-paywalls) à la place : contrairement aux onboardings, qui s'exécutent dans une WebView, les flows s'affichent nativement sur l'appareil — offrant des animations plus fluides, un rendu natif cohérent, des temps de chargement plus rapides et aucune dépendance à un runtime WebView. Consultez [Obtenir des flows et paywalls](unity-get-pb-paywalls) et [Afficher des flows et paywalls](unity-present-paywalls) pour commencer. ::: Si vous avez personnalisé un onboarding avec le builder, vous n'avez pas besoin de vous soucier de son rendu dans votre code Unity pour l'afficher à l'utilisateur. Un tel onboarding contient à la fois ce qui doit être affiché et comment cela doit l'être. Avant de commencer, assurez-vous que : 1. Vous avez installé [Adapty Unity SDK](sdk-installation-unity) 3.14.0 ou version ultérieure. 2. Vous avez [créé un onboarding](create-onboarding). 3. Vous avez ajouté l'onboarding à un [placement](placements). Pour afficher un onboarding, utilisez la méthode `view.Present()` sur la `view` créée par la méthode `CreateOnboardingView`. Chaque `view` ne peut être utilisée qu'une seule fois. Si vous devez afficher le paywall à nouveau, appelez `CreateOnboardingView` une nouvelle fois pour créer une nouvelle instance de `view`. :::warning Réutiliser la même `view` sans la recréer peut entraîner une erreur `AdaptyUIError.viewAlreadyPresented`. ::: ```csharp showLineNumbers title="Unity" view.Present((presentError) => { if (presentError != null) { // handle the error } }; ``` ## Configurer le style de présentation iOS \{#configure-ios-presentation-style\} Configurez la façon dont l'onboarding est présenté sur iOS en passant le paramètre `iosPresentationStyle` à la méthode `Present()`. Le paramètre accepte les valeurs `AdaptyUIIOSPresentationStyle.FullScreen` (par défaut) ou `AdaptyUIIOSPresentationStyle.PageSheet`. ```csharp showLineNumbers title="Unity" view.Present(AdaptyUIIOSPresentationStyle.PageSheet, (error) => { // handle the error }); ``` ## Personnaliser l'ouverture des liens dans les onboardings \{#customize-how-links-open-in-onboardings\} :::important La personnalisation de l'ouverture des liens dans les onboardings est prise en charge à partir du SDK Adapty v3.15. ::: Par défaut, les liens dans les onboardings s'ouvrent dans un navigateur intégré à l'application, offrant une expérience fluide en affichant les pages web directement dans votre application sans changer d'app. Pour ouvrir les liens dans un navigateur externe à la place, passez `AdaptyWebPresentation.ExternalBrowser` à la méthode `CreateOnboardingView` : ```csharp showLineNumbers title="Unity" AdaptyUI.CreateOnboardingView( onboarding, AdaptyWebPresentation.ExternalBrowser, // default — InAppBrowser (view, error) => { if (error != null) { // handle the error return; } // present the onboarding view view.Present((presentError) => { if (presentError != null) { // handle the error } }); } ); ``` Options disponibles : - `AdaptyWebPresentation.InAppBrowser` - Ouvre les liens dans un navigateur intégré à l'application (par défaut) - `AdaptyWebPresentation.ExternalBrowser` - Ouvre les liens dans le navigateur externe de l'appareil --- # File: unity-handling-onboarding-events --- --- title: "Gérer les événements d'onboarding dans le SDK Unity" description: "Gérez les événements liés à l'onboarding dans Unity avec Adapty." --- :::warning **Les onboardings sont dépréciés dans le SDK v4 et seront supprimés dans une prochaine version.** Ils ne reçoivent plus de correctifs ni d'améliorations. Utilisez les [flows](unity-get-pb-paywalls) à la place : contrairement aux onboardings, qui s'exécutent dans une WebView, les flows s'affichent nativement sur l'appareil — offrant des animations plus fluides, un rendu natif cohérent, des temps de chargement plus rapides, et aucune dépendance à un runtime WebView. Consultez [Obtenir des flows & paywalls](unity-get-pb-paywalls) et [Afficher des flows & paywalls](unity-present-paywalls) pour commencer. ::: Avant de commencer, assurez-vous que : 1. Vous avez installé [le SDK Adapty Unity](sdk-installation-unity) version 3.14.0 ou ultérieure. 2. Vous avez [créé un onboarding](create-onboarding). 3. Vous avez ajouté l'onboarding à un [placement](placements). Les onboardings configurés avec le builder génèrent des événements auxquels votre application peut réagir. Découvrez ci-dessous comment gérer ces événements. Pour contrôler ou surveiller les processus qui se déroulent sur l'écran d'onboarding dans votre application Unity, implémentez l'interface `AdaptyOnboardingsEventsListener`. :::note Dans le SDK 4.0, les interfaces listener suivent la convention de préfixe C# `I-` : implémentez `IAdaptyOnboardingsEventsListener` plutôt que `AdaptyOnboardingsEventsListener`. Les méthodes restent inchangées. Consultez le [guide de migration](migration-to-unity-sdk-v4). ::: ## Actions personnalisées \{#custom-actions\} Dans le builder, vous pouvez ajouter une action **personnalisée** à un bouton et lui attribuer un identifiant.
Ensuite, vous pouvez utiliser cet ID dans votre code et le gérer comme une action personnalisée. Par exemple, si un utilisateur appuie sur un bouton personnalisé, comme **Login** ou **Allow notifications**, la méthode `OnboardingViewOnCustomAction` sera déclenchée avec le paramètre `actionId` correspondant à l'**Action ID** défini dans le builder. Vous pouvez créer vos propres IDs, comme "allowNotifications".
Pour gérer les événements d'onboarding, implémentez l'interface `AdaptyOnboardingsEventsListener` :
```csharp showLineNumbers title="Unity"
public class OnboardingManager : MonoBehaviour, AdaptyOnboardingsEventsListener
{
void Start()
{
Adapty.SetOnboardingsEventsListener(this);
}
public void OnboardingViewOnCustomAction(
AdaptyUIOnboardingView view,
AdaptyUIOnboardingMeta meta,
string actionId
)
{
if (actionId == "allowNotifications") {
// request notification permissions
}
}
public void OnboardingViewDidFailWithError(
AdaptyUIOnboardingView view,
AdaptyError error
)
{
// handle errors
}
// Implement other required interface methods (see examples below)
}
```
:::important
Notez que vous devez gérer ce qui se passe lorsqu'un utilisateur ferme l'onboarding. Par exemple, vous devez arrêter d'afficher l'onboarding lui-même.
:::
Implémentez la méthode `OnboardingViewOnCloseAction` dans votre classe :
```csharp showLineNumbers title="Unity"
public class OnboardingManager : MonoBehaviour, AdaptyOnboardingsEventsListener
{
public void OnboardingViewOnCloseAction(
AdaptyUIOnboardingView view,
AdaptyUIOnboardingMeta meta,
string actionId
)
{
view.Dismiss((error) => {
if (error != null) {
// handle the error
}
});
}
// ... other interface methods
}
```
Ce code d'erreur indique que l'utilisateur a annulé une demande de paiement.
Aucune action n'est requise, mais d'un point de vue logique métier, vous pouvez proposer une remise à votre utilisateur ou lui rappeler ultérieurement.
| | [paymentInvalid](https://developer.apple.com/documentation/storekit/skerror/code/paymentinvalid) | 3 | Cette erreur indique que l'un des paramètres de paiement n'a pas été reconnu par l'App Store. | | [paymentNotAllowed](https://developer.apple.com/documentation/storekit/skerror/code/paymentnotallowed) | 4 | Ce code d'erreur indique que l'utilisateur n'est pas autorisé à valider des paiements. | | [storeProductNotAvailable](https://developer.apple.com/documentation/storekit/skerror/code/storeproductnotavailable) | 5 | Ce code d'erreur indique que le produit demandé n'est pas disponible dans le store.L'[`identifiant`](https://developer.apple.com/documentation/storekit/skpaymentdiscount/identifier) de l'offre n'est pas valide. Par exemple, vous n'avez pas configuré d'offre avec cet identifiant dans l'App Store, ou vous avez révoqué l'offre.
Assurez-vous de configurer les offres souhaitées dans AppStore Connect et de passer un identifiant d'offre valide.
| | [invalidSignature](https://developer.apple.com/documentation/storekit/skerror/code/invalidsignature) | 12 | Ce code d'erreur indique que la signature dans une remise de paiement n'est pas valide. | | [missingOfferParams](https://developer.apple.com/documentation/storekit/skerror/code/missingofferparams) | 13 | Ce code d'erreur indique que des paramètres sont manquants dans une remise de paiement. | | [invalidOfferPrice](https://developer.apple.com/documentation/storekit/skerror/code/invalidofferprice/) | 14 | Ce code d'erreur indique que le prix que vous avez spécifié dans App Store Connect n'est plus valide. Les offres doivent toujours représenter un prix réduit. | ## Codes Android personnalisés \{#custom-android-codes\} | Erreur | Code | Solution | |-----|----|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | adaptyNotInitialized | 20 | Vous devez configurer correctement le SDK Adapty via la méthode `Adapty.activate`. Découvrez comment le faire [pour Unity](sdk-installation-unity#activate-adapty-module-of-adapty-sdk). | | productNotFound | 22 | Cette erreur indique que le produit demandé pour l'achat n'est pas disponible dans le store. | | invalidJson | 23 | Le JSON du paywall n'est pas valide. Corrigez-le dans l'Adapty Dashboard. Consultez la rubrique [Personnaliser le paywall avec Remote Config](customize-paywall-with-remote-config) pour savoir comment le corriger. | | currentSubscriptionToUpdateNotFoundInHistory | 24 | L'abonnement d'origine qui doit être renouvelé est introuvable. | | pendingPurchase | 25 | Cette erreur indique que l'état de l'achat est en attente plutôt que finalisé. Consultez la page [Gestion des transactions en attente](https://developer.android.com/google/play/billing/integrate#pending) dans la documentation Android Developer pour plus de détails. | | billingServiceTimeout | 97 | Cette erreur indique que la requête a atteint le délai d'attente maximum avant que Google Play puisse répondre. Cela peut être causé, par exemple, par un délai dans l'exécution de l'action demandée par l'appel à la bibliothèque Play Billing. | | featureNotSupported | 98 | La fonctionnalité demandée n'est pas prise en charge par le Play Store sur l'appareil actuel. | | billingServiceDisconnected | 99 | Cette erreur fatale indique que la connexion de l'application cliente au service Google Play Store via le `BillingClient` a été interrompue. | | billingServiceUnavailable | 102 | Cette erreur transitoire indique que le service Google Play Billing est actuellement indisponible. Dans la plupart des cas, cela signifie qu'il y a un problème de connexion réseau quelque part entre l'appareil client et les services Google Play Billing. | | billingUnavailable | 103 |Cette erreur indique qu'une erreur de facturation utilisateur s'est produite pendant le processus d'achat. Exemples de situations où cela peut se produire :
1\. L'application Play Store sur l'appareil de l'utilisateur est obsolète.
2. L'utilisateur se trouve dans un pays non pris en charge.
3. L'utilisateur est un utilisateur entreprise et son administrateur a désactivé les achats pour les utilisateurs.
4. Google Play ne peut pas débiter le moyen de paiement de l'utilisateur. Par exemple, la carte de crédit de l'utilisateur a peut-être expiré.
5. L'utilisateur n'est pas connecté à l'application Play Store.
| | developerError | 105 | Il s'agit d'une erreur fatale indiquant que vous utilisez une API de manière incorrecte. | | billingError | 106 | Il s'agit d'une erreur fatale indiquant un problème interne avec Google Play lui-même. | | itemAlreadyOwned | 107 | Le produit consommable a déjà été acheté. | | itemNotOwned | 108 | Cette erreur indique que l'action demandée sur l'article a échoué car | ## Codes StoreKit personnalisés \{#custom-storekit-codes\} | Erreur | Code | Solution | |-----|----|-----------| | noProductIDsFound | 1000 |Cette erreur indique qu'aucun des produits que vous avez demandés sur le paywall n'est disponible à l'achat dans l'App Store, même s'ils y sont répertoriés. Cette erreur peut parfois s'accompagner d'un avertissement `InvalidProductIdentifiers`. Si l'avertissement apparaît sans erreur, ignorez-le.
Si vous rencontrez cette erreur, suivez les étapes de la section [Correction de l'erreur Code-1000 `noProductIDsFound`](InvalidProductIdentifiers-unity).
| | productRequestFailed | 1002 |Impossible de récupérer les produits disponibles pour le moment. Raison possible :
- Aucun cache n'a encore été créé et il n'y a pas de connexion Internet en même temps.
| | cantMakePayments | 1003 | Les achats intégrés ne sont pas autorisés sur cet appareil. Consultez le [guide](cantMakePayments-unity) de dépannage. | | noPurchasesToRestore | 1004 | Cette erreur indique que Google Play n'a pas trouvé d'achat à restaurer. | | cantReadReceipt | 1005 |Aucun reçu valide n'est disponible sur l'appareil. Cela peut poser problème lors des tests en sandbox.
Aucune action n'est requise, mais d'un point de vue logique métier, vous pouvez proposer une remise à votre utilisateur ou lui rappeler ultérieurement.
| | productPurchaseFailed | 1006 | L'achat du produit a échoué. Cela encapsule une erreur StoreKit sous-jacente — lisez l'erreur encapsulée (ou activez les logs verbeux pour la voir dans la console) pour connaître la raison réelle. L'erreur encapsulée correspond généralement à l'un des codes StoreKit 0–14 du tableau ci-dessus — le plus souvent `paymentCancelled`, `paymentInvalid`, `paymentNotAllowed` ou `invalidOfferPrice`. Si vous ne pouvez pas identifier une raison précise, essayez un nouveau [profil sandbox](test-purchases-in-sandbox) ; si cela échoue encore, contactez le support Apple. | | refreshReceiptFailed | 1010 | Cette erreur indique que le reçu n'a pas été reçu. Applicable uniquement à StoreKit 1. | | receiveRestoredTransactionsFailed | 1011 | La restauration des achats a échoué. | ## Codes réseau personnalisés \{#custom-network-codes\} | Erreur | Code | Solution | |:---------------------|:-----|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | notActivated | 2002 | Le SDK Adapty n'est pas activé.
2. Cliquez sur le nom du groupe d'abonnements. Vos produits apparaîtront dans la section **Subscriptions**.
3. Assurez-vous que le produit que vous testez est marqué **Ready to Submit**.
4. Comparez l'identifiant du produit dans le tableau avec celui qui figure dans l'onglet [**Products**](https://app.adapty.io/products) de l'Adapty Dashboard. Si les identifiants ne correspondent pas, copiez l'identifiant du produit depuis le tableau et [créez un produit](create-product) avec cet identifiant dans l'Adapty Dashboard.
## Étape 3. Vérifier la disponibilité du produit \{#step-4-check-product-availability\}
1. Retournez dans **App Store Connect** et ouvrez la même section **Subscriptions**.
2. Cliquez sur le nom du groupe d'abonnements pour afficher vos produits.
3. Sélectionnez le produit que vous testez.
4. Faites défiler jusqu'à la section **Availability** et vérifiez que tous les pays et régions requis y sont bien listés.
## Étape 4. Vérifier les prix du produit \{#step-5-check-product-prices\}
1. De nouveau, rendez-vous dans la section **Monetization** → **Subscriptions** d'**App Store Connect**.
2. Cliquez sur le nom du groupe d'abonnements.
3. Sélectionnez le produit que vous testez.
4. Faites défiler jusqu'à **Subscription Pricing** et dépliez la section **Current Pricing for New Subscribers**.
5. Vérifiez que tous les prix requis sont bien listés.
## Étape 5. Vérifier le statut des apps payantes, le compte bancaire et les formulaires fiscaux \{#step-5-check-app-paid-status-bank-account-and-tax-forms-are-active\}
1. Sur la page d'accueil d'[**App Store Connect**](https://appstoreconnect.apple.com/), cliquez sur **Business**.
2. Sélectionnez le nom de votre entreprise.
3. Faites défiler vers le bas et vérifiez que votre **Paid Apps Agreement**, votre **Bank Account** et vos **Tax forms** affichent bien le statut **Active**.
En suivant ces étapes, vous devriez pouvoir résoudre l'avertissement `InvalidProductIdentifiers` et rendre vos produits disponibles dans le store.
## Étape 6. Recréer le produit s'il est bloqué \{#step-6-recreate-the-product-if-its-stuck\}
Les étapes 1 à 5 peuvent toutes passer avec succès — statut `Approved`, Bundle ID correspondant, clé API valide — et pourtant le SDK continue de retourner `1000 noProductIDsFound`. Dans ce cas, le produit est peut-être bloqué dans le registre d'Apple. Il arrive que le registre de produits d'Apple entre dans un état où un produit existe dans l'interface d'App Store Connect mais n'est pas exposé au chemin de recherche StoreKit.
Supprimez le produit dans App Store Connect et recréez-le avec le même identifiant. Attendez jusqu'à 24 heures après la recréation pour que la propagation soit effective.
---
# File: cantMakePayments-unity
---
---
title: "Correction de l'erreur Code-1003 cantMakePayment dans le SDK Unity"
description: "Résolvez l'erreur de paiement lors de la gestion des abonnements dans Adapty."
---
L'erreur 1003, `cantMakePayments`, indique que les achats intégrés ne peuvent pas être effectués sur cet appareil.
Si vous rencontrez l'erreur `cantMakePayments`, cela est généralement dû à l'une des raisons suivantes :
- Restrictions de l'appareil : L'erreur n'est pas liée à Adapty. Consultez les solutions ci-dessous.
- Configuration du mode Observateur : La méthode `makePurchase` et le mode Observateur ne peuvent pas être utilisés simultanément. Consultez la section ci-dessous.
## Problème : Restrictions de l'appareil \{#issue-device-restrictions\}
| Problème | Solution |
|--------------------------------|-------------------------------------------------------------------------------------------------------------|
| Restrictions Screen Time | Désactivez les restrictions d'achat intégré dans [Screen Time](https://support.apple.com/en-us/102470) |
| Compte suspendu | Contactez le support Apple pour résoudre les problèmes de compte |
| Restrictions régionales | Utilisez un compte App Store d'une région prise en charge |
## Problème : Utilisation simultanée du mode Observateur et de makePurchase \{#issue-using-both-observer-mode-and-makepurchase\}
Si vous utilisez `makePurchases` pour gérer les achats, vous n'avez pas besoin d'utiliser le mode Observateur. Le [mode Observateur](observer-vs-full-mode) n'est nécessaire que si vous implémentez vous-même la logique d'achat.
Ainsi, si vous utilisez `makePurchase`, vous pouvez supprimer en toute sécurité l'activation du mode Observateur dans le code d'initialisation du SDK.
---
# File: unity-sdk-migration-guides
---
---
title: "Guides de migration du SDK Unity"
description: "Guides de migration pour les versions du SDK Unity d'Adapty."
---
Cette page regroupe tous les guides de migration pour le SDK Unity d'Adapty. Choisissez la version vers laquelle vous souhaitez migrer pour obtenir des instructions détaillées :
- **[Migrer vers la v4.0 (bêta)](migration-to-unity-sdk-v4)**
- **[Migrer vers la v3.14](migration-to-unity-sdk-314)**
- **[Migrer vers la v3.4](migration-to-unity-sdk-34)**
- **[Migrer vers la v3.3](migration-to-unity330)**
- **[Migrer vers la v3.0](migration-to-unity-sdk-v3)**
---
# File: migration-to-unity-sdk-v4
---
---
title: "Migrer le SDK Adapty Unity vers la v4.0"
description: "Migrez vers le SDK Adapty Unity v4.0 (beta) en remplaçant les API paywall par des API flow, compatibles avec le Flow Builder et le Paywall Builder."
---
Le SDK Adapty Unity 4.0 (beta) introduit les flows et renomme les API paywall en conséquence. Les nouvelles API fonctionnent à la fois avec le nouveau Flow Builder et le Paywall Builder existant — aucune modification de configuration n'est requise côté Adapty Dashboard.
## Référence rapide \{#quick-reference\}
| v3 | v4 |
|---|---|
| `Adapty.GetPaywall(placementId, locale, ...)` | `Adapty.GetFlow(placementId, ...)` |
| `Adapty.GetPaywallForDefaultAudience(placementId, locale, ...)` | `Adapty.GetFlowForDefaultAudience(placementId, ...)` |
| `Adapty.GetPaywallProducts(paywall, ...)` | `Adapty.GetPaywallProducts(flow, ...)` |
| `Adapty.LogShowPaywall(paywall, ...)` | `Adapty.LogShowFlow(flow, ...)` |
| `AdaptyPaywall` | `AdaptyFlow` |
| `AdaptyUI.CreatePaywallView(paywall, ...)` | `AdaptyUI.CreateFlowView(flow, ...)` |
| `AdaptyUICreatePaywallViewParameters` | `AdaptyUICreateFlowViewParameters` |
| `AdaptyUIPaywallView` | `AdaptyUIFlowView` |
| `AdaptyUI.PresentPaywallView(view, ...)` / `DismissPaywallView(view, ...)` | `AdaptyUI.PresentFlowView(view, ...)` / `DismissFlowView(view, ...)` |
| `Adapty.SetPaywallsEventsListener(listener)` | `Adapty.SetFlowsEventsListener(listener)` |
| `AdaptyPaywallsEventsListener` | `IAdaptyFlowsEventsListener` |
| `AdaptyEventListener` | `IAdaptyEventListener` |
| `AdaptyOnboardingsEventsListener` | `IAdaptyOnboardingsEventsListener` |
| `PaywallViewDidPerformAction`, `PaywallViewDidAppear`, et autres callbacks `PaywallView...` | `FlowViewDidPerformAction`, `FlowViewDidAppear`, et autres callbacks `FlowView...` |
| `PaywallViewDidFailRendering` | `FlowViewDidReceiveError` |
| `Adapty.SetFallbackPaywalls(...)` (déprécié en v3) | supprimé — utilisez `Adapty.SetFallback(fileName, ...)` |
| `Builder.SetIDFACollectionDisabled(...)` (déprécié en v3) | supprimé — utilisez `Builder.SetAppleIDFACollectionDisabled(...)` |
| `paywall.Products` (une liste de `AdaptyProductReference`) | supprimé — utilisez `ProductIdentifiers` ou `VendorProductIds`, ou appelez `GetPaywallProducts(flow)` pour les produits complets |
| `AdaptyProductReference` | supprimé en tant que type public — voir [Modèle de données](#data-model) |
| `paywall.RemoteConfigString` | supprimé — utilisez `flow.RemoteConfig?.Data` |
`AdaptyPaywallProduct` garde son nom — les produits appartiennent toujours à un flow, et `GetPaywallProducts` garde également son nom, prenant désormais un `AdaptyFlow`. Les méthodes `GetFlow` et `GetFlowForDefaultAudience` ne prennent plus de paramètre `locale`. Les API d'achat et de profil (`MakePurchase`, `RestorePurchases`, `GetProfile`, `Identify`, `UpdateProfile`) et les fallbacks via `SetFallback` sont inchangés. Les méthodes onboarding fonctionnent toujours mais sont dépréciées — voir [Dépréciation de l'API Onboarding](#onboarding-api-deprecation). Certains comportements par défaut ont changé — voir [Changements de comportement par défaut](#default-behavior-changes).
## Installation \{#installation\}
La v4.0 est une pré-version, donc épinglez le tag bêta exact. Pour l'installer via le Unity Package Manager, ajoutez le tag à l'URL Git :
```
https://github.com/adaptyteam/AdaptySDK-Unity.git?path=/Packages/com.adapty.unity-sdk#4.0.0-beta.1
```
Si vous installez via le package Unity, téléchargez `adapty-unity-plugin-4.0.0-beta.1.unitypackage` depuis la [version 4.0.0-beta.1](https://github.com/adaptyteam/AdaptySDK-Unity/releases/tag/4.0.0-beta.1). Consultez [Installer le SDK Adapty](sdk-installation-unity#install-adapty-sdk) pour la configuration complète.
Deux changements de configuration de build sont introduits avec la v4 :
- **Les dépendances iOS passent à Swift Package Manager.** Le SDK iOS natif Adapty 4.0 est déclaré comme package Swift distant au lieu d'un pod CocoaPods. Mettez à jour l'[External Dependency Manager](https://github.com/googlesamples/unity-jar-resolver#getting-started) vers la version **1.2.188 ou ultérieure** — les versions antérieures ne prennent pas en charge les dépendances Swift Package Manager. Les étapes CocoaPods (`iOS Resolver -> Install Cocoapods`, ouverture de `Unity-iPhone.xcworkspace`) ne s'appliquent plus.
- **La cible de déploiement iOS doit être 15.0 ou supérieure.** Un nouveau validateur de build dans l'éditeur Unity bloque le build iOS si la cible est inférieure.
Les SDK natifs Adapty sous-jacents passent à la version 4.x sur les deux plateformes et sont résolus automatiquement — aucune autre modification de build n'est nécessaire.
## Récupération des flows \{#fetching-flows\}
### GetPaywall → GetFlow
Le type retourné passe de `AdaptyPaywall` à `AdaptyFlow`, et le paramètre `locale` est supprimé — lors du rendu d'un flow, la locale est résolue automatiquement ; pour les paywalls personnalisés, toutes les locales sont retournées dans `flow.RemoteConfigs` :
```diff showLineNumbers
- Adapty.GetPaywall("YOUR_PLACEMENT_ID", "en", (paywall, error) => {
+ Adapty.GetFlow("YOUR_PLACEMENT_ID", (flow, error) => {
if (error != null) {
// handle the error
return;
}
- // use the paywall
+ // use the flow
});
```
`GetPaywallForDefaultAudience` est renommé de la même façon :
```diff showLineNumbers
- Adapty.GetPaywallForDefaultAudience("YOUR_PLACEMENT_ID", "en", (paywall, error) => { /* ... */ });
+ Adapty.GetFlowForDefaultAudience("YOUR_PLACEMENT_ID", (flow, error) => { /* ... */ });
```
### GetPaywallProducts(paywall) → GetPaywallProducts(flow)
`GetPaywallProducts` conserve son nom mais prend désormais un `AdaptyFlow` :
```diff showLineNumbers
- Adapty.GetPaywallProducts(paywall, (products, error) => {
+ Adapty.GetPaywallProducts(flow, (products, error) => {
if (error != null) {
// handle the error
return;
}
// use the products
});
```
## Modèle de données \{#data-model\}
`GetFlow` retourne un `AdaptyFlow` au lieu d'un `AdaptyPaywall`, et la forme de l'objet a changé :
| Propriété v3 `AdaptyPaywall` | Propriété v4 `AdaptyFlow` | Action |
|---|---|---|
| `RemoteConfig` (unique, nullable) | `RemoteConfigs` (liste) | Un flow contient une Remote Config par langue configurée. Lisez celle qui correspond à l'utilisateur via `flow.RemoteConfigs`. Le raccourci `flow.RemoteConfig` renvoie la première entrée. |
| _(nouveau)_ | `Paywalls` (liste de `AdaptyFlowPaywall`) | Chaque entrée est une variation de paywall dans le flow, avec son propre `Name`, `VariationId` et `ProductIdentifiers`. Les méthodes de paywall web prennent un `AdaptyFlowPaywall` — voir [Méthodes de paywall web](#web-paywall-methods). |
| `ProductIdentifiers`, `VendorProductIds` | conservé | Sur `AdaptyFlow`, ces propriétés agrègent les produits de toutes les variations de paywall. Chaque variation expose également ses propres `ProductIdentifiers` et `VendorProductIds`. Pour récupérer les produits, continuez d'appeler `GetPaywallProducts(flow)`. |
| `HasViewConfiguration` | supprimé | Supprimez tout contrôle `HasViewConfiguration` de votre code — `CreateFlowView` renvoie une erreur à la place (voir [Affichage des flows](#displaying-flows)). |
| `Products` (liste de `AdaptyProductReference`) | supprimé | `AdaptyProductReference` n'est plus public, et avec lui les valeurs `PromotionalOfferId`, `WinBackOfferId` et `AndroidOfferId` qu'il portait. Utilisez `ProductIdentifiers` — une liste de `AdaptyProductIdentifier` avec `VendorProductId` et le `BasePlanId` réservé à Android (le `AndroidBasePlanId` de la v3) — ou appelez `GetPaywallProducts(flow)` quand vous avez besoin d'objets `AdaptyPaywallProduct` complets avec les prix et les offres. |
| `RemoteConfigString` | supprimé | Lisez la chaîne directement depuis la Remote Config : `flow.RemoteConfig?.Data`, ou l'entrée correspondante dans `flow.RemoteConfigs`. |
| _(nouveau)_ | `FlowVersionId` (nullable) | L'identifiant de version du flow, ou `null` s'il n'est pas disponible. |
`AdaptyPaywallProduct` gagne un champ supplémentaire : `FlowProductId`, l'identifiant du produit au sein du flow, qui est `null` pour les produits n'appartenant pas à un flow.
## Méthodes de paywall web \{#web-paywall-methods\}
`OpenWebPaywall` et `CreateWebPaywallUrl` conservent leurs noms, mais l'argument `paywall` accepte désormais un `AdaptyFlowPaywall` — l'une des variantes dans `flow.Paywalls`. Vous pouvez toujours passer un `AdaptyPaywallProduct` à la place :
```diff showLineNumbers
- Adapty.OpenWebPaywall(paywall, AdaptyWebPresentation.ExternalBrowser, (error) => { /* ... */ });
+ var flowPaywall = flow.Paywalls.FirstOrDefault();
+ if (flowPaywall != null) {
+ Adapty.OpenWebPaywall(flowPaywall, AdaptyWebPresentation.ExternalBrowser, (error) => { /* ... */ });
+ }
```
## Suivi des vues de flow \{#tracking-flow-views\}
### LogShowPaywall → LogShowFlow
`LogShowPaywall` est renommé en `LogShowFlow` et prend désormais un `AdaptyFlow`. L'événement est toujours enregistré pour la même variation, donc les métriques de funnel et de test A/B existantes continuent de fonctionner sans modifications du tableau de bord.
```diff showLineNumbers
- Adapty.LogShowPaywall(paywall, (error) => { /* ... */ });
+ Adapty.LogShowFlow(flow, (error) => { /* ... */ });
```
Comme dans la v3, vous n'avez pas besoin d'appeler cette méthode lors de l'affichage des flows ou des paywalls rendus par le [Flow Builder](adapty-flow-builder) ou le [Paywall Builder](adapty-paywall-builder) — Adapty suit automatiquement ces vues.
## Afficher des flows \{#displaying-flows\}
### CreatePaywallView → CreateFlowView
Renommez la méthode factory et passez l'`AdaptyFlow`. Le type de vue retourné est renommé de `AdaptyUIPaywallView` en `AdaptyUIFlowView`, mais ses méthodes (`Present`, `Dismiss`) restent inchangées, et l'objet de paramètres optionnels conserve les mêmes champs (`LoadTimeout`, `PreloadProducts`, `CustomTags`, `CustomTimers`, `CustomAssets`, `ProductPurchaseParameters`) sous le nouveau nom `AdaptyUICreateFlowViewParameters`, plus deux nouveaux — `Locale` et `EnableSafeAreaPaddings` :
```diff showLineNumbers
- AdaptyUI.CreatePaywallView(paywall, parameters, (view, error) => {
+ AdaptyUI.CreateFlowView(flow, parameters, (view, error) => {
if (error != null) {
// handle the error
return;
}
view.Present((error) => { /* handle the error */ });
});
```
`CreateFlowView` retourne une erreur si le flow n'a pas de vue configurée — cela remplace la vérification `HasViewConfiguration` de la v3 :
```diff showLineNumbers
- if (paywall.HasViewConfiguration) {
- AdaptyUI.CreatePaywallView(paywall, null, (view, error) => { /* ... */ });
- }
+ AdaptyUI.CreateFlowView(flow, (view, error) => {
+ if (error != null) {
+ // the flow has no view configured, or view creation failed
+ return;
+ }
+ view.Present((error) => { /* handle the error */ });
+ });
```
:::note
Une vue de flow est à usage unique : après avoir appelé `Dismiss`, la vue est détruite. Appelez donc à nouveau `CreateFlowView` pour afficher le flow une nouvelle fois.
:::
### Marges de zone sécurisée Android \{#android-safe-area-paddings\}
`AdaptyUICreateFlowViewParameters` ajoute `EnableSafeAreaPaddings`, qui contrôle les marges de zone sécurisée Android à l'exécution. Il est ignoré sur iOS et vaut `true` par défaut :
```csharp showLineNumbers
var parameters = new AdaptyUICreateFlowViewParameters()
.SetEnableSafeAreaPaddings(false);
```
## Gestion des événements \{#handling-events\}
Les interfaces de listener suivent désormais la convention C# avec préfixe `I` — il n'existe plus d'alias hérités : renommez `AdaptyEventListener` en `IAdaptyEventListener` et `AdaptyOnboardingsEventsListener` en `IAdaptyOnboardingsEventsListener` partout où vous les implémentez.
L'écouteur d'événements de flow est renommé de `AdaptyPaywallsEventsListener` en `IAdaptyFlowsEventsListener`, sa méthode d'enregistrement de `SetPaywallsEventsListener` en `SetFlowsEventsListener`, et ses callbacks remplacent le préfixe `PaywallView` par `FlowView`. Le corps des handlers existants ne nécessite aucune modification — il suffit de renommer l'interface et les méthodes :
```diff showLineNumbers
- public class MyListener : MonoBehaviour, AdaptyPaywallsEventsListener {
- public void PaywallViewDidFinishPurchase(
- AdaptyUIPaywallView view,
+ public class MyListener : MonoBehaviour, IAdaptyFlowsEventsListener {
+ public void FlowViewDidFinishPurchase(
+ AdaptyUIFlowView view,
AdaptyPaywallProduct product,
AdaptyPurchaseResult purchasedResult
) {
// custom logic after purchase
}
// ...
}
- Adapty.SetPaywallsEventsListener(myListener);
+ Adapty.SetFlowsEventsListener(myListener);
```
Un callback est renommé : `PaywallViewDidFailRendering` devient `FlowViewDidReceiveError`. Il se déclenche pour les mêmes erreurs de rendu qu'auparavant, plus d'autres erreurs d'exécution non liées aux achats :
```diff showLineNumbers
- public void PaywallViewDidFailRendering(AdaptyUIPaywallView view, AdaptyError error) { }
+ public void FlowViewDidReceiveError(AdaptyUIFlowView view, AdaptyError error) { }
```
Consultez [Gérer les événements de flow et de paywall](unity-handling-events) pour la liste complète des callbacks.
### Nouvelles API \{#new-apis\}
- `Adapty.SetObserverModeResolver(...)` avec un `IAdaptyUIObserverModeResolver` — gérez les achats et restaurations initiés depuis les flows lorsque le SDK fonctionne en [mode Observer](implement-observer-mode-unity). Auparavant, cette fonctionnalité n'était disponible que dans les SDK natifs iOS et Android. Voir [Présenter des flows en mode Observer](unity-present-flows-in-observer-mode).
- `Adapty.SetSystemRequestsHandler(...)` avec un `IAdaptyUISystemRequestsHandler` — réservé aux requêtes système provenant d'un flow : invites de permissions OS (`FlowViewDidAskPermission`) et demandes d'évaluation de l'app (`FlowViewDidRequestAppReview`). Les flows ne déclenchent pas encore ces requêtes, vous n'avez donc pas besoin d'enregistrer un handler.
- `AdaptyUICreateFlowViewParameters.Locale` (à définir avec `SetLocale`) — affichez un flow ou un paywall avec une [localisation Builder](add-paywall-locale-in-adapty-paywall-builder) spécifique plutôt que la localisation par défaut du flow. Un flow est localisé au moment de la création de sa vue, c'est donc le seul endroit pour choisir sa localisation ; la vue créée indique la localisation avec laquelle elle a été construite dans `view.Locale`. Voir [Utiliser les localisations et les codes de langue](unity-localizations-and-locale-codes).
- Le nouveau callback `FlowViewDidReceiveAnalyticEvent` sur `IAdaptyFlowsEventsListener` est réservé aux événements analytiques personnalisés provenant d'un flow. Les flows n'émettent pas encore ces événements vers votre code, implémentez-le donc avec un corps vide.
- `AdaptyUI.OpenUrl(url, openIn, ...)` et `AdaptyUI.RequestAppReview(...)` — le traitement natif derrière les actions `open_url` et les demandes d'évaluation de l'app. Appelez `OpenUrl` depuis `FlowViewDidPerformAction` pour conserver le comportement URL par défaut ; `RequestAppReview` sert d'appui à l'invite d'évaluation par défaut, que les flows ne déclenchent pas encore.
## Changements de comportement par défaut \{#default-behavior-changes\}
Ces changements ne provoquent pas d'erreurs de compilation, testez-les donc à l'exécution :
- **Finalisation d'achat** : en v3, la vue se fermait automatiquement après un achat réussi. En v4, **un flow reste ouvert après un achat ou une erreur jusqu'à ce que vous le fermiez** — le SDK n'applique aucun comportement par défaut. Appelez vous-même `view.Dismiss(...)` dans `FlowViewDidFinishPurchase` dès que l'utilisateur obtient l'accès.
- **Bouton retour Android** : le bouton retour système (ou le geste de retour) est transmis à `FlowViewDidPerformAction` sous la forme d'une action `SystemBack` et ne ferme plus le flow par lui-même — alignement avec iOS, où un flow ne peut pas être fermé par un geste système. Donnez aux utilisateurs un moyen de sortir explicite (un bouton **Close** ou une action `on_device_back`), ou fermez la vue vous-même lors du traitement de l'action.
- **Les vues sont à usage unique** : après `Dismiss`, la vue est détruite. Appelez à nouveau `CreateFlowView` pour présenter le flow une nouvelle fois.
- **Transactions en mode Observer** : `ReportTransaction` ne remonte plus d'erreur de décodage en cas de succès — en v3, la réponse de succès était mal analysée, si bien qu'un rapport réussi se terminait toujours avec une erreur.
## Dépréciation de l'API onboarding \{#onboarding-api-deprecation\}
L'ancienne API onboarding est dépréciée dans la v4.0 au profit du [Flow Builder](adapty-flow-builder). Elle fonctionne toujours, mais sera supprimée dans une prochaine version. Prévoyez donc la migration de vos onboardings vers le Flow Builder.
Symboles dépréciés : `GetOnboarding`, `GetOnboardingForDefaultAudience`, `AdaptyUI.CreateOnboardingView`, `AdaptyUI.PresentOnboardingView`, `AdaptyUI.DismissOnboardingView` et `Adapty.SetOnboardingsEventsListener`.
---
# File: migration-to-unity-sdk-314
---
---
title: "Migrer le SDK Adapty Unity vers la v3.14"
description: "Migrez vers le SDK Adapty Unity v3.14 pour de meilleures performances et de nouvelles fonctionnalités de monétisation."
---
Le SDK Adapty 3.14.0 est une version majeure qui apporte des améliorations nécessitant toutefois quelques étapes de migration de votre part :
1. Écouteur d'événements distinct pour les événements de paywall.
2. Renommer `AdaptyUI.CreateView` en `AdaptyUI.CreatePaywallView` et les méthodes associées.
3. Mettre à jour la méthode `MakePurchase` pour utiliser `AdaptyPurchaseParameters` à la place des paramètres individuels.
4. Remplacer `SetFallbackPaywalls` par la méthode `SetFallback`.
5. Mettre à jour l'accès aux propriétés du paywall pour utiliser `AdaptyPlacement`.
6. Mettre à jour l'accès à la configuration distante pour utiliser l'objet `AdaptyRemoteConfig`.
7. Remplacer `VendorProductIds` par `ProductIdentifiers` dans le modèle `AdaptyPaywall`.
8. Mettre à jour la politique de récupération de `GetPaywall` pour utiliser `AdaptyFetchPolicy`.
## Écouteur d'événements distinct pour les événements de paywall \{#separate-event-listener-for-paywall-events\}
Si vous affichez des paywalls conçus avec le [Paywall Builder](adapty-paywall-builder), les événements de vue de paywall utilisent désormais l'interface dédiée `AdaptyPaywallsEventsListener` et la méthode `SetPaywallsEventsListener`. L'interface principale `AdaptyEventListener` reste utilisée pour les mises à jour de profil et les détails d'installation.
```diff showLineNumbers
using UnityEngine;
using AdaptySDK;
public class AdaptyListener : MonoBehaviour,
- AdaptyEventListener {
+ AdaptyEventListener,
+ AdaptyPaywallsEventsListener {
void Start() {
Adapty.SetEventListener(this);
+ Adapty.SetPaywallsEventsListener(this);
}
// AdaptyEventListener methods
public void OnLoadLatestProfile(AdaptyProfile profile) { }
public void OnInstallationDetailsSuccess(AdaptyInstallationDetails details) { }
public void OnInstallationDetailsFail(AdaptyError error) { }
+ // AdaptyPaywallsEventsListener methods
+ // Implement paywall event handlers here
}
```
[En savoir plus sur la gestion des événements de paywall](unity-handling-events).
## Renommer les méthodes de création et de présentation de vue \{#rename-view-creation-and-presentation-methods\}
Les méthodes de création et de présentation de vue ont été renommées :
```diff showLineNumbers
using AdaptySDK;
- AdaptyUI.CreateView(paywall, parameters, (view, error) => {
+ AdaptyUI.CreatePaywallView(paywall, parameters, (view, error) => {
if (error != null) {
// handle the error
return;
}
- AdaptyUI.PresentView(view, (error) => {
+ AdaptyUI.PresentPaywallView(view, (error) => {
// handle the error
});
});
}
```
De même, la méthode de fermeture a été renommée :
```diff showLineNumbers
- AdaptyUI.DismissView(view, (error) => {
+ AdaptyUI.DismissPaywallView(view, (error) => {
// handle the error
});
```
## Mettre à jour la méthode MakePurchase \{#update-makepurchase-method\}
La méthode `MakePurchase` utilise désormais `AdaptyPurchaseParameters` à la place des arguments individuels `subscriptionUpdateParams` et `isOfferPersonalized`. Cela offre une meilleure sécurité de type et permet d'étendre plus facilement les paramètres d'achat à l'avenir.
```diff showLineNumbers
using AdaptySDK;
void MakePurchase(
AdaptyPaywallProduct product,
AdaptySubscriptionUpdateParameters subscriptionUpdate,
bool? isOfferPersonalized
) {
- Adapty.MakePurchase(product, subscriptionUpdate, isOfferPersonalized, (result, error) => {
+ var parameters = new AdaptyPurchaseParametersBuilder()
+ .SetSubscriptionUpdateParams(subscriptionUpdate)
+ .SetIsOfferPersonalized(isOfferPersonalized)
+ .Build();
+
+ Adapty.MakePurchase(product, parameters, (result, error) => {
switch (result.Type) {
case AdaptyPurchaseResultType.Pending:
// handle pending purchase
break;
case AdaptyPurchaseResultType.UserCancelled:
// handle purchase cancellation
break;
case AdaptyPurchaseResultType.Success:
var profile = result.Profile;
// handle successful purchase
break;
default:
break;
}
});
}
```
Si aucun paramètre supplémentaire n'est nécessaire, vous pouvez simplement utiliser :
```csharp showLineNumbers
using AdaptySDK;
void MakePurchase(AdaptyPaywallProduct product) {
Adapty.MakePurchase(product, (result, error) => {
// handle purchase result
});
}
```
## Mettre à jour la méthode de fallback \{#update-fallback-method\}
:::important
Lors de la mise à niveau vers le SDK Unity 3.14, vous devrez télécharger les nouveaux fichiers de fallback depuis l'Adapty Dashboard et remplacer ceux existants dans votre projet.
:::
La méthode de définition des fallbacks a été mise à jour. La méthode `SetFallbackPaywalls` a été renommée en `SetFallback` :
```diff showLineNumbers
using AdaptySDK;
void SetFallBackPaywalls() {
#if UNITY_IOS
var assetId = "adapty_fallback_ios.json";
#elif UNITY_ANDROID
var assetId = "adapty_fallback_android.json";
#else
var assetId = "";
#endif
- Adapty.SetFallbackPaywalls(assetId, (error) => {
+ Adapty.SetFallback(assetId, (error) => {
// handle the error
});
}
```
Consultez l'exemple de code final sur la page [Utiliser des paywalls de secours dans Unity](unity-use-fallback-paywalls).
## Mettre à jour l'accès aux propriétés du paywall \{#update-paywall-property-access\}
Les propriétés suivantes ont été déplacées de `AdaptyPaywall` vers `AdaptyPlacement` :
```diff showLineNumbers
using AdaptySDK;
void ProcessPaywall(AdaptyPaywall paywall) {
- var abTestName = paywall.ABTestName;
- var audienceName = paywall.AudienceName;
- var revision = paywall.Revision;
- var placementId = paywall.PlacementId;
+ var abTestName = paywall.Placement.ABTestName;
+ var audienceName = paywall.Placement.AudienceName;
+ var revision = paywall.Placement.Revision;
+ var placementId = paywall.Placement.Id;
}
```
## Mettre à jour l'accès à la configuration distante \{#update-remote-config-access\}
Les propriétés du Remote Config ont été restructurées dans un objet `AdaptyRemoteConfig` pour une meilleure organisation :
```diff showLineNumbers
using AdaptySDK;
void ProcessRemoteConfig(AdaptyPaywall paywall) {
- var remoteConfigString = paywall.RemoteConfigString;
- var locale = paywall.Locale;
- var remoteConfigDict = paywall.RemoteConfig;
+ var remoteConfigString = paywall.RemoteConfig.Data;
+ var locale = paywall.RemoteConfig.Locale;
+ var remoteConfigDict = paywall.RemoteConfig.Dictionary;
}
```
## Mettre à jour l'utilisation du modèle AdaptyPaywall \{#update-adapty-paywall-model-usage\}
La propriété `VendorProductIds` est désormais dépréciée au profit de `ProductIdentifiers`. La nouvelle propriété retourne des objets `AdaptyProductIdentifier` au lieu de simples chaînes de caractères, offrant une information produit mieux structurée.
```diff showLineNumbers
using AdaptySDK;
void ProcessPaywallProducts(AdaptyPaywall paywall) {
- var productIds = paywall.VendorProductIds;
- foreach (var vendorId in productIds) {
- // use vendorId
- }
+ var productIdentifiers = paywall.ProductIdentifiers;
+ foreach (var productId in productIdentifiers) {
+ var vendorId = productId.VendorProductId;
+ // use vendorId
+ }
}
```
L'objet `AdaptyProductIdentifier` donne accès à l'identifiant de produit du vendeur via la propriété `VendorProductId`, conservant la même fonctionnalité tout en offrant une meilleure structure pour les améliorations futures.
## Mettre à jour la politique de récupération de GetPaywall \{#update-getpaywall-fetch-policy\}
Le type du paramètre `fetchPolicy` dans la méthode `GetPaywall` a été modifié de `AdaptyPaywallFetchPolicy` en `AdaptyPlacementFetchPolicy`. Ce changement unifie l'utilisation de la politique de récupération dans l'ensemble du SDK.
```diff showLineNumbers
using AdaptySDK;
void GetPaywall(string placementId) {
- Adapty.GetPaywall(placementId, AdaptyPaywallFetchPolicy.ReloadRevalidatingCacheData, null, (paywall, error) => {
+ Adapty.GetPaywall(placementId, AdaptyPlacementFetchPolicy.ReloadRevalidatingCacheData, null, (paywall, error) => {
// handle the result
});
}
```
---
# File: migration-to-unity-sdk-34
---
---
title: "Migrer le SDK Adapty Unity vers v3.4"
description: "Migrez vers le SDK Adapty Unity v3.4 pour de meilleures performances et de nouvelles fonctionnalités de monétisation."
---
Le SDK Adapty 3.4.0 est une version majeure qui introduit des améliorations nécessitant des étapes de migration de votre côté.
## Mettre à jour les fichiers de paywall de secours \{#update-fallback-paywall-files\}
Mettez à jour vos fichiers de paywall de secours pour assurer la compatibilité avec la nouvelle version du SDK :
1. [Téléchargez les fichiers de paywall de secours mis à jour](fallback-paywalls) depuis l'Adapty Dashboard.
2. [Remplacez les paywalls de secours existants dans votre application mobile](unity-use-fallback-paywalls) par les nouveaux fichiers.
## Mettre à jour l'implémentation du mode Observateur \{#update-implementation-of-observer-mode\}
Si vous utilisez le mode Observateur, assurez-vous de mettre à jour son implémentation.
Auparavant, différentes méthodes étaient utilisées pour signaler les transactions à Adapty. Dans la nouvelle version, la méthode `reportTransaction` doit être utilisée de manière cohérente sur Android et iOS. Cette méthode signale explicitement chaque transaction à Adapty, garantissant qu'elle est reconnue. Si un paywall a été utilisé, transmettez l'ID de variation pour associer la transaction à celui-ci.
:::warning
**Ne sautez pas le signalement des transactions !**
Si vous n'appelez pas `reportTransaction`, Adapty ne reconnaîtra pas la transaction, elle n'apparaîtra pas dans les analyses et ne sera pas envoyée aux intégrations.
:::
```diff showLineNumbers
- #if UNITY_ANDROID && !UNITY_EDITOR
- Adapty.RestorePurchases((profile, error) => {
- // handle the error
- });
- #endif
Adapty.ReportTransaction(
"YOUR_TRANSACTION_ID",
"PAYWALL_VARIATION_ID", // optional
(error) => {
// handle the error
});
```
---
# File: migration-to-unity330
---
---
title: "Migrer le SDK Adapty Unity vers la v3.3"
description: "Migrez vers le SDK Adapty Unity v3.3 pour de meilleures performances et de nouvelles fonctionnalités de monétisation."
---
Le SDK Adapty 3.3.0 est une version majeure qui apporte des améliorations pouvant nécessiter quelques étapes de migration de votre côté.
1. Mettre à jour vers le SDK Adapty v3.3.x.
2. Plusieurs classes, propriétés et méthodes ont été renommées dans les modules Adapty et AdaptyUI du SDK Adapty.
3. Désormais, la méthode `SetLogLevel` accepte un callback en argument.
4. Désormais, la méthode `PresentCodeRedemptionSheet` accepte un callback en argument.
5. Modifier la façon dont la vue paywall est créée
6. Supprimer la méthode `GetProductsIntroductoryOfferEligibility`.
7. Enregistrer les paywalls de secours dans des fichiers séparés (un par plateforme) dans `Assets/StreamingAssets/` et transmettre les noms de fichiers à la méthode `SetFallbackPaywalls`.
8. Mettre à jour le processus d'achat
9. Mettre à jour la gestion des événements du Paywall Builder.
10. Mettre à jour la gestion des erreurs de paywall du Paywall Builder.
11. Mettre à jour les configurations d'intégration pour Adjust, Amplitude, AppMetrica, Appsflyer, Branch, Firebase et Google Analytics, Mixpanel, OneSignal, Pushwoosh.
13. Mettre à jour l'implémentation du mode Observer.
14. Mettre à jour l'initialisation du plugin Unity avec un appel explicite à `Activate`.
## Mettre à jour le SDK Adapty Unity vers la version 3.3.x \{#upgrade-adapty-unity-sdk-to-33x\}
Jusqu'à cette version, le SDK Adapty était le SDK principal et obligatoire pour le bon fonctionnement d'Adapty dans votre application, tandis que le SDK AdaptyUI était optionnel et ne devenait nécessaire que si vous utilisiez le Paywall Builder d'Adapty.
À partir de la version 3.3.0, le SDK AdaptyUI est déprécié et AdaptyUI est fusionné dans le SDK Adapty en tant que module. Suite à ces changements, vous devez supprimer AdaptyUISDK et réinstaller AdaptySDK.
1. Supprimez les dépendances de packages **AdaptySDK** et **AdaptyUISDK** de votre projet.
2. Supprimez les dossiers **AdaptySDK** et **AdaptyUISDK**.
3. Importez à nouveau le package AdaptySDK comme décrit sur la page [Installation et configuration du SDK Adapty pour Unity](sdk-installation-unity).
## Renommages \{#renamings\}
1. Renommages dans le module Adapty :
| Ancienne version | Nouvelle version |
| ------------------------- | ------------------------ |
| Adapty.sdkVersion | Adapty.SDKVersion |
| Adapty.LogLevel | AdaptyLogLevel |
| Adapty.Paywall | AdaptyPaywall |
| Adapty.PaywallFetchPolicy | AdaptyPaywallFetchPolicy |
| PaywallProduct | AdaptyPaywallProduct |
| Adapty.Profile | AdaptyProfile |
| Adapty.ProfileParameters | AdaptyProfileParameters |
| ProfileGender | AdaptyProfileGender |
| Error | AdaptyError |
2. Renommages dans le module AdaptyUI :
| Ancienne version | Nouvelle version |
| ------------------ | ------------------ |
| CreatePaywallView | CreateView |
| PresentPaywallView | PresentView |
| DismissPaywallView | DismissView |
| AdaptyUI.View | AdaptyUIView |
| AdaptyUI.Action | AdaptyUIUserAction |
## Modifier la méthode SetLogLevel \{#change-the-setloglevel-method\}
Désormais, la méthode `SetLogLevel` accepte un callback en argument.
```diff showLineNumbers
- Adapty.SetLogLevel(Adapty.LogLevel.Verbose);
+ Adapty.SetLogLevel(Adapty.LogLevel.Verbose, null); // or you can pass the callback to handle the possible error
```
## Modifier la méthode PresentCodeRedemptionSheet \{#change-the-presentcoderedemptionsheet-method\}
Désormais, la méthode `PresentCodeRedemptionSheet` accepte un callback en argument.
```diff showLineNumbers
- Adapty.PresentCodeRedemptionSheet();
+ Adapty.PresentCodeRedemptionSheet(null); // or you can pass the callback to handle the possible error
```
## Modifier la façon dont la vue paywall est créée \{#change-how-the-paywall-view-is-created\}
Pour un exemple de code complet, consultez [Récupérer la configuration de vue d'un paywall conçu avec le Paywall Builder](unity-get-pb-paywalls#fetch-the-view-configuration-of-paywall-designed-using-paywall-builder).
```diff showLineNumbers
+ var parameters = new AdaptyUICreateViewParameters()
+ .SetPreloadProducts(true);
- AdaptyUI.CreatePaywallView(
+ AdaptyUI.CreateView(
paywall,
- preloadProducts: true,
+ parameters,
(view, error) => {
// use the view
});
```
## Supprimer la méthode GetProductsIntroductoryOfferEligibility \{#remove-the-getproductsintroductoryoffereligibility-method\}
Avant le SDK Adapty iOS 3.3.0, l'objet produit incluait toujours les offres, que l'utilisateur y soit éligible ou non. Vous deviez vérifier manuellement l'éligibilité avant d'utiliser l'offre.
Désormais, l'objet produit n'inclut une offre que si l'utilisateur est éligible. Vous n'avez donc plus besoin de vérifier l'éligibilité — si une offre est présente, l'utilisateur y est éligible.
## Mettre à jour la méthode de fourniture des paywalls de secours \{#update-method-for-providing-fallback-paywalls\}
Jusqu'à cette version, les paywalls de secours étaient transmis sous forme de JSON sérialisé. À partir de la v3.3.0, le mécanisme a changé :
1. Enregistrez les paywalls de secours dans des fichiers dans `/Assets/StreamingAssets/`, 1 fichier pour Android et un autre pour iOS.
2. Transmettez les noms de fichiers à la méthode `SetFallbackPaywalls`.
Votre code changera de la façon suivante :
```diff showLineNumbers
using AdaptySDK;
void SetFallBackPaywalls() {
+ #if UNITY_IOS
+ var assetId = "adapty_fallback_ios.json";
+ #elif UNITY_ANDROID
+ var assetId = "adapty_fallback_android.json";
+ #else
+ var assetId = "";
+ #endif
- Adapty.SetFallbackPaywalls("FALLBACK_PAYWALLS_JSON_STRING", (error) => {
+ Adapty.SetFallbackPaywalls(assetId, (error) => {
// handle the error
});
}
```
Consultez l'exemple de code final sur la page [Utiliser les paywalls de secours dans Unity](unity-use-fallback-paywalls).
## Mettre à jour le processus d'achat \{#update-making-purchase\}
Auparavant, les achats annulés et en attente étaient considérés comme des erreurs et retournaient respectivement les codes `PaymentCancelled` et `PendingPurchase`.
Une nouvelle classe `AdaptyPurchaseResultType` est désormais utilisée pour traiter les achats annulés, réussis et en attente. Mettez à jour le code d'achat de la façon suivante :
```diff showLineNumbers
using AdaptySDK;
void MakePurchase(AdaptyPaywallProduct product) {
- Adapty.MakePurchase(product, (profile, error) => {
- // handle successfull purchase
+ Adapty.MakePurchase(product, (result, error) => {
+ switch (result.Type) {
+ case AdaptyPurchaseResultType.Pending:
+ // handle pending purchase
+ break;
+ case AdaptyPurchaseResultType.UserCancelled:
+ // handle purchase cancellation
+ break;
+ case AdaptyPurchaseResultType.Success:
+ var profile = result.Profile;
+ // handle successful purchase
+ break;
+ default:
+ break;
}
});
}
```
Consultez l'exemple de code final sur la page [Effectuer des achats dans une application mobile](unity-making-purchases).
## Mettre à jour la gestion des événements du Paywall Builder \{#update-handling-of-paywall-builder-events\}
Les achats annulés et en attente ne sont plus considérés comme des erreurs ; tous ces cas sont traités via la méthode `PaywallViewDidFinishPurchase`.
1. Supprimez le traitement de l'événement d'achat annulé.
2. Mettez à jour la gestion de l'événement d'achat réussi de la façon suivante :
```diff showLineNumbers
- public void OnFinishPurchase(
- AdaptyUI.View view,
- Adapty.PaywallProduct product,
- Adapty.Profile profile
- ) { }
+ public void PaywallViewDidFinishPurchase(
+ AdaptyUIView view,
+ AdaptyPaywallProduct product,
+ AdaptyPurchaseResult purchasedResult
+ ) { }
```
3. Mettez à jour la gestion des actions :
```diff showLineNumbers
- public void OnPerformAction(
- AdaptyUI.View view,
- AdaptyUI.Action action
- ) {
+ public void PaywallViewDidPerformAction(
+ AdaptyUIView view,
+ AdaptyUIUserAction action
+ ) {
switch (action.Type) {
- case AdaptyUI.ActionType.Close:
+ case AdaptyUIUserActionType.Close:
view.Dismiss(null);
break;
- case AdaptyUI.ActionType.OpenUrl:
+ case AdaptyUIUserActionType.OpenUrl:
var urlString = action.Value;
if (urlString != null {
Application.OpenURL(urlString);
}
default:
// handle other events
break;
}
}
```
4. Mettez à jour la gestion du démarrage d'un achat :
```diff showLineNumbers
- public void OnSelectProduct(
- AdaptyUI.View view,
- Adapty.PaywallProduct product
- ) { }
+ public void PaywallViewDidSelectProduct(
+ AdaptyUIView view,
+ string productId
+ ) { }
```
5. Mettez à jour la gestion d'un achat échoué :
```diff showLineNumbers
- public void OnFailPurchase(
- AdaptyUI.View view,
- Adapty.PaywallProduct product,
- Adapty.Error error
- ) { }
+ public void PaywallViewDidFailPurchase(
+ AdaptyUIView view,
+ AdaptyPaywallProduct product,
+ AdaptyError error
+ ) { }
```
6. Mettez à jour la gestion d'une restauration réussie :
```diff showLineNumbers
- public void OnFailRestore(
- AdaptyUI.View view,
- Adapty.Error error
- ) { }
+ public void PaywallViewDidFailRestore(
+ AdaptyUIView view,
+ AdaptyError error
+ ) { }
```
Consultez l'exemple de code final sur la page [Gérer les événements du paywall](unity-handling-events).
## Mettre à jour la gestion des erreurs de paywall du Paywall Builder \{#update-handling-of-paywall-builder-paywall-errors\}
La gestion des erreurs a également changé. Mettez à jour votre code selon les indications ci-dessous.
1. Mettez à jour la gestion des erreurs de chargement des produits :
```diff showLineNumbers
- public void OnFailLoadingProducts(
- AdaptyUI.View view,
- Adapty.Error error
- ) { }
+ public void PaywallViewDidFailLoadingProducts(
+ AdaptyUIView view,
+ AdaptyError error
+ ) { }
```
2. Mettez à jour la gestion des erreurs de rendu :
```diff showLineNumbers
- public void OnFailRendering(
- AdaptyUI.View view,
- Adapty.Error error
- ) { }
+ public void PaywallViewDidFailRendering(
+ AdaptyUIView view,
+ AdaptyError error
+ ) { }
```
## Mettre à jour la configuration du SDK d'intégration tierce \{#update-third-party-integration-sdk-configuration\}
À partir du SDK Adapty Unity 3.3.0, nous avons mis à jour l'API publique de la méthode `updateAttribution`. Auparavant, elle acceptait un dictionnaire `[AnyHashable: Any]`, vous permettant de passer directement des objets d'attribution de divers services. Désormais, elle requiert un `[String: any Sendable]`, vous devrez donc convertir les objets d'attribution avant de les transmettre.
Pour garantir le bon fonctionnement des intégrations avec le SDK Adapty Unity 3.3.0 et versions ultérieures, mettez à jour vos configurations SDK pour les intégrations suivantes comme décrit dans les sections ci-dessous.
### Adjust
Mettez à jour le code de votre application mobile comme indiqué ci-dessous. Pour un exemple de code complet, consultez la [configuration du SDK pour l'intégration Adjust](adjust#connect-your-app-to-adjust).
```diff showLineNumbers
- using static AdaptySDK.Adapty;
using AdaptySDK;
Adjust.GetAdid((adid) => {
- Adjust.GetAttribution((attribution) => {
- Dictionary