public async static void RequestLicense(string productKey) { if (NetworkInterface.GetIsNetworkAvailable() == true) { try { #if DEBUG await CurrentAppSimulator.RequestProductPurchaseAsync(productKey); #else var result = await CurrentApp.RequestProductPurchaseAsync(productKey); #endif if (licenseInformation.ProductLicenses[productKey].IsActive) { HelperUWP.Reporting.DisplayMessage("Successfully Purchased the product forever! " + HelperUWP.Reporting.AppName, "Successfully Purchased"); } else { HelperUWP.Reporting.DisplayMessage("Product key was not purchased" + HelperUWP.Reporting.AppName + " Please restart app and try again" + " -> UpradePage"); } } catch (Exception ex) { HelperUWP.Reporting.DisplayMessage(ex.Message + "Product key was not purchased" + HelperUWP.Reporting.AppName + " Please restart app and try again" + "->UpradePage"); } } else { HelperUWP.Reporting.NoConnections(); } }
/// <summary> /// Check if the product is already activated on MEGA license server /// </summary> /// <param name="productId">Product identifier</param> private static async Task CheckLicenseAsync(string productId) { try { if (string.IsNullOrEmpty(productId)) { return; } #if DEBUG var receipt = await CurrentAppSimulator.GetProductReceiptAsync(productId); #else var receipt = await CurrentApp.GetProductReceiptAsync(productId); #endif if (string.IsNullOrEmpty(receipt)) { return; } LogService.Log(MLogLevel.LOG_LEVEL_INFO, "Checking product license..."); LogService.Log(MLogLevel.LOG_LEVEL_DEBUG, "License info: " + receipt); if (!CheckReceiptIdStatus(receipt)) { await ActivateMegaLicenseAsync(receipt); } } catch (Exception e) { // If an error occurs, ignore. App will try again on restart LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Error (re-)checking licenses", e); } }
private async void Donation_Click(object sender, RoutedEventArgs e) { if (!Config.Instance.LicenseInformation.ProductLicenses[InAppPurchase.TokenDonation].IsActive) { try { // show the purchase dialog. #if DEBUG await CurrentAppSimulator.RequestProductPurchaseAsync(InAppPurchase.TokenDonation); #else await CurrentApp.RequestProductPurchaseAsync(InAppPurchase.TokenDonation); #endif SetDonations(); } catch (Exception) { // The in-app purchase was not completed because // an error occurred. } } else { SetDonations(); } }
private async void Button_Click(object sender, RoutedEventArgs e) { LicenseInformation licenseInformation = CurrentAppSimulator.LicenseInformation; if (!licenseInformation.ProductLicenses["product2"].IsActive) { try { await CurrentAppSimulator.RequestProductPurchaseAsync("product2"); if (licenseInformation.ProductLicenses["product2"].IsActive) { AdMediator.Visibility = Visibility.Collapsed; } else { AdMediator.Visibility = Visibility.Visible; } } catch (Exception) { //rootPage.NotifyUser("Unable to buy " + productName + ".", NotifyType.ErrorMessage); } } else { //rootPage.NotifyUser("You already own " + productName + ".", NotifyType.ErrorMessage); } }
private async void PurchaseButton_Click(object sender, RoutedEventArgs e) { if (!AppLicenseInformation.ProductLicenses["MyInAppOfferToken"].IsActive) { try { // The customer doesn't own this feature, so // show the purchase dialog. PurchaseResults results = await CurrentAppSimulator.RequestProductPurchaseAsync("RemoveAdsOffer"); //Check the license state to determine if the in-app purchase was successful. if (results.Status == ProductPurchaseStatus.Succeeded) { AdMediator_40F141.Visibility = Visibility.Collapsed; PurchaseButton.Visibility = Visibility.Collapsed; } } catch (Exception ex) { // The in-app purchase was not completed because // an error occurred. throw ex; } } else { // The customer already owns this feature. } }
private static async Task LoadConfigFile() { var storageFolder = Package.Current.InstalledLocation; var storageFileResult = await storageFolder.GetFileAsync(@"trial-mode.xml"); await CurrentAppSimulator.ReloadSimulatorAsync(storageFileResult); }
public async Task <InAppPurchaseHelper> Setup() { // license if (Simulate) { #if DEBUG await SetupSimulation(); m_License = CurrentAppSimulator.LicenseInformation; m_Listing = await CurrentAppSimulator.LoadListingInformationAsync(); CanPurchase = true; #endif } else { try { m_License = CurrentApp.LicenseInformation; m_Listing = await CurrentApp.LoadListingInformationAsync(); CanPurchase = true; } catch (Exception e) { System.Diagnostics.Debug.WriteLine(string.Format("Setup/License [{0}, {1}, {2}]", this.Key, this.Simulate, e.Message)); CanPurchase = false; } } if (!CanPurchase) { return(this); // :( } try { // test setup m_License.LicenseChanged += () => { RaiseLicenseChanged(IsPurchased); }; IReadOnlyDictionary <string, ProductLicense> _Licenses = m_License.ProductLicenses; if (!_Licenses.Any(x => x.Key.Equals(Key, StringComparison.CurrentCultureIgnoreCase))) { throw new KeyNotFoundException(Key); } IReadOnlyDictionary <string, ProductListing> _Products = m_Listing.ProductListings; if (!_Products.Any(x => x.Key.Equals(Key, StringComparison.CurrentCultureIgnoreCase))) { throw new KeyNotFoundException(Key); } // product m_Product = _Products[Key]; } catch (Exception e) { System.Diagnostics.Debug.WriteLine(string.Format("Setup/Tests [{0}, {1}, {2}]", this.Key, this.Simulate, e.Message)); CanPurchase = false; } return(this); }
async Task PurchaseFeatureAsync(string feature_name) { var feature = App.License.ProductLicenses[feature_name]; if (App.ListingInfo.ProductListings.ContainsKey(feature_name)) { var feature_listinginfo = App.ListingInfo.ProductListings[feature_name]; if (feature.IsActive) { MessageDialog dlg = new MessageDialog($"You already have {feature_listinginfo.Name}"); await dlg.ShowAsync(); } else { MessageDialog dlg = new MessageDialog($"{feature_listinginfo.FormattedPrice} costs {feature_listinginfo.Name}", $"Buy {feature_listinginfo.Name}?"); dlg.Commands.Add(new UICommand($"Buy {feature_listinginfo.Name}", async delegate(IUICommand c) { await CurrentAppSimulator.RequestProductPurchaseAsync(feature.ProductId); //CurrentAppSimulator. })); dlg.Commands.Add(new UICommand("No thanks", cmd => { })); await dlg.ShowAsync(); } } else { MessageDialog dlg = new MessageDialog($"{feature_name} does not exist in this application"); await dlg.ShowAsync(); } }
/// <summary> /// Loads the app listing information asynchronously, returning features /// and products in the ProductListings collection that match all supplied keywords. /// </summary> /// <param name="keywords"> /// The list of keywords by which to filter the ProductListings /// collection that is returned in the ListingInformation object. /// </param> /// <returns> /// The app's listing information, with ProductListings collection filtered by keywords. If the method fails, it /// returns an HRESULT error code. If no products or features are found that match all of the given keywords, the /// ProductListings collection will be empty. /// </returns> public static IAsyncOperation <ListingInformation> LoadListingInformationByKeywordsAsync( IEnumerable <string> keywords) { return(IsMockEnabled ? CurrentAppSimulator.LoadListingInformationByKeywordsAsync(keywords) : CurrentApp.LoadListingInformationByKeywordsAsync(keywords)); }
internal async void PurchaseFullLicense() { MainPageViewModel mainPageVM = ServiceLocator.Current.GetInstance <MainPageViewModel>(); licenseInformation = CurrentAppSimulator.LicenseInformation; if (licenseInformation.IsTrial) { try { await CurrentAppSimulator.RequestAppPurchaseAsync(false); if (!licenseInformation.IsTrial && licenseInformation.IsActive) { mainPageVM.ResumeDownloadAction(); } else { mainPageVM.CancelDownloadAction(); } } catch (Exception) { mainPageVM.CancelDownloadAction(); } } }
public async Task <ProductPurchaseStatus> BuyFullVersion(bool isPermanent) { try { ProductPurchaseStatus status; if (isPermanent) { status = (await CurrentAppSimulator.RequestProductPurchaseAsync(StoreConstants.FullVersionVKSaverPernament)).Status; } else { status = (await CurrentAppSimulator.RequestProductPurchaseAsync(StoreConstants.FullVersionVKSaver)).Status; } var dict = new Dictionary <string, string>(1); if (status == ProductPurchaseStatus.Succeeded) { dict["Purchased"] = isPermanent ? FULL_VERSION_PERMANENT : FULL_VERSION_MONTH; _metricaService.LogEvent(FULL_VERSION_PURCHASED_EVENT, JsonConvert.SerializeObject(dict)); } else if (status == ProductPurchaseStatus.AlreadyPurchased) { dict["AlreadyPurchased"] = isPermanent ? FULL_VERSION_PERMANENT : FULL_VERSION_MONTH; _metricaService.LogEvent(FULL_VERSION_PURCHASED_EVENT, JsonConvert.SerializeObject(dict)); } return(status); } catch (Exception ex) { _logService.LogException(ex); return(ProductPurchaseStatus.NotPurchased); } }
private async Task LoadInAppPurchaseProxyFileAsync() { StorageFolder proxyDataFolder = await Package.Current.InstalledLocation.GetFolderAsync("data"); StorageFile proxyFile = await proxyDataFolder.GetFileAsync("in-app-purchase.xml"); licenseChangeHandler = new LicenseChangedEventHandler(InAppPurchaseRefreshScenario); CurrentAppSimulator.LicenseInformation.LicenseChanged += licenseChangeHandler; await CurrentAppSimulator.ReloadSimulatorAsync(proxyFile); // setup application upsell message try { ListingInformation listing = await CurrentAppSimulator.LoadListingInformationAsync(); var product1 = listing.ProductListings["product1"]; var product2 = listing.ProductListings["product2"]; Product1SellMessage.Text = "You can buy " + product1.Name + " for: " + product1.FormattedPrice + "."; Product2SellMessage.Text = "You can buy " + product2.Name + " for: " + product2.FormattedPrice + "."; } catch (Exception) { rootPage.NotifyUser("LoadListingInformationAsync API call failed", NotifyType.ErrorMessage); } }
/// <summary> /// Requests purchase of your app if it is in trial mode, returns an xml reciept if successful /// </summary> /// <param name="response">A callback containing the receipt</param> public static void PurchaseApp(Action <string> response) { #if NETFX_CORE || (ENABLE_IL2CPP && UNITY_WSA_10_0) if (_isTest) { UnityEngine.WSA.Application.InvokeOnUIThread(async() => { string result = await CurrentAppSimulator.RequestAppPurchaseAsync(true); UnityEngine.WSA.Application.InvokeOnAppThread(() => { if (response != null) { response(result); } }, true); }, true); } else { UnityEngine.WSA.Application.InvokeOnUIThread(async() => { string result = await CurrentApp.RequestAppPurchaseAsync(true); UnityEngine.WSA.Application.InvokeOnAppThread(() => { if (response != null) { response(result); } }, true); }, true); } #endif }
/// <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 async void BuyAndFulfillProduct1Button_Click(object sender, RoutedEventArgs e) { Log("Buying Product 1...", NotifyType.StatusMessage); try { PurchaseResults purchaseResults = await CurrentAppSimulator.RequestProductPurchaseAsync("product1"); switch (purchaseResults.Status) { case ProductPurchaseStatus.Succeeded: GrantFeatureLocally("product1", purchaseResults.TransactionId); FulfillProduct1("product1", purchaseResults.TransactionId); break; case ProductPurchaseStatus.NotFulfilled: if (!IsLocallyFulfilled("product1", purchaseResults.TransactionId)) { GrantFeatureLocally("product1", purchaseResults.TransactionId); } FulfillProduct1("product1", purchaseResults.TransactionId); break; case ProductPurchaseStatus.NotPurchased: Log("Product 1 was not purchased.", NotifyType.StatusMessage); break; } } catch (Exception) { Log("Unable to buy Product 1.", NotifyType.ErrorMessage); } }
/// <summary> /// Requests the purchase of an in-app product. Additionally, calling this method displays the UI that is used to complete /// the transaction via the Windows Store. /// </summary> /// <param name="productId">Specifies the id of the in-app product.</param> /// <param name="offerId"> /// The specific in-app feature or content within the large purchase catalog represented on the /// Windows Store by the productId. This value correlates with the content your app is responsible for fulfilling. The /// Windows Store only uses this value to itemize the PurchaseResults. /// </param> /// <param name="displayProperties"> /// The name of the app feature or content offer that is displayed to the user at time of /// purchase. /// </param> /// <returns>The results of the in-app product purchase request.</returns> public static IAsyncOperation <PurchaseResults> RequestProductPurchaseAsync(string productId, string offerId, ProductPurchaseDisplayProperties displayProperties) { return(IsMockEnabled ? CurrentAppSimulator.RequestProductPurchaseAsync(productId, offerId, displayProperties) : CurrentApp.RequestProductPurchaseAsync(productId, offerId, displayProperties)); }
/// <summary> /// Invoked when the user asks purchase the app. /// </summary> private async void PurchaseFullLicense() { LicenseInformation licenseInformation = CurrentAppSimulator.LicenseInformation; rootPage.NotifyUser("Buying the full license...", NotifyType.StatusMessage); if (licenseInformation.IsTrial) { try { await CurrentAppSimulator.RequestAppPurchaseAsync(false); if (!licenseInformation.IsTrial && licenseInformation.IsActive) { rootPage.NotifyUser("You successfully upgraded your app to the fully-licensed version.", NotifyType.StatusMessage); } else { rootPage.NotifyUser("You still have a trial license for this app.", NotifyType.ErrorMessage); } } catch (Exception) { rootPage.NotifyUser("The upgrade transaction failed. You still have a trial license for this app.", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("You already bought this app and have a fully-licensed version.", NotifyType.ErrorMessage); } }
public async Task <bool> BuyProduct(string FeatureName) { try { #if DEBUG if (licenseInformation.IsTrial) { await CurrentAppSimulator.RequestAppPurchaseAsync(false); } PurchaseResults Result = await CurrentAppSimulator.RequestProductPurchaseAsync(FeatureName); #else PurchaseResults Result = await CurrentApp.RequestProductPurchaseAsync(FeatureName); #endif //Reset status; _HasRemoveAds = null; //Check the license state to determine if the in-app purchase was successful. return(Result.Status == ProductPurchaseStatus.Succeeded || Result.Status == ProductPurchaseStatus.AlreadyPurchased); } catch (Exception) { return(false); } }
private async void DoTapAction(StoreItem key) { if (!LicenseInformation.ProductLicenses[key.Code].IsActive) { try { #if DEBUG var result = await CurrentAppSimulator.RequestProductPurchaseAsync(key.Code); #else var result = await CurrentApp.RequestProductPurchaseAsync(key.Code); #endif CheckBuy(); CheckType(); } catch (Exception e) { } } else { var item = AvailableProducts.Where(x => x.Code == key.Code).FirstOrDefault(); if (item != null) { item.Purchased = true; } } }
private async void FulfillPreviousPurchase(object sender, RoutedEventArgs e) { try { IReadOnlyList <UnfulfilledConsumable> consumables = await CurrentAppSimulator.GetUnfulfilledConsumablesAsync(); string logMessage = "Number of unfulfilled consumables: " + consumables.Count; foreach (UnfulfilledConsumable consumable in consumables) { logMessage += "\nProduct Id: " + consumable.ProductId + " Transaction Id: " + consumable.TransactionId; // This is where you would grant the user their consumable content and call currentApp.reportConsumableFulfillment // For demonstration purposes, we leave the purchase unfulfilled. if (!IsLocallyFulfilled(consumable.TransactionId)) { GrantFeatureLocally(consumable.TransactionId); } FulfillProduct(consumable.TransactionId); } //NotifyUser("product1 was fulfilled.You are now able to buy another one"); //tb2.Text = logMessage.ToString(); } catch (Exception) { //rootPage.NotifyUser("GetUnfulfilledConsumablesAsync API call failed", NotifyType.ErrorMessage); } }
public static void RequestAppPurchase(bool requireReceipt, Action <CallbackResponse <string> > OnAppPurchaseFinished) { string result = String.Empty; bool didPurchaseSucceed = false; Utils.RunOnWindowsUIThread(async() => { try { if (_isLicenseSimulationOn) { result = await CurrentAppSimulator.RequestAppPurchaseAsync(requireReceipt); if (CurrentAppSimulator.LicenseInformation.IsActive && !CurrentAppSimulator.LicenseInformation.IsTrial) { didPurchaseSucceed = true; } } else { result = await CurrentApp.RequestAppPurchaseAsync(requireReceipt); if (CurrentApp.LicenseInformation.IsActive && !CurrentApp.LicenseInformation.IsTrial) { didPurchaseSucceed = true; } } } catch (Exception ex) { DebugLog.Log(LogLevel.Error, "Error purchasing the app " + ex.ToString()); Utils.RunOnUnityAppThread(() => { if (OnAppPurchaseFinished != null) { OnAppPurchaseFinished( new CallbackResponse <string> { Status = CallbackStatus.Failure, Result = null, Exception = ex }); } }); return; } Utils.RunOnUnityAppThread(() => { if (OnAppPurchaseFinished != null) { OnAppPurchaseFinished(new CallbackResponse <string> { Status = didPurchaseSucceed ? CallbackStatus.Success : CallbackStatus.Failure, Result = result, Exception = null }); } }); }); }
private async void Buy(object sender, RoutedEventArgs e) { PurchaseResults purchaseResults = await CurrentAppSimulator.RequestProductPurchaseAsync("product1"); switch (purchaseResults.Status) { case ProductPurchaseStatus.Succeeded: //Local fulfillment //GrantFeatureLocally(purchaseResults.TransactionId); ////Reporting product fulfillment to the Store //FulfillProduct(purchaseResults.TransactionId); NotifyUser("You bought product1. Transaction Id: " + purchaseResults.TransactionId); break; case ProductPurchaseStatus.NotFulfilled: // 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. //NotifyUser("You have an unfulfilled copy of " + info.nameRun.Text + ". Fulfill it before purchasing another one."); NotifyUser("You have an unfulfilled copy of product1.Fulfill it before purchasing another one."); break; case ProductPurchaseStatus.NotPurchased: NotifyUser("product1 was not purchased."); break; } }
private async void Page_Loaded(object sender, RoutedEventArgs e) { //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Remove these lines of code before publishing! // The actual CurrentApp will create a WindowsStoreProxy.xml // in the package's \LocalState\Microsoft\Windows Store\ApiData // folder where it stores the actual purchases. // Here we're just giving it a fake version of that file // for testing. StorageFolder proxyDataFolder = await Package.Current.InstalledLocation.GetFolderAsync("Assets"); StorageFile proxyFile = await proxyDataFolder.GetFileAsync("test.xml"); await CurrentAppSimulator.ReloadSimulatorAsync(proxyFile); //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // You may want to put this at the App level AppLicenseInformation = CurrentAppSimulator.LicenseInformation; if (AppLicenseInformation.ProductLicenses["RemoveAdsOffer"].IsActive) { // Customer can access this feature. AdMediator_40F141.Visibility = Visibility.Collapsed; PurchaseButton.Visibility = Visibility.Collapsed; } else { // Customer can NOT access this feature. AdMediator_40F141.Visibility = Visibility.Visible; PurchaseButton.Visibility = Visibility.Visible; } }
private async void BuyProduct1Button_Click(object sender, RoutedEventArgs e) { LicenseInformation licenseInformation = CurrentAppSimulator.LicenseInformation; if (!licenseInformation.ProductLicenses["product1"].IsActive) { rootPage.NotifyUser("Buying Product 1...", NotifyType.StatusMessage); try { await CurrentAppSimulator.RequestProductPurchaseAsync("product1", false); if (licenseInformation.ProductLicenses["product1"].IsActive) { rootPage.NotifyUser("You bought Product 1.", NotifyType.StatusMessage); } else { rootPage.NotifyUser("", NotifyType.StatusMessage); } } catch (Exception) { rootPage.NotifyUser("Unable to buy Product 1.", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("You already own Product 1.", NotifyType.ErrorMessage); } }
public static async Task <Boolean> Purchase() { try { #if DEBUG await CurrentAppSimulator.RequestAppPurchaseAsync(false); #else await CurrentApp.RequestAppPurchaseAsync(false); #endif if (!IsTrial()) { ResourceLoader _res = ResourceLoader.GetForCurrentView(); MessageDialog messageDialog = new MessageDialog(_res.GetString("VersionFull"), _res.GetString("ThanksPurchase")); messageDialog.Commands.Add(new UICommand("Ok", (command) => { })); messageDialog.CancelCommandIndex = 0; messageDialog.DefaultCommandIndex = 0; await messageDialog.ShowAsync(); return(true); } else { return(false); } } catch (Exception) { return(false); } }
private async Task BuyProductAsync(string productId, string productName) { LicenseInformation licenseInformation = CurrentAppSimulator.LicenseInformation; if (!licenseInformation.ProductLicenses[productId].IsActive) { rootPage.NotifyUser("Buying " + productName + "...", NotifyType.StatusMessage); try { await CurrentAppSimulator.RequestProductPurchaseAsync(productId); if (licenseInformation.ProductLicenses[productId].IsActive) { rootPage.NotifyUser("You bought " + productName + ".", NotifyType.StatusMessage); } else { rootPage.NotifyUser(productName + " was not purchased.", NotifyType.StatusMessage); } } catch (Exception) { rootPage.NotifyUser("Unable to buy " + productName + ".", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("You already own " + productName + ".", NotifyType.ErrorMessage); } }
private async void BuyButton_Click(object sender, RoutedEventArgs e) { var proxyFolder = await Package.Current.InstalledLocation.GetFolderAsync("Assets"); var proxyFile = await proxyFolder.GetFileAsync("WindowsStoreProxy.xml"); await CurrentAppSimulator.ReloadSimulatorAsync(proxyFile); try { var listing = await CurrentAppSimulator.LoadListingInformationAsync(); var product = listing.ProductListings["product1"]; var results = await CurrentAppSimulator.RequestProductPurchaseAsync("product1"); if (results.Status == ProductPurchaseStatus.Succeeded) { VKAppPlatform.Instance.ReportInAppPurchase(new VKAppPlatform.InAppPurchaseData(results.ReceiptXml, product.FormattedPrice)); } } catch (Exception exc) { /* Handle exception */ } }
internal async void GetPrice() { try { #if DEBUG ListingInformation listing = await CurrentAppSimulator.LoadListingInformationAsync(); #else ListingInformation listing = await CurrentApp.LoadListingInformationAsync(); #endif List <string> ps = new List <string>(); foreach (var item in DonationPack) { var product = listing.ProductListings[item]; ps.Add(product.FormattedPrice); } Price = ps.ToArray(); licenseChangeHandler = new LicenseChangedEventHandler(licenseChangedEventHandler); #if DEBUG CurrentAppSimulator.LicenseInformation.LicenseChanged += licenseChangeHandler; #else CurrentApp.LicenseInformation.LicenseChanged += licenseChangeHandler; #endif } catch (Exception) { Price = null; } }
public static async void LoadAddons() { StorageFolder proxyDataFolder = await Package.Current.InstalledLocation.GetFolderAsync("Assets"); StorageFile proxyFile = await proxyDataFolder.GetFileAsync("test.xml"); await CurrentAppSimulator.ReloadSimulatorAsync(proxyFile); //TODO if (App.AppLicenseInformation.ProductLicenses[catsPackageToken].IsActive) { var collection = await CreateAddonCollectionAsync("Cats").ConfigureAwait(true); App.PurchaseCollections.Add(collection); } if (App.AppLicenseInformation.ProductLicenses[mountainsPackageToken].IsActive) { var collection = await CreateAddonCollectionAsync("Mountains").ConfigureAwait(true); App.PurchaseCollections.Add(collection); } if (App.AppLicenseInformation.ProductLicenses[spacePackageToken].IsActive) { var collection = await CreateAddonCollectionAsync("Space").ConfigureAwait(true); App.PurchaseCollections.Add(collection); } if (App.AppLicenseInformation.ProductLicenses[sunsetsPackageToken].IsActive) { var collection = await CreateAddonCollectionAsync("Sunsets").ConfigureAwait(true); App.PurchaseCollections.Add(collection); } }
private async void BuyProduct2Button_Click(object sender, RoutedEventArgs e) { Log("Buying Product 2...", NotifyType.StatusMessage); try { PurchaseResults purchaseResults = await CurrentAppSimulator.RequestProductPurchaseAsync("product2"); switch (purchaseResults.Status) { case ProductPurchaseStatus.Succeeded: product2NumPurchases++; product2TempTransactionId = purchaseResults.TransactionId; Log("You bought product 2. Transaction Id: " + purchaseResults.TransactionId, NotifyType.StatusMessage); // Normally you would grant the user their content here, and then call currentApp.reportConsumableFulfillment break; case ProductPurchaseStatus.NotFulfilled: product2TempTransactionId = purchaseResults.TransactionId; Log("You have an unfulfilled copy of product 2. Hit \"Fulfill product 2\" before you can purchase a second copy.", NotifyType.StatusMessage); // Normally you would grant the user their content here, and then call currentApp.reportConsumableFulfillment break; case ProductPurchaseStatus.NotPurchased: Log("Product 2 was not purchased.", NotifyType.StatusMessage); break; } } catch (Exception) { Log("Unable to buy Product 2.", NotifyType.ErrorMessage); } }