> ## 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.
# Introducción a PlayFab Economy heredado, Unity IAP y Android
> Conecte Unity IAP y la API de facturación de Android con los elementos del catálogo de Economy heredado de PlayFab para lograr un flujo de compra desde la aplicación funcional en dispositivos Android.
# Introducción a PlayFab (Economy heredado), Unity IAP y Android
Las API de Economy v1 están en modo de mantenimiento y no recibirán nuevas características, solo correcciones de errores. **Las API v1 se mantendrán en el futuro previsible.** Consulte la [información general de Economy v2](/services/playfab/economy-monetization/economy-v2/overview) para obtener más información sobre la próxima versión de PlayFab Economy.
Este tutorial le muestra cómo configurar las compras desde la aplicación (IAP) mediante PlayFab, el servicio Unity + IAP y la API de facturación de Android.
## Antes de empezar
Configurar IAP puede ser tedioso, especialmente si no está seguro de cómo se supone que los distintos servicios se integran y cooperan.
La imagen siguiente ilustra cómo la API de facturación de Android y PlayFab funcionan conjuntamente para proporcionar una experiencia de IAP sólida a su cliente.
Empiece por configurar sus **Product IDs** y **Prices** a través de PlayMarket. Inicialmente, todos los productos *carecen de identidad*: son entidades digitales que el jugador puede comprar, pero no tienen ningún significado para los jugadores de PlayFab.
Para que esas entidades sean útiles, es necesario reflejarlas en los catálogos de elementos de PlayFab. Esto convierte las entidades sin identidad en lotes, contenedores y elementos individuales.
Cada uno tiene su propia identidad única, con:
* **Títulos**
* **Descripciones**
* **Etiquetas**
* **Tipos**
* **Imágenes**
* **Comportamientos**
Todos ellos están vinculados a los productos del mercado mediante identificadores compartidos.
La mejor manera de acceder a los elementos con dinero real disponibles para su compra es usar [GetCatalogItems](xref:titleid.playfabapi.com.client.title-widedatamanagement.getcatalogitems) y [GetStoreItems](xref:titleid.playfabapi.com.client.title-widedatamanagement.getstoreitems). Estos son los mismos métodos de API que usan las tiendas de moneda gratuita, por lo que el proceso debería resultarle familiar.
El identificador del elemento es el vínculo entre PlayFab y cualquier sistema de IAP externo. Por lo tanto, pasamos el identificador del elemento al servicio de IAP.
En este punto, comienza el proceso de compra. El jugador interactúa con la interfaz de IAP y, si la compra se realiza correctamente, usted obtiene un recibo.
A continuación, PlayFab puede validar el recibo y registrar la compra, concediendo al jugador de PlayFab los elementos que acaba de comprar.
Esta es una idea aproximada de cómo funciona la integración de IAP, y el ejemplo siguiente muestra la mayor parte en acción.
## Configuración de una aplicación cliente
En esta sección se muestra cómo configurar una aplicación muy básica para probar IAP mediante PlayFab, UnityIAP y la API de facturación de Android.
Requisitos previos:
* Un proyecto de Unity.
* El SDK de PlayFab importado y configurado para funcionar con su título.
Nuestro primer paso es configurar UnityIAP:
1. Vaya a **Services**.
2. Asegúrese de que la pestaña **Services** está seleccionada.
3. Seleccione su perfil u organización de **Unity Services**.
4. Seleccione el botón **Create**.
1. A continuación, vaya al servicio **In-App Purchasing (IAP)**.
1. Asegúrese de habilitar el **Service**, estableciendo el botón de alternancia **Simplify cross-platform IAP**.
2. A continuación, seleccione el botón **Continue**.
Aparecerá una página con una lista de complementos.
1. Seleccione el botón **Import**.
Continúe con la instalación de Unity y el procedimiento de importación hasta el punto en que haya importado todos los complementos.
1. Compruebe que los complementos están en su lugar.
2. A continuación, cree un nuevo script llamado **AndroidIAPExample.cs**.
`AndroidIAPExample.cs` contendrá el código que se muestra a continuación (consulte los comentarios del código para obtener más explicaciones).
```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. Cree un nuevo objeto de **Game** llamado **Code**.
2. Agréguele el componente `AndroidIAPExample` (proceso de 2 pasos).
3. Agréguele el componente `AndroidIAPExample`.
4. Asegúrese de **guardar** la escena.
Por último, vaya a **Build Settings**.
1. Compruebe que la escena se ha agregado al área **Scenes In Build**.
2. Asegúrese de que la plataforma **Android** está seleccionada.
3. Vaya al área **Player Settings**.
4. Asigne su **Package Name**.
Asegúrese de crear su *propio* nombre de paquete para evitar colisiones en **PlayMarket**.
Por último, compile la aplicación como de costumbre y asegúrese de tener un APK a buen recaudo.
Todavía no tenemos medios para probarlo. Primero es necesario configurar PlayMarket y PlayFab, lo que se describe en las secciones siguientes.
## Configuración de una aplicación de PlayMarket para IAP
En esta sección se describen los detalles de cómo habilitar IAP para su aplicación de PlayMarket.
La configuración de la aplicación en sí queda fuera del ámbito de este tutorial. Suponemos que ya *tiene* una aplicación y que está configurada para publicar al menos versiones Alpha.
Notas útiles:
* Para llegar a ese punto será necesario que tenga un APK cargado. Use el APK que construimos en la sección anterior.
* Cuando se le pida cargar el APK, puede cargarlo como aplicación Alpha o Beta para habilitar el sandbox de IAP.
* La configuración de **Content Rating** incluirá preguntas sobre cómo está habilitado IAP en la aplicación.
* PlayMarket *no* permite a los publicadores usar ni probar IAP, así que elija *otra* cuenta de Google para las pruebas y agréguela como evaluador de su compilación Alpha/Beta.
Una vez que tenga publicada la compilación de la aplicación:
1. Seleccione **In-app products** en el menú.
* Si se le pide una **Merchant Account**, vincule o cree una.
2. Seleccione el botón **Add New Product**.
1. En la pantalla que se muestra a continuación, seleccione **Managed Product**.
2. Asígnele un **Product ID** descriptivo.
3. Seleccione **Continue**.
PlayMarket requiere que rellene un **Title (1)** y una **Description (2)**. Sin embargo, en nuestro caso no son de mucha utilidad.
Tomaremos los datos del **Data Item** exclusivamente del servicio de PlayFab, y solo es necesario que los identificadores coincidan.
1. Desplácese más abajo y seleccione el botón **Add a price**.
1. Escriba un precio válido (observe cómo el precio se convierte para cada país o región de forma independiente).
2. Seleccione el botón **Apply**.
1. Por último, vuelva a la parte superior de la pantalla y cambie el estado del elemento a **Active**.
Aunque esto concluye la configuración de la aplicación, necesitamos un par de ajustes más. En primer lugar, guardemos la **Licensing Key** (resultará útil para vincular PlayFab con PlayMarket).
1. Vaya a **Services & APIs** en el menú.
2. A continuación, busque y guarde la versión **Base64** de la **Key**.
El paso siguiente es habilitar las pruebas de IAP. Aunque el sandbox se habilita automáticamente para las compilaciones Alpha y Beta, es necesario configurar las cuentas autorizadas para probar la aplicación:
1. Vaya a **Home**.
2. Busque y seleccione **Account details** en el menú de la izquierda.
3. Busque el área **License Testing**.
4. Compruebe que sus **Test Accounts** están en la lista.
5. Asegúrese de que **License Test Response** está establecido en **RESPOND\_NORMALLY**.
No olvide aplicar la configuración.
En este punto, la parte de Play Market de la integración debería estar configurada.
## Configuración de un título de PlayFab
Nuestro último paso es configurar un título de PlayFab para reflejar nuestros productos e integrarlo con la API de facturación de Google.
1. Seleccione **Add-ons**.
2. A continuación, seleccione el complemento de **Google**.
1. Rellene su **Package ID**.
2. Rellene la **Google App License Key** que obtuvo en la sección anterior.
3. Confirme los cambios seleccionando el botón **Install Google**.
El paso siguiente es reflejar nuestro elemento Golden Sword en PlayFab:
1. Seleccione **Economy**.
2. Compruebe que la subpestaña **Catalogs** está seleccionada.
3. Seleccione **New Catalog**.
4. Proporcione un nombre de **Catalog version**.
5. Seleccione **Save Catalog**.
Si el catálogo no tiene elementos, se quita *automáticamente*. Por eso, cualquier catálogo nuevo incluye un elemento agregado previamente llamado **One**.
*Siempre* podemos crear un elemento *nuevo*, pero para mantener las cosas ordenadas, modifiquemos el elemento **One** existente.
1. Seleccione el elemento para editar el **Item ID** de modo que coincida con el identificador de PlayMarket.
2. Ahora, edite el **Display name** y agregue una **Description**.
Tenga en cuenta que estos datos *no tienen nada que ver* con el **Play Market Item Title** y la **Description**: son *totalmente* independientes.
1. Asigne un **Price** a su **Item**.
2. Seleccione **Save Item** para confirmar los cambios.
En este tutorial, IAP se refiere principalmente a las compras con dinero real. Por eso usamos **RM**, la moneda especial de dinero real. El importe de PlayFab se define en centavos de dólar estadounidense.
1. Observe su elemento en la lista **Item ID**.
Esto concluye la configuración de su título de PlayFab.
## Pruebas
Para las pruebas, descargue la aplicación mediante la versión Alpha/Beta.
* Asegúrese de usar una cuenta de prueba y un dispositivo Android real.
* Una vez que inicie la aplicación, debería ver IAP inicializado y *un botón* que representa su elemento.
* Seleccione ese botón.
Se iniciará la compra de IAP. Siga las instrucciones de Google Play hasta el punto en que la compra se realice correctamente.
Por último, vaya a su título en el panel de **Game Manager** de PlayFab y busque **New Events**.
Esto significa que la compra se proporcionó, se validó y se canalizó correctamente al ecosistema de PlayFab.
En este punto, ha integrado correctamente UnityIAP y la API de facturación de Android en su aplicación de PlayFab.
## Related topics
- [Introducción a Economy v2, Unity IAP y Android](/es/services/playfab/economy-monetization/economy-v2/tutorials/getting-started-with-unity-and-android.md)
- [Introducción a Multiplayer para Android](/es/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/android-specific-requirements.md)
- [Introducción a PlayFab Multiplayer para Unity](/es/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/multiplayer-unity-sdk-getting-started.md)
- [Documentación de PlayFab Economy v2](/es/services/playfab/economy-monetization/index.md)
- [Inicio rápido de Economy (heredada)](/es/services/playfab/economy-monetization/economy/quickstart.md)