> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Prise en main de PlayFab Economy (hérité), Unity IAP et Android
> Connectez Unity IAP et l'API Android Billing aux objets de catalogue de PlayFab Economy (hérité) pour obtenir un flux d'achat intégré fonctionnel sur les appareils Android.
# Prise en main de PlayFab (Economy hérité), Unity IAP et Android
Les API Economy v1 sont en mode maintenance et ne recevront plus de nouvelles fonctionnalités, uniquement des correctifs de bogues. **Les API v1 seront maintenues dans un avenir prévisible.** Consultez la [vue d'ensemble d'Economy v2](/fr/services/playfab/economy-monetization/economy-v2/overview) pour en savoir plus sur la prochaine version de PlayFab Economy !
Ce tutoriel vous montre comment configurer les achats intégrés (IAP) à l'aide de PlayFab, du service Unity + IAP et de l'API Android Billing.
## Avant de commencer
La configuration des achats intégrés peut être fastidieuse, surtout si vous ne savez pas exactement comment les différents services sont censés s'intégrer et coopérer.
L'image suivante illustre comment l'API Android Billing et PlayFab fonctionnent ensemble pour offrir une expérience d'achat intégré solide à votre client.
Commencez par configurer vos **ID de produit** et vos **prix** via PlayMarket. Au départ, tous les produits sont *anonymes* : ce sont des entités numériques que votre joueur peut acheter, mais elles n'ont aucune signification pour les joueurs PlayFab.
Pour rendre ces entités utiles, nous devons les refléter dans les catalogues d'objets PlayFab. Cela transforme les entités anonymes en lots, en conteneurs et en objets individuels.
Chacun possède sa propre identité, avec :
* **Titres**
* **Descriptions**
* **Balises**
* **Types**
* **Images**
* **Comportements**
Tous ces éléments sont liés aux produits du marché par le partage d'ID.
La meilleure façon d'accéder aux objets en argent réel disponibles à l'achat consiste à utiliser [GetCatalogItems](xref:titleid.playfabapi.com.client.title-widedatamanagement.getcatalogitems) et [GetStoreItems](xref:titleid.playfabapi.com.client.title-widedatamanagement.getstoreitems). Ce sont les mêmes méthodes d'API que celles utilisées par les boutiques en monnaie gratuite ; le processus devrait donc vous être familier.
L'ID de l'objet constitue le lien entre PlayFab et tout système d'achat intégré externe. Nous transmettons donc l'ID de l'objet au service IAP.
À ce stade, le processus d'achat commence. Le joueur interagit avec l'interface IAP et, si l'achat réussit, vous obtenez un reçu.
PlayFab peut alors valider le reçu et enregistrer l'achat, en accordant au joueur PlayFab les objets qu'il vient d'acheter.
Voici une idée générale du fonctionnement de l'intégration des achats intégrés, et l'exemple suivant en montre la majeure partie en action.
## Configuration d'une application cliente
Cette section vous montre comment configurer une application très simple pour tester les achats intégrés à l'aide de PlayFab, d'UnityIAP et de l'API Android Billing.
Prérequis :
* Un projet Unity.
* Le SDK PlayFab importé et configuré pour fonctionner avec votre titre.
Notre première étape consiste à configurer UnityIAP :
1. Accédez à **Services**.
2. Assurez-vous que l'onglet **Services** est sélectionné.
3. Sélectionnez votre profil ou organisation **Unity Services**.
4. Sélectionnez le bouton **Create**.
1. Accédez ensuite au service **In-App Purchasing (IAP)**.
1. Veillez à activer le **Service** en activant le bouton bascule **Simplify cross-platform IAP**.
2. Sélectionnez ensuite le bouton **Continue**.
Une page contenant une liste de plug-ins s'affiche.
1. Sélectionnez le bouton **Import**.
Poursuivez la procédure d'installation et d'importation d'Unity jusqu'à ce que tous les plug-ins soient importés.
1. Vérifiez que les plug-ins sont en place.
2. Créez ensuite un nouveau script, appelé **AndroidIAPExample.cs**.
`AndroidIAPExample.cs` contiendra le code présenté ci-dessous (veuillez vous reporter aux commentaires du code pour plus d'explications).
```csharp theme={null}
using PlayFab;
using PlayFab.ClientModels;
using PlayFab.Json;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Purchasing;
public class AndroidIAPExample : MonoBehaviour, IStoreListener {
// Items list, configurable via inspector
private List Catalog;
// The Unity Purchasing system
private static IStoreController m_StoreController;
// Bootstrap the whole thing
public void Start() {
// Make PlayFab log in
Login();
}
public void OnGUI() {
// This line just scales the UI up for high-res devices
// Comment it out if you find the UI too large.
GUI.matrix = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(3, 3, 3));
// if we are not initialized, only draw a message
if (!IsInitialized) {
GUILayout.Label("Initializing IAP and logging in...");
return;
}
// Draw menu to purchase items
foreach (var item in Catalog) {
if (GUILayout.Button("Buy " + item.DisplayName)) {
// On button click buy a product
BuyProductID(item.ItemId);
}
}
}
// This is invoked manually on Start to initiate login ops
private void Login() {
// Login with Android ID
PlayFabClientAPI.LoginWithAndroidDeviceID(new LoginWithAndroidDeviceIDRequest() {
CreateAccount = true,
AndroidDeviceId = SystemInfo.deviceUniqueIdentifier
}, result => {
Debug.Log("Logged in");
// Refresh available items
RefreshIAPItems();
}, error => Debug.LogError(error.GenerateErrorReport()));
}
private void RefreshIAPItems() {
PlayFabClientAPI.GetCatalogItems(new GetCatalogItemsRequest(), result => {
Catalog = result.Catalog;
// Make UnityIAP initialize
InitializePurchasing();
}, error => Debug.LogError(error.GenerateErrorReport()));
}
// This is invoked manually on Start to initialize UnityIAP
public void InitializePurchasing() {
// If IAP is already initialized, return gently
if (IsInitialized) return;
// Create a builder for IAP service
var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance(AppStore.GooglePlay));
// Register each item from the catalog
foreach (var item in Catalog) {
builder.AddProduct(item.ItemId, ProductType.Consumable);
}
// Trigger IAP service initialization
UnityPurchasing.Initialize(this, builder);
}
// We are initialized when StoreController and Extensions are set and we are logged in
public bool IsInitialized {
get {
return m_StoreController != null && Catalog != null;
}
}
// This is automatically invoked automatically when IAP service is initialized
public void OnInitialized(IStoreController controller, IExtensionProvider extensions) {
m_StoreController = controller;
}
// This is automatically invoked automatically when IAP service failed to initialized
public void OnInitializeFailed(InitializationFailureReason error) {
Debug.Log("OnInitializeFailed InitializationFailureReason:" + error);
}
// This is automatically invoked automatically when purchase failed
public void OnPurchaseFailed(Product product, PurchaseFailureReason failureReason) {
Debug.Log(string.Format("OnPurchaseFailed: FAIL. Product: '{0}', PurchaseFailureReason: {1}", product.definition.storeSpecificId, failureReason));
}
// This is invoked automatically when successful purchase is ready to be processed
public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs e) {
// NOTE: this code does not account for purchases that were pending and are
// delivered on application start.
// Production code should account for such case:
// More: https://docs.unity3d.com/ScriptReference/Purchasing.PurchaseProcessingResult.Pending.html
if (!IsInitialized) {
return PurchaseProcessingResult.Complete;
}
// Test edge case where product is unknown
if (e.purchasedProduct == null) {
Debug.LogWarning("Attempted to process purchase with unknown product. Ignoring");
return PurchaseProcessingResult.Complete;
}
// Test edge case where purchase has no receipt
if (string.IsNullOrEmpty(e.purchasedProduct.receipt)) {
Debug.LogWarning("Attempted to process purchase with no receipt: ignoring");
return PurchaseProcessingResult.Complete;
}
Debug.Log("Processing transaction: " + e.purchasedProduct.transactionID);
// Deserialize receipt
var googleReceipt = GooglePurchase.FromJson(e.purchasedProduct.receipt);
// Invoke receipt validation
// This will not only validate a receipt, but will also grant player corresponding items
// only if receipt is valid.
PlayFabClientAPI.ValidateGooglePlayPurchase(new ValidateGooglePlayPurchaseRequest() {
// Pass in currency code in ISO format
CurrencyCode = e.purchasedProduct.metadata.isoCurrencyCode,
// Convert and set Purchase price
PurchasePrice = (uint)(e.purchasedProduct.metadata.localizedPrice * 100),
// Pass in the receipt
ReceiptJson = googleReceipt.PayloadData.json,
// Pass in the signature
Signature = googleReceipt.PayloadData.signature
}, result => Debug.Log("Validation successful!"),
error => Debug.Log("Validation failed: " + error.GenerateErrorReport())
);
return PurchaseProcessingResult.Complete;
}
// This is invoked manually to initiate purchase
void BuyProductID(string productId) {
// If IAP service has not been initialized, fail hard
if (!IsInitialized) throw new Exception("IAP Service is not initialized!");
// Pass in the product id to initiate purchase
m_StoreController.InitiatePurchase(productId);
}
}
// The following classes are used to deserialize JSON results provided by IAP Service
// Please, note that JSON fields are case-sensitive and should remain fields to support Unity Deserialization via JsonUtilities
public class JsonData {
// JSON Fields, ! Case-sensitive
public string orderId;
public string packageName;
public string productId;
public long purchaseTime;
public int purchaseState;
public string purchaseToken;
}
public class PayloadData {
public JsonData JsonData;
// JSON Fields, ! Case-sensitive
public string signature;
public string json;
public static PayloadData FromJson(string json) {
var payload = JsonUtility.FromJson(json);
payload.JsonData = JsonUtility.FromJson(payload.json);
return payload;
}
}
public class GooglePurchase {
public PayloadData PayloadData;
// JSON Fields, ! Case-sensitive
public string Store;
public string TransactionID;
public string Payload;
public static GooglePurchase FromJson(string json) {
var purchase = JsonUtility.FromJson(json);
purchase.PayloadData = PayloadData.FromJson(purchase.Payload);
return purchase;
}
}
```
1. Créez un nouvel objet **Game** appelé **Code**.
2. Ajoutez-lui le composant `AndroidIAPExample` (processus en 2 étapes).
3. Ajoutez-lui le composant `AndroidIAPExample`.
4. Veillez à **enregistrer** la scène.
Enfin, accédez à **Build Settings**.
1. Vérifiez que votre scène a été ajoutée à la zone **Scenes In Build**.
2. Assurez-vous que la plateforme **Android** a été sélectionnée.
3. Passez à la zone **Player Settings**.
4. Attribuez votre **Package Name**.
Veillez à choisir votre *propre* nom de package pour éviter tout conflit dans **PlayMarket**.
Enfin, générez l'application comme d'habitude et assurez-vous de disposer d'un APK sain et sauf.
Nous n'avons pas encore les moyens de le tester. Nous devons d'abord configurer PlayMarket et PlayFab, comme décrit dans les sections suivantes.
## Configuration d'une application PlayMarket pour les achats intégrés
Cette section décrit les spécificités de l'activation des achats intégrés pour votre application PlayMarket.
La configuration de l'application elle-même dépasse le cadre de ce tutoriel. Nous supposons que vous *disposez* déjà d'une application, et qu'elle est configurée pour publier au moins des versions Alpha.
Remarques utiles :
* Pour arriver à ce stade, vous devrez avoir chargé un APK. Veuillez utiliser l'APK que nous avons créé dans la section précédente.
* Lorsque vous êtes invité à charger l'APK, vous pouvez le charger en tant qu'application Alpha ou Bêta pour activer le bac à sable IAP.
* La configuration de la **classification du contenu** comprend des questions sur la façon dont les achats intégrés sont activés dans l'application.
* PlayMarket ne permet *pas* aux éditeurs d'utiliser ou de tester les achats intégrés ; veuillez donc choisir un *autre* compte Google à des fins de test, et l'ajouter comme testeur pour votre build Alpha/Bêta.
Une fois le build de l'application publié :
1. Sélectionnez **In-app products** dans le menu.
* Si un **Merchant Account** vous est demandé, liez-en un ou créez-en un.
2. Sélectionnez le bouton **Add New Product**.
1. Sur l'écran présenté ci-dessous, sélectionnez **Managed Product**.
2. Attribuez-lui un **Product ID** descriptif.
3. Sélectionnez **Continue**.
PlayMarket vous demande de renseigner un **Title (1)** et une **Description (2)**. Cependant, ils ne nous sont pas très utiles dans notre cas.
Nous récupérerons les données **Data Item** exclusivement à partir du service PlayFab, et nous avons seulement besoin que les ID correspondent.
1. Faites défiler plus bas et sélectionnez le bouton **Add a price**.
1. Saisissez un prix valide (notez que le prix est converti indépendamment pour chaque pays/région).
2. Sélectionnez le bouton **Apply**.
1. Enfin, revenez en haut de votre écran et modifiez l'état de l'objet sur **Active**.
Bien que cela conclue la configuration de l'application, quelques ajustements supplémentaires sont nécessaires. Tout d'abord, enregistrons la **Licensing Key** (elle sera utile pour lier PlayFab à PlayMarket).
1. Accédez à **Services & APIs** dans le menu.
2. Localisez et enregistrez ensuite la version **Base64** de la **Key**.
L'étape suivante consiste à activer les tests d'achats intégrés. Bien que le bac à sable soit automatiquement activé pour les builds Alpha et Bêta, nous devons configurer les comptes autorisés à tester l'application :
1. Accédez à **Home**.
2. Localisez et sélectionnez **Account details** dans le menu de gauche.
3. Localisez la zone **License Testing**.
4. Vérifiez que vos **Test Accounts** figurent dans la liste.
5. Assurez-vous que **License Test Response** est défini sur **RESPOND\_NORMALLY**.
N'oubliez pas d'appliquer les paramètres !
La partie Play Market de l'intégration devrait maintenant être configurée.
## Configuration d'un titre PlayFab
Notre dernière étape consiste à configurer un titre PlayFab pour refléter nos produits et l'intégrer à l'API Google Billing.
1. Sélectionnez **Add-ons**.
2. Sélectionnez ensuite le module complémentaire **Google**.
1. Renseignez votre **Package ID**.
2. Renseignez la **Google App License Key** obtenue dans la section précédente.
3. Validez vos modifications en sélectionnant le bouton **Install Google**.
Notre étape suivante consiste à refléter notre objet Golden Sword dans PlayFab :
1. Sélectionnez **Economy**.
2. Vérifiez que le sous-onglet **Catalogs** est sélectionné.
3. Sélectionnez **New Catalog**.
4. Indiquez un nom de **Catalog version**.
5. Sélectionnez **Save Catalog**.
Si le catalogue ne contient aucun objet, il est *automatiquement* supprimé. C'est pourquoi tout nouveau catalogue est fourni avec un objet préajouté appelé **One**.
Nous pouvons *toujours* créer un *nouvel* objet, mais pour garder les choses propres, modifions l'objet **One** existant.
1. Sélectionnez l'objet pour modifier son **Item ID** afin qu'il corresponde à l'ID dans PlayMarket.
2. Modifiez maintenant le **Display name** et ajoutez une **Description**.
N'oubliez pas que ces données n'ont *rien à voir* avec le **titre** et la **description de l'objet Play Market** : elles sont *totalement* indépendantes.
1. Attribuez un **Price** à votre **Item**.
2. Sélectionnez **Save Item** pour valider vos modifications.
Dans ce tutoriel, les achats intégrés désignent principalement des achats en argent réel. C'est pourquoi nous utilisons **RM**, la devise spéciale Real Money. Le montant PlayFab est défini en cents américains.
1. Observez votre objet dans la liste **Item ID**.
Cela conclut la configuration de votre titre PlayFab.
## Test
À des fins de test, téléchargez l'application à l'aide de la version Alpha/Bêta.
* Veillez à utiliser un compte de test et un véritable appareil Android.
* Une fois l'application démarrée, vous devriez voir que les achats intégrés sont initialisés, ainsi qu'*un bouton* représentant votre objet.
* Sélectionnez ce bouton.
L'achat intégré est lancé. Suivez les instructions de Google Play jusqu'à ce que l'achat réussisse.
Enfin, accédez à votre titre dans le tableau de bord PlayFab **Game Manager** et localisez **New Events**.
Cela signifie que l'achat a bien été fourni, validé et transmis à l'écosystème PlayFab.
À ce stade, vous avez intégré avec succès UnityIAP et l'API Android Billing dans votre application PlayFab.
## Related topics
- [Prise en main de Multiplayer sur Android](/fr/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/android-specific-requirements.md)
- [Prise en main de PlayFab Multiplayer pour Unity](/fr/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/multiplayer-unity-sdk-getting-started.md)
- [Prise en main de PlayFab Explorer](/fr/services/playfab/data-analytics/acting-data/schemas-events-all.md)
- [Démarrage rapide d'Economy (héritée)](/fr/services/playfab/economy-monetization/economy/quickstart.md)
- [Bien démarrer avec Economy v2, Unity IAP et Android](/fr/services/playfab/economy-monetization/economy-v2/tutorials/getting-started-with-unity-and-android.md)