> ## 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.
# Premiers pas avec PlayFab Economy hérité, Unity IAP et Android
> Connectez Unity IAP et l'API Android Billing aux articles de catalogue de PlayFab Legacy Economy pour obtenir un flux d'achats intégrés fonctionnel sur les appareils Android.
# Premiers pas avec PlayFab (Economy hérité), Unity IAP et Android
Les API Economy v1 sont en mode maintenance et ne recevront aucune nouvelle fonctionnalité, seulement des correctifs de bogues. **Les API v1 seront maintenues dans un avenir prévisible.** Consultez la [vue d'ensemble d'Economy v2](/fr-CA/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 collaborer.
L'image suivante illustre comment l'API Android Billing et PlayFab fonctionnent ensemble pour offrir une expérience d'achats intégrés solide à votre client.
Commencez par configurer vos **Product IDs** et vos **Prices** au moyen de 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 reproduire dans les catalogues d'articles PlayFab. Cela transforme les entités anonymes en ensembles, en conteneurs et en articles individuels.
Chacun possède sa propre identité, avec :
* **des titres**
* **des descriptions**
* **des étiquettes**
* **des types**
* **des images**
* **des comportements**
Tous ces éléments sont liés aux produits du marché au moyen d'ID partagés.
La meilleure façon d'accéder aux articles en argent réel offerts à l'achat est d'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'article est le lien entre PlayFab et tout système d'achats intégrés externe. Nous transmettons donc l'ID de l'article au service d'achats intégrés.
À ce stade, le processus d'achat commence. Le joueur interagit avec l'interface d'achats intégrés et, si l'achat réussit, vous obtenez un reçu.
PlayFab peut ensuite valider le reçu et enregistrer l'achat, en accordant au joueur PlayFab les articles qu'il vient d'acheter.
Voilà 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.
## Configurer 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, de 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 votre organisation **Unity Services**.
4. Sélectionnez le bouton **Create**.
1. Ensuite, accédez au service **In-App Purchasing (IAP)**.
1. Assurez-vous d'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 plugiciels s'affiche.
1. Sélectionnez le bouton **Import**.
Poursuivez la procédure d'installation et d'importation de Unity jusqu'à ce que tous les plugiciels soient importés.
1. Vérifiez que les plugiciels sont en place.
2. Créez ensuite un nouveau script appelé **AndroidIAPExample.cs**.
`AndroidIAPExample.cs` contiendra le code présenté ci-dessous (veuillez consulter les commentaires du code pour obtenir 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-y le composant `AndroidIAPExample` (processus en 2 étapes).
3. Ajoutez-y le composant `AndroidIAPExample`.
4. Assurez-vous d'**enregistrer** (**Save**) 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** est sélectionnée.
3. Passez à la zone **Player Settings**.
4. Attribuez votre **Package Name**.
Assurez-vous de choisir votre *propre* nom de package pour éviter tout conflit dans **PlayMarket**.
Enfin, générez l'application comme d'habitude et assurez-vous d'avoir un APK en lieu sûr.
Nous n'avons pas encore de moyen de le tester. Nous devons d'abord configurer PlayMarket et PlayFab, comme le décrivent les sections suivantes.
## Configurer une application PlayMarket pour les achats intégrés
Cette section décrit les détails de l'activation des achats intégrés pour votre application PlayMarket.
La configuration de l'application elle-même dépasse la portée de ce tutoriel. Nous supposons que vous *avez* déjà une application et qu'elle est configurée pour publier au moins des versions Alpha.
Remarques utiles :
* Pour arriver à ce point, vous devrez avoir téléversé un APK. Veuillez utiliser l'APK que nous avons créé dans la section précédente.
* Lorsqu'on vous demande de téléverser l'APK, vous pouvez le téléverser en tant qu'application Alpha ou Bêta pour activer le bac à sable des achats intégrés.
* La configuration de la **Content Rating** comprendra 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 ni de tester les achats intégrés; veuillez donc choisir un *autre* compte Google à des fins de test, et l'ajouter comme testeur de votre version Alpha/Bêta.
Une fois la version de l'application publiée :
1. Sélectionnez **In-app products** dans le menu.
* Si on vous demande un **Merchant Account**, liez-en un ou créez-en un.
2. Sélectionnez le bouton **Add New Product**.
1. Dans l'écran présenté ci-dessous, sélectionnez **Managed Product**.
2. Donnez-lui un **Product ID** descriptif.
3. Sélectionnez **Continue**.
PlayMarket exige que vous remplissiez un **Title (1)** et une **Description (2)**. Toutefois, ceux-ci ne sont pas très utiles dans notre cas.
Nous obtiendrons les données des **Data Item** exclusivement à partir du service PlayFab, et nous avons seulement besoin que les ID correspondent.
1. Faites défiler vers le bas et sélectionnez le bouton **Add a price**.
1. Entrez un prix valide (remarquez comment le prix est converti indépendamment pour chaque pays ou région).
2. Sélectionnez le bouton **Apply**.
1. Enfin, remontez en haut de l'écran et changez l'état de l'article à **Active**.
Bien que cela conclue la configuration de l'application, nous devons apporter quelques ajustements supplémentaires. D'abord, enregistrons la **Licensing Key** (elle sera utile pour lier PlayFab à PlayMarket).
1. Accédez à **Services & APIs** dans le menu.
2. Repérez 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 versions Alpha et Bêta, nous devons configurer les comptes autorisés à tester l'application :
1. Accédez à **Home**.
2. Repérez et sélectionnez **Account details** dans le menu de gauche.
3. Repérez 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!
Le volet Play Market de l'intégration devrait maintenant être configuré.
## Configurer 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. Entrez votre **Package ID**.
2. Entrez la **Google App License Key** que vous avez obtenue dans la section précédente.
3. Validez vos modifications en sélectionnant le bouton **Install Google**.
Notre prochaine étape consiste à reproduire notre article 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 article, il est *automatiquement* supprimé. C'est pourquoi tout nouveau catalogue est fourni avec un article préajouté appelé **One**.
Nous pouvons *toujours* créer un *nouvel* article, mais pour garder les choses simples, modifions l'article **One** existant.
1. Sélectionnez l'article pour modifier l'**Item ID** afin qu'il corresponde à l'ID dans PlayMarket.
2. Modifiez maintenant le **Display name** et ajoutez une **Description**.
Gardez à l'esprit que ces données n'ont *rien à voir* avec le **Play Market Item Title** et la **Description**; elles en 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 les achats en argent réel. C'est pourquoi nous utilisons **RM**, la monnaie spéciale Real Money (argent réel). Le montant PlayFab est défini en cents américains.
1. Observez votre article 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.
* Assurez-vous d'utiliser un compte de test et un véritable appareil Android.
* Une fois l'application démarrée, vous devriez voir les achats intégrés initialisés et *un bouton* représentant votre article.
* Sélectionnez ce bouton.
L'achat intégré est alors lancé. Suivez les instructions de Google Play jusqu'à ce que l'achat réussisse.
Enfin, accédez à votre titre dans le tableau de bord de PlayFab **Game Manager** et repérez les **New Events**.
Cela signifie que l'achat a été fourni, validé et acheminé avec succès vers l'écosystème PlayFab.
Vous avez maintenant intégré avec succès UnityIAP et l'API Android Billing à votre application PlayFab.
## Related topics
- [Démarrage rapide d'Economy (hérité)](/fr-CA/services/playfab/economy-monetization/economy/quickstart.md)
- [Prise en main d'Economy v2, d'Unity IAP et d'Android](/fr-CA/services/playfab/economy-monetization/economy-v2/tutorials/getting-started-with-unity-and-android.md)
- [Objets (Economy hérité)](/fr-CA/services/playfab/economy-monetization/economy/items/index.md)
- [Notifications push pour Android](/fr-CA/services/playfab/live-service-management/game-configuration/title-communications/push-notifications/push-notifications-for-android.md)
- [Tables de butin dans Economy (hérité)](/fr-CA/services/playfab/economy-monetization/economy/tutorials/drop-tables.md)