コード例 #1
0
        private async Task <Receipt> PurchaseProductAsync(Product product)
        {
            // Ensure that if this is a consumable, any previous purchases have been fulfilled
            if (product.Type == ProductType.Consumable)
            {
                var waiting = await GetUnfulfilledConsumablesAsync();

                UnfulfilledConsumable transaction = null;
                foreach (var unfulfilledConsumable in waiting)
                {
                    if (unfulfilledConsumable.ProductId == product.ProductID)
                    {
                        transaction = unfulfilledConsumable;
                        break;
                    }
                }

                if (transaction != null)
                {
                    var fulfillmentResult = await ReportConsumableFulfillmentAsync(transaction.ProductId, transaction.TransactionId);

                    if (fulfillmentResult != FulfillmentResult.NothingToFulfill &&
                        fulfillmentResult != FulfillmentResult.Succeeded)
                    {
                        // An error occured or the purchase is still pending and could fail - we consider this purchase failed
                        return(new Receipt(product, StatusCode.ConsumablePending, null));
                    }
                }
            }

            var purchaseResult = await RequestProductPurchaseAsync(product.ProductID);

            if (purchaseResult.Status == ProductPurchaseStatus.Succeeded)
            {
                return(new Receipt(product, StatusCode.Success, purchaseResult.ReceiptXml));
            }

            // If we reach this point then an error has occured in the purchase
            var status = StatusCode.UnknownError;

            switch (purchaseResult.Status)
            {
            case ProductPurchaseStatus.AlreadyPurchased:
                status = StatusCode.DurableOwned;
                break;

            case ProductPurchaseStatus.NotFulfilled:
                status = StatusCode.ConsumablePending;
                break;

            case ProductPurchaseStatus.NotPurchased:
                status = StatusCode.UserCancelled;
                break;
            }
            return(new Receipt(product, status, null));
        }
コード例 #2
0
 public static async void LoadUnfulfilledConsumables(string productId, Action <List <InAppUnfulfilledProduct> > callback)
 {
     if (callback != null)
     {
         List <InAppUnfulfilledProduct> list = new List <InAppUnfulfilledProduct>();
         if (AppGlobalStateManager.Current.GlobalState.PaymentType == AccountPaymentType.money)
         {
             callback.Invoke(list);
         }
         else
         {
             try
             {
                 IEnumerator <UnfulfilledConsumable> var_2 = (await CurrentApp.GetUnfulfilledConsumablesAsync()).GetEnumerator();
                 try
                 {
                     while (var_2.MoveNext())
                     {
                         UnfulfilledConsumable var_3_BD = var_2.Current;
                         string var_4_C9 = InAppPurchaseService.ToServerMerchantProductId(var_3_BD.ProductId);
                         if (string.IsNullOrEmpty(productId) || !(var_4_C9 != productId))
                         {
                             list.Add(new InAppUnfulfilledProduct
                             {
                                 ProductId     = var_4_C9,
                                 TransactionId = var_3_BD.TransactionId
                             });
                         }
                     }
                 }
                 finally
                 {
                     if (var_2 != null)
                     {
                         var_2.Dispose();
                     }
                 }
             }
             catch
             {
             }
             callback.Invoke(list);
         }
     }
 }