/// <summary> /// Reports that your app has fullfilled the consumable product, the product cannot be purchased again until this is called /// </summary> /// <param name="id">The id of the product</param> /// <param name="transactionId">The transaction id</param> /// <param name="response">A callback indicating the result</param> public static void ReportConsumableProductFulfillment(string id, Guid transactionId, Action <WSAFulfillmentResult> response) { #if NETFX_CORE || (ENABLE_IL2CPP && UNITY_WSA_10_0) if (_isTest) { UnityEngine.WSA.Application.InvokeOnUIThread(async() => { FulfillmentResult result = await CurrentAppSimulator.ReportConsumableFulfillmentAsync(id, transactionId); UnityEngine.WSA.Application.InvokeOnAppThread(() => { if (response != null) { response(MapFulfillmentResult(result)); } }, true); }, false); } else { UnityEngine.WSA.Application.InvokeOnUIThread(async() => { FulfillmentResult result = await CurrentApp.ReportConsumableFulfillmentAsync(id, transactionId); UnityEngine.WSA.Application.InvokeOnAppThread(() => { if (response != null) { response(MapFulfillmentResult(result)); } }, true); }, false); } #endif }
private void FulfillProduct1(string productId, Guid transactionId) { try { FulfillmentResult result = CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); switch (result) { case FulfillmentResult.Succeeded: Debug.WriteLine("You bought and fulfilled product 1."); break; case FulfillmentResult.NothingToFulfill: Debug.WriteLine("There is no purchased product 1 to fulfill."); break; case FulfillmentResult.PurchasePending: Debug.WriteLine("You bought product 1. The purchase is pending so we cannot fulfill the product."); break; case FulfillmentResult.PurchaseReverted: Debug.WriteLine("You bought product 1. But your purchase has been reverted."); // Since the user's purchase was revoked, they got their money back. // You may want to revoke the user's access to the consumable content that was granted. break; case FulfillmentResult.ServerError: Debug.WriteLine("You bought product 1. There was an error when fulfilling."); break; } } catch (System.Exception e) { Debug.WriteLine("You bought Product 1. There was an error when fulfilling. " + e); } }
private IAsyncOperation <FulfillmentResult> ReportConsumableFulfillmentAsync(string productId, Guid transactionId) { if (_useSimulator) { return(CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId)); } else { return(CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId)); } }
public static IAsyncOperation <FulfillmentResult> ReportConsumableFulfillmentAsync(string productId, Guid transactionId) { if (testmode == null) { throw new NotSupportedException(); } else if (testmode.Value) { return(CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId)); } else { return(CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId)); } }
public static void ReportConsumableFulfillment(string productId, Guid transactionId, Action <CallbackResponse <FulfillmentResult> > OnReportConsumableFulfillmentFinished) { Utils.RunOnWindowsUIThread(async() => { Windows.ApplicationModel.Store.FulfillmentResult result = Windows.ApplicationModel.Store.FulfillmentResult.ServerError; try { if (_isLicenseSimulationOn) { result = await CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId); } else { result = await CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId); } } catch (Exception ex) { DebugLog.Log(LogLevel.Error, "Error while reporting consumable fulfillment " + ex.ToString()); Utils.RunOnUnityAppThread(() => { if (OnReportConsumableFulfillmentFinished != null) { OnReportConsumableFulfillmentFinished(new CallbackResponse <FulfillmentResult> { Status = CallbackStatus.Failure, Exception = ex, Result = FulfillmentResult.ServerError }); } }); return; } // This should not really be throwing exceptions.. If it does, they will be raised on the Unity thread anyways, so game should handle it Utils.RunOnUnityAppThread(() => { if (OnReportConsumableFulfillmentFinished != null) { OnReportConsumableFulfillmentFinished( new CallbackResponse <FulfillmentResult> { Result = (Microsoft.UnityPlugins.FulfillmentResult)result, Exception = null, Status = CallbackStatus.Success }); } }); }); }
private async void shield1_Click(object sender, RoutedEventArgs e) { // var result = await CurrentApp.GetProductReceiptAsync("shield"); try { //await Windows.System.Launcher.LaunchUriAsync( //new Uri("ms-windows-store:reviewapp?appid=B5EB66C4-C37A-4DAF-9280-CA85810D0C52")); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync( CoreDispatcherPriority.Normal, async() => { try { PurchaseResults result = await CurrentApp.RequestProductPurchaseAsync("shield"); // var result = await CurrentApp.LoadListingInformationAsync(); var hasPaid = CurrentApp.LicenseInformation.ProductLicenses[("shield")].IsActive; switch (result.Status) { case ProductPurchaseStatus.Succeeded: await CurrentApp.ReportConsumableFulfillmentAsync("shield", result.TransactionId); // OnPurchaseDismissed("1"); break; case ProductPurchaseStatus.NotFulfilled: // InAppPurchaseManager.Instance.CheckUnfulfilledConsumables(); await CurrentApp.ReportConsumableFulfillmentAsync("shield", result.TransactionId); // OnPurchaseDismissed("1"); break; } } catch (Exception ex) { String message = ex.ToString(); var dialog1 = new MessageDialog(message); await dialog1.ShowAsync(); } }); } catch (Exception ex) { ex.ToString(); } }
private static async Task <FulfillmentResult> FulfillAsync(string productID, Guid transactionID) { if (ApplicationInfo.Current.HasInternetConnection == false) { return(FulfillmentResult.ServerError); } FulfillmentResult result = FulfillmentResult.PurchasePending; try { result = await CurrentApp.ReportConsumableFulfillmentAsync( productID, transactionID); } catch { } return(result); }
private IAsyncOperation <bool> FulfillProductInternal(Guid transactionId) { return(AsyncInfo.Run(async cancellationToken => { try { #if DEBUG FulfillmentResult result = await CurrentAppSimulator.ReportConsumableFulfillmentAsync("Credits", transactionId); #else FulfillmentResult result = await CurrentApp.ReportConsumableFulfillmentAsync("Credits", transactionId); Analytics.TrackEvent("credits.fulfillement", new Dictionary <string, string> { ["result"] = result.ToString() }); #endif switch (result) { case FulfillmentResult.Succeeded: return true; case FulfillmentResult.NothingToFulfill: return true; case FulfillmentResult.PurchasePending: return true; case FulfillmentResult.PurchaseReverted: return true; case FulfillmentResult.ServerError: return true; default: return false; } } catch (Exception) { return false; } })); }
public static void ReportConsumableProductFulfillment(InAppUnfulfilledProduct product, Action callback = null) { if (product == null) { return; } Execute.ExecuteOnUIThread(async delegate { try { await CurrentApp.ReportConsumableFulfillmentAsync(InAppPurchaseService.ToInAppProductId(product.ProductId), product.TransactionId); } catch { } Action expr_A2 = callback; if (expr_A2 != null) { expr_A2.Invoke(); } }); }
private async Task <bool> FulfillDonation() { var unfulfilledConsumables = await CurrentApp.GetUnfulfilledConsumablesAsync(); foreach (UnfulfilledConsumable consumable in unfulfilledConsumables) { if (consumable.ProductId == "donation") { FulfillmentResult fulfillmentResult = await CurrentApp.ReportConsumableFulfillmentAsync(consumable.ProductId, consumable.TransactionId); switch (fulfillmentResult) { case FulfillmentResult.Succeeded: case FulfillmentResult.NothingToFulfill: case FulfillmentResult.PurchaseReverted: return(true); } return(false); } } return(true); }
public async Task <FulfillmentResult> PurchaseProduct(string productId) { try { await CurrentApp.RequestProductPurchaseAsync(productId); try { var licenses = CurrentApp.LicenseInformation.ProductLicenses; if (licenses[productId].IsConsumable && licenses[productId].IsActive) { Guid transactionID = new Guid(); FulfillmentResult fr = await CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionID); return(fr); } } catch (Exception) { } } catch (Exception) { } return(FulfillmentResult.ServerError); }
private async void FulfillProduct(string storeId, Guid transactionId) { try { FulfillmentResult result = await CurrentApp.ReportConsumableFulfillmentAsync(storeId, transactionId); switch (result) { case FulfillmentResult.Succeeded: textBlockPurchase.Text = "You bought and fulfilled product"; break; case FulfillmentResult.NothingToFulfill: textBlockPurchase.Text = "There is no purchased product to fulfill."; break; case FulfillmentResult.PurchasePending: textBlockPurchase.Text = "You bought product. The purchase is pending so we cannot fulfill the product."; break; case FulfillmentResult.PurchaseReverted: textBlockPurchase.Text = "You bought product, but your purchase has been reverted."; // Since the user's purchase was revoked, they got their money back. // You may want to revoke the user's access to the consumable content that was granted. break; case FulfillmentResult.ServerError: textBlockPurchase.Text = "You bought product. There was an error when fulfilling."; break; } } catch { textBlockPurchase.Text = "You bought product. There was an error when fulfilling."; } }
public static async Task <FulfillmentResult> ReportConsumableFulfillmentAsync(bool isTestingMode, string productId, Guid transactionId) { return(isTestingMode ? await CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId) : await CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId)); }
private async void buyInAppAsync(string inAppID, InAppPurchaseBuyCallbackMethod purchasedCallback) #endif { #if WINDOWS_PHONE WinRTPlugin.Dispatcher.BeginInvoke(async delegate() #else await WinRTPlugin.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async delegate() #endif { #if WINDOWS_PHONE if ((testing && (!wp8TestLicenseInformation.ProductLicenses[inAppID].IsActive || wp8TestLicenseInformation.ProductLicenses[inAppID].IsConsumable)) || (!testing && (!licenseInformation.ProductLicenses[inAppID].IsActive || licenseInformation.ProductLicenses[inAppID].IsConsumable))) #else if (!licenseInformation.ProductLicenses[inAppID].IsActive || isConsumbable(inAppID)) #endif { try { string receipt = null; #if WINDOWS_PHONE string productID = null; if (testing) { productID = wp8TestListingInformation.ProductListings[inAppID].ProductId; } else { productID = licenseInformation.ProductLicenses[inAppID].ProductId; } #elif UNITY_METRO_8_0 string productID = licenseInformation.ProductLicenses[inAppID].ProductId; #else PurchaseResults results; string productID = licenseInformation.ProductLicenses[inAppID].ProductId; #endif if (testing) { #if WINDOWS_PHONE receipt = await CurrentAppSimulator.RequestProductPurchaseAsync(productID, true); if (wp8TestLicenseInformation.ProductLicenses[inAppID].IsActive) { PlayerPrefsEx.SetIntAsync("ReignIAP_PurchasedAwarded_" + inAppID, 0, true); } #elif UNITY_METRO_8_0 receipt = await CurrentAppSimulator.RequestProductPurchaseAsync(productID, true); #else results = await CurrentAppSimulator.RequestProductPurchaseAsync(productID); receipt = results.ReceiptXml; #endif } else { #if WINDOWS_PHONE receipt = await CurrentApp.RequestProductPurchaseAsync(productID, true); if (licenseInformation.ProductLicenses[inAppID].IsActive) { PlayerPrefsEx.SetIntAsync("ReignIAP_PurchasedAwarded_" + inAppID, 0, true); } #elif UNITY_METRO_8_0 receipt = await CurrentApp.RequestProductPurchaseAsync(productID, true); #else results = await CurrentApp.RequestProductPurchaseAsync(productID); receipt = results.ReceiptXml; #endif } #if UNITY_METRO_8_0 if (!string.IsNullOrEmpty(receipt) || licenseInformation.ProductLicenses[inAppID].IsActive) { PlayerPrefsEx.SetIntAsync("ReignIAP_PurchasedAwarded_" + inAppID, 0, true); } #elif UNITY_METRO if (results.Status == ProductPurchaseStatus.Succeeded || results.Status == ProductPurchaseStatus.AlreadyPurchased || licenseInformation.ProductLicenses[inAppID].IsActive) { PlayerPrefsEx.SetIntAsync("ReignIAP_PurchasedAwarded_" + inAppID, 0, true); } #endif if (purchasedCallback != null) { #if WINDOWS_PHONE if (testing) { purchasedCallback(inAppID, receipt, wp8TestLicenseInformation.ProductLicenses[inAppID].IsActive); if (wp8TestLicenseInformation.ProductLicenses[inAppID].IsConsumable) { CurrentAppSimulator.ReportProductFulfillment(productID); } } else { purchasedCallback(inAppID, receipt, licenseInformation.ProductLicenses[inAppID].IsActive); if (licenseInformation.ProductLicenses[inAppID].IsConsumable) { CurrentApp.ReportProductFulfillment(productID); } } #elif UNITY_METRO_8_0 purchasedCallback(inAppID, receipt, !string.IsNullOrEmpty(receipt) || licenseInformation.ProductLicenses[inAppID].IsActive); if (isConsumbable(inAppID)) { Debug.LogError("NOTE: Consumable IAP not supported in 8.0"); } #else purchasedCallback(inAppID, receipt, results.Status == ProductPurchaseStatus.Succeeded || results.Status == ProductPurchaseStatus.AlreadyPurchased || licenseInformation.ProductLicenses[inAppID].IsActive); if (isConsumbable(inAppID)) { if (testing) { await CurrentAppSimulator.ReportConsumableFulfillmentAsync(productID, results.TransactionId); } else { await CurrentApp.ReportConsumableFulfillmentAsync(productID, results.TransactionId); } } #endif } } catch (Exception e) { Debug.LogError(e.Message); if (purchasedCallback != null) { purchasedCallback(inAppID, null, false); } } } else { if (purchasedCallback != null) { purchasedCallback(inAppID, null, true); } } }); }
ReportConsumableFulfillmentAsync(string productId, Guid transactionId) { return(IsMockEnabled ? CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId) : CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId)); }
protected async Task <FulfillmentResult> ReportConsumableFulfillmentAsyncInternal(string productId, Guid transactionId) { return(await CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId)); }