Abilitare gli acquisti di prodotti di consumo in-app

Offrire prodotti in-app di consumo (elementi che possono essere acquistati, usati e acquistati di nuovo) attraverso la piattaforma di commercio dello Store per fornire ai clienti un'esperienza di acquisto efficace e affidabile. Questo è particolarmente utile per elementi quali il denaro usato nel gioco (oro, monete e così via) che possono essere acquistati e poi usati per acquistare potenziamenti specifici.

Prerequisiti

• Questo argomento illustra la segnalazione degli acquisti e dell'evasione di prodotti in-app di consumo. Se non si ha familiarità con i prodotti in-app, vedere Abilitare gli acquisiti di prodotti in-app per informazioni sulle licenze e su come elencare correttamente i prodotti in-app nello Store.
• La prima volta che si scrive il codice di nuovi prodotti in-app e li si testano, è necessario usare l'oggetto CurrentAppSimulator anziché l'oggetto CurrentApp. In questo modo è possibile verificare la logica di licenza usando chiamate simulate al server licenze anziché chiamare il server live. Per fare ciò, è necessario personalizzare il file denominato WindowsStoreProxy.xml in %userprofile%\AppData\local\packages\<nome pacchetto>\LocalState\Microsoft\Windows Store\ApiData. Il simulatore di Microsoft Visual Studio crea questo file quando esegui l'app per la prima volta oppure puoi anche caricarne uno personalizzato in fase di runtime. Per maggiori informazioni, consultare Utilizzando il file WindowsStoreProxy.xml con CurrentAppSimulator.
• Questo argomento fa riferimento anche agli esempi di codice forniti nelcampione di negozio. Questo esempio è un ottimo modo per acquisire esperienza pratica con le diverse opzioni di monetizzazione fornite per le app UWP (Universal Windows Platform).

Passaggio 1: effettuare la richiesta di acquisto

La richiesta di acquisto iniziale si effettua con RequestProductPurchaseAsync come qualsiasi altro acquisto eseguito tramite lo Store. La differenza per i prodotti in-app di consumo è che dopo un acquisto effettuato, un cliente non può acquistare di nuovo lo stesso prodotto fino a quando l'app non comunica allo Store che l'acquisto precedente è stato evaso. Spetta all'app evadere i prodotti di consumo acquistati e comunicare l'evasione allo Store.

L'esempio seguente mostra una richiesta di acquisto di prodotti in-app di consumo. Sono presenti commenti del codice che indicano quando l'app deve eseguire l'evasione locale del prodotto in-app di consumo per due diversi scenari: quando la richiesta ha esito positivo e quando la richiesta ha esito negativo a causa di un acquisto non evaso dello stesso prodotto.

PurchaseResults purchaseResults = await CurrentAppSimulator.RequestProductPurchaseAsync("product1");
switch (purchaseResults.Status)
{
    case ProductPurchaseStatus.Succeeded:
        product1TempTransactionId = purchaseResults.TransactionId;

        // Grant the user their purchase here, and then pass the product ID and transaction ID to
        // CurrentAppSimulator.ReportConsumableFulfillment to indicate local fulfillment to the
        // Windows Store.
        break;

    case ProductPurchaseStatus.NotFulfilled:
        product1TempTransactionId = purchaseResults.TransactionId;

        // First check for unfulfilled purchases and grant any unfulfilled purchases from an
        // earlier transaction. Once products are fulfilled pass the product ID and transaction ID
        // to CurrentAppSimulator.ReportConsumableFulfillment to indicate local fulfillment to the
        // Windows Store.
        break;
}

Passaggio 2: tenere traccia dell'evasione locale del prodotto di consumo

Quando si concede al cliente l'accesso al prodotto in-app di consumo, è importante tenere traccia del prodotto evaso (productId) e della transazione a cui l'evasione è associata (transactionId).

L'esempio seguente mostra l'uso delle proprietà PurchaseResults della chiamata RequestProductPurchaseAsync nel passaggio precedente per identificare il prodotto acquistato per l'evasione. Si usa una raccolta per archiviare le informazioni sul prodotto in una posizione a cui sia possibile fare riferimento in seguito per verificare che l'evasione locale ha avuto esito positivo.

private void GrantFeatureLocally(string productId, Guid transactionId)
{
    if (!grantedConsumableTransactionIds.ContainsKey(productId))
    {
        grantedConsumableTransactionIds.Add(productId, new List<Guid>());
    }
    grantedConsumableTransactionIds[productId].Add(transactionId);

    // Grant the user their content. You will likely increase some kind of gold/coins/some other asset count.
}

Questo esempio mostra come usare la matrice dell'esempio precedente per accedere alle coppie ID prodotto/ID transazione usate successivamente per segnalare l'evasione allo Store.

private Boolean IsLocallyFulfilled(string productId, Guid transactionId)
{
    return grantedConsumableTransactionIds.ContainsKey(productId) &&
        grantedConsumableTransactionIds[productId].Contains(transactionId);
}

Passaggio 3: segnalare l'evasione dei prodotti allo Store

Dopo il completamento dell'evasione locale, l'app deve eseguire una chiamata ReportConsumableFulfillmentAsync che include productId e la transazione in cui è incluso l'acquisto del prodotto.

FulfillmentResult result = await CurrentAppSimulator.ReportConsumableFulfillmentAsync(
    "product2", product2TempTransactionId);

Passaggio 4: identificare gli acquisti non evasi

L'app può usare il metodo GetUnfulfilledConsumablesAsync per controllare la presenza di prodotti in-app di consumo non evasi in qualsiasi momento. Questo metodo deve essere chiamato regolarmente per verificare la presenza di prodotti di consumo non evasi dovuti a eventi imprevisti dell'app, quali un'interruzione della connettività di rete o la chiusura dell'app.

L'esempio seguente mostra come è possibile usare GetUnfulfilledConsumablesAsync per enumerare i prodotti di consumo non evasi e come l'app può scorrere questo elenco per completare l'evasione locale.

private async void GetUnfulfilledConsumables()
{
    products = await CurrentApp.GetUnfulfilledConsumablesAsync();

    foreach (UnfulfilledConsumable product in products)
    {
        logMessage += "\nProduct Id: " + product.ProductId + " Transaction Id: " + product.TransactionId;
        // This is where you would pass the product ID and transaction ID to
        // currentAppSimulator.reportConsumableFulfillment to indicate local fulfillment to the Windows Store.
    }
}

Argomenti correlati

• Abilitare gli acquisti di prodotti in-app
• Esempio di Store (illustra le versioni di valutazione e gli acquisti in-app)
• Windows.ApplicationModel.Store