Validation

Overview

The purchase validation/verification process ensures that in-app purchases and subscriptions are validated on the server. This process involves sending purchase records to the server and processing the server's response to determine the validity of the purchase. The Magify server on its side contacts GooglePlay / AppStore to validate the purchase.

Types of validation

Depending on the needs of your project, your application can work in two modes of purchase validation: "passive" and "active". The key difference is that in "active" validation, the application is directly involved in and can influence the purchase validation process.

"Passive" validation

In this case, you are not required to do anything additional. The normal mode of operation looks like this:

• Store notifies the app when a purchase has been made;
• The purchase data is collected and passed to the SDK for processing;
• The SDK generates request and send it to the server;
• The SDK will handle all errors itself and retry requests if necessary;
• SDK will not notify about the validity of the purchase in any way.

This mode is active by default and you can stop here if you don't care that the user is rewarded only for real purchases, but only that the analytics are correct.

"Active" validation

In this case, you can handle Magify SDK's responses about the validity of the purchase yourself and thus only provide the player with rewards for real purchases.

To control the verification process it is necessary to implement the interface:

interface IPurchaseVerificationHandler
{
    RepeatState? HandlePurchaseVerification(PurchaseVerificationResult result);
}

There are some peculiarities when implementing the interface:

• As input, you get an instance of PurchaseVerificationResult, which stores information about the verified purchase, as well as a Code field representing the result of the last verification attempt:
  • Fail - verification attempt failed for an undetermined reason;
  • Success - verification successful, purchase VALID;
  • DoesntSupport - Purchase verification is not supported in this application (validator is not configured);
  • Invalid - verification successful, purchase INVALID;
  • InvalidGoogleCredentials - incorrect credentials for Google Play are given in the validator;
• You're returning an instance RepeatState:
  • Finish - if you want to stop attempting to verify your purchase;
  • Retry - if you want to immediately retry the verification attempt;
  • Wait - if you want to wait before retrying verification (currently the waiting time is constant at 60 seconds of real time, this part may change, then the documentation will be updated);
  • null - you leave it up to the SDK to decide how to handle the current verification attempt result;
• You should return null or Finish in case PurchaseVerificationResult.Code is Invalid or Success, because in such a situation SDK will work as if you had returned Finish for these values anyway;
• During processing, you can notify your game systems of the success/failure of the validation of the purchase.

Example of using "active" validation

First of all, you should implement the interface IPurchaseVerificationHandler:

public class ExamplePurchaseVerificationHandler : IPurchaseVerificationHandler
{
    public RepeatState? HandlePurchaseVerification(PurchaseVerificationResult result)
    {
        return result.Code switch
        {
            PurchaseVerificationResultCode.Fail => RepeatState.Retry,
            PurchaseVerificationResultCode.DoesntSupport => RepeatState.Finish,
            PurchaseVerificationResultCode.InvalidGoogleCredentials => RepeatState.Wait,
            _ => null,
        };
    }
}

In this implementation, let's assume that you decide to take this approach:

• If the result was Fail, we will immediately retry, because it is critical that the processing goes as fast as possible and we don't want to wait for some time until the next attempt in case of a connection failure.
• If the result was DoesntSupport, then there is no point in further attempts because the application does not support validation of purchases.
• If the result was InvalidGoogleCredentials, you can assume that this is some temporary problem in the configuration, you will soon fix the credentials and validation will work.

Next, you can add a callback that will be triggered when Invalid or Success is received, which other systems in the game can subscribe to:

public delegate void ProductVerificationFinishedDelegate(string productId, bool isValid);

public class ExamplePurchaseVerificationHandler : IPurchaseVerificationHandler
{
    public event ProductVerificationFinishedDelegate OnProductVerificationFinished;

    public RepeatState? HandlePurchaseVerification(PurchaseVerificationResult result)
    {
        switch (result.Code)
        {
            case PurchaseVerificationResultCode.Success:
                OnProductVerificationFinished?.Invoke(result.ProductId, isValid: true);
                return null; // == return RepeatState.Finish
            case PurchaseVerificationResultCode.Invalid:
                OnProductVerificationFinished?.Invoke(result.ProductId, isValid: false);
                return null; // == return RepeatState.Finish
        }

        return result.Code switch
        {
            PurchaseVerificationResultCode.Fail => RepeatState.Retry,
            PurchaseVerificationResultCode.DoesntSupport => RepeatState.Finish,
            PurchaseVerificationResultCode.InvalidGoogleCredentials => RepeatState.Wait,
            _ => null,
        };
    }
}