Class TInAppPurchases

Warning: this symbol is deprecated: use RefreshedPrices or RefreshedPurchases

Called when the knowledge about what do we own is complete.

See OnRefreshedPrices for information when is this called. The default implementation of this method in this class just calls OnRefreshedPrices.

See OnRefreshedPurchases for information when is this called. The default implementation of this method in this class just calls OnRefreshedPurchases.

Called when the product is successfully consumed, in response to the Consume call.

In this class, this simply sets Product.SuccessfullyConsumed flag to True, and waits for some other code (maybe overridden SuccessfullyConsumed implementation, maybe something else) will handle it and reset the Product.SuccessfullyConsumed flag to False.

Called when we know the product is owned, in particular when it's successfully bought.

If the product is not consumable (which means that it can be owned only once, and it's owned forever once bought): Note that this method may be called multiple times, because there are various situations in which we may "gain knowledge" that user owns this item (e.g. each RefreshPurchases call). Write your code to react gracefullly to this, such that calling this method on an already-owned item is handled correctly.

E.g. if you increase some stat (e.g. "gold owned") when user buys a "chest of gold", and "chest of gold" is non-consumable (you can only own it once, and then you just own it forever), then store the fact that you "already increased gold because of the chest ownership" in the user persistent data (see https://castle-engine.io/manual_user_prefs.php). Do not just increase the "gold owned" at every call of this method.

If the product is a consumable, which means it has a one-time use (and should disappear afterwards, until user will buy it again), then:

1. Call the Consume method once you know the item is owned. You can call Consume directly from the overridden implementation of Owns, this is often the simplest approach.

2. Actually perform the consumption (bump the player gold, grant extra life and so on) only when the item is successfully consumed. You are notified about this by the SuccessfullyConsumed call (you can override it), or you can watch if the TInAppProduct.SuccessfullyConsumed flag is set.

   Do not give any one-time gain as a response to the Owns call. Always wait for SuccessfullyConsumed call.

   This protects you from the scenario when you're notified that you own the item multiple times (which may happen, since purchases may be resumed asynchronously while other code is executing), and you call Consume twice. The SuccessfullyConsumed will only fire once, if user bought item once.

Initialize a list of products for which to query prices from server. The overloaded version with TAvailableProduct allows to provide additional information to the in-app payment system, see TAvailableProduct docs.

Initiate a purchase of given item.

Initiate a consumption of a consumable item. You should listen on a "successful consumption" (override SuccessfullyConsumed method and/or watch TInAppProduct.SuccessfullyConsumed) until you actually act on the consumption (increase player gold or such).

Find product with given name.

Creates and adds new product, if not found (useful in case you asked for a product before information about it arrived from the net, or before you even called SetAvailableProducts with it).

Call to refresh the state of owned (purchased) items from server. This will call Owns on the owned items, and then RefreshedPurchases or OnRefreshedPurchases.

This is necessary to be called explicitly on iOS (for AppStore), as it will ask user to login to AppStore. On Android, this is done automatically at app start, and doesn't ask user anything.

For debug purposes, immediately set all TInAppProduct.Owns to False. This does not reset any persistent knowledge about the ownership of the items of course, it merely resets the temporary (in CGE) knowledge about what is owned. If the purchases communicate with any store (Google Play on Android, AppStore on iOS) then the purchases will be restored next time the RefreshPurchases are done.

Purely for debug purposes, mockup buying (pretend that all purchases succeed).

Called when the prices (and other shop-related information) are known about the products. The information is stored inside TInAppProduct instances, e.g. query TInAppProduct.Price, TInAppProduct.Title and so on. Get the TInAppProduct instance by Product method.

This signals that we queried the shop for the product information like TInAppProduct.Price and TInAppProduct.Title and TInAppProduct.Description. This is automatically done always when launching the application, and sometimes later too.

It does not mean that we have queried the ownership status of the products, for this see OnRefreshedPurchases.

See also RefreshedPrices method. Instead of assigning this event, you can also override RefreshedPrices method in descendants.

Called when the ownership status of all products is known. The information is stored inside TInAppProduct.Owns, you can get the TInAppProduct instance using the Product method.

The ownership status is automatically queried when the application starts on Android. On iOS, it must be explicitly invoked using RefreshPurchases (this is a limitation of iOS user-interface around this, so it cannot be hidden / workarounded by us).