Android IAP Restore Purchases Not Happening

I’m using Unity 5.4.2 with Unity’s IAP plugin (nothing third party).

These IAP’s have always worked fine. Two days ago I released an update that adds an additional level for purchase. Numerous users are now complaining that they have lost their earlier purchases. I tell them to uninstall and reinstall the app. This works for some, but I’m still seeing numerous fresh complaint reviews.

I understand that the Unity IAP automatically restores any products the user owns during the first initialization following reinstallation; the ProcessPurchase method of the IStoreListener is called for each owned item.

Why is does this only work “sometimes”? I have the latest Unity IAP 1.9.3 installed.

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Purchasing;

	// Deriving the Purchaser class from IStoreListener enables it to receive messages from Unity Purchasing.
	public class Purchaser : MonoBehaviour, IStoreListener{
	
		//these are links to the button gameObjects
		public GameObject TorontoIsland_buy;
		public GameObject RockyMountain_buy;
		public GameObject LaGuardia_buy;
		public GameObject Vancouver_buy;
		public GameObject Castlegar_buy;
		public GameObject RestorePurchasesButton;
		public GameObject pleaseWaitText;

		private static IStoreController m_StoreController;                                                                  // Reference to the Purchasing system.
		private static IExtensionProvider m_StoreExtensionProvider;                                                         // Reference to store-specific Purchasing subsystems.

		// Product identifiers for all products capable of being purchased: "convenience" general identifiers for use with Purchasing, and their store-specific identifier counterparts 
		// for use with and outside of Unity Purchasing. Define store-specific identifiers also on each platform's publisher dashboard (iTunes Connect, Google Play Developer Console, etc.)
		
		private static string toronto_island = "toronto_island";                                                        
		private static string rocky_mountain = "rocky_mountain";                                                 
		private static string laguardia =  "laguardia";                                                 
		private static string vancouver =  "vancouver"; 
		private static string castlegar =  "castlegar"; 

		private static string iOS_toronto_island = "com.mpdigital.ios_airportmadness3d_toronto_island_b"; 
		private static string iOS_rocky_mountain = "com.mpdigital.ios_airportmadness3d_rocky_mountain_b"; 
		private static string iOS_laguardia = "com.mpdigital.ios_airportmadness3d_laguardia_b"; 
		private static string iOS_vancouver = "com.mpdigital.ios_airportmadness3d_vancouver_b"; 
		private static string iOS_castlegar = "com.mpdigital.ios_airportmadness3d_castlegar_b"; 

		private static string mac_toronto_island = "com.mpdigital.ios_airportmadness3d_toronto_island_b"; 
		private static string mac_rocky_mountain = "com.mpdigital.ios_airportmadness3d_rocky_mountain_b"; 
		private static string mac_laguardia = "com.mpdigital.ios_airportmadness3d_laguardia_b"; 
		private static string mac_vancouver = "com.mpdigital.ios_airportmadness3d_vancouver_b";
		private static string mac_castlegar = "com.mpdigital.ios_airportmadness3d_castlegar_b"; 

		private static string android_toronto_island = "com.mpdigital.android_airportmadness3d_toronto_island"; 
		private static string android_rocky_mountain = "com.mpdigital.android_airportmadness3d_rocky_mountain"; 
		private static string android_laguardia = "com.mpdigital.android_airportmadness3d_laguardia";
		private static string android_vancouver = "com.mpdigital.android_airportmadness3d_vancouver";
		private static string android_castlegar = "com.mpdigital.android_airportmadness3d_castlegar";

		//private static string kProductIDConsumable =    "consumable";                                                         // General handle for the consumable product.
		//private static string kProductIDNonConsumable = "nonconsumable";                                                  // General handle for the non-consumable product.
		//private static string kProductIDSubscription =  "subscription";                                                   // General handle for the subscription product.

		//private static string kProductNameAppleConsumable =    "com.unity3d.test.services.purchasing.consumable";             // Apple App Store identifier for the consumable product.
		//private static string kProductNameAppleNonConsumable = "com.unity3d.test.services.purchasing.nonconsumable";      // Apple App Store identifier for the non-consumable product.
		//private static string kProductNameAppleSubscription =  "com.unity3d.test.services.purchasing.subscription";       // Apple App Store identifier for the subscription product.

		//private static string kProductNameGooglePlayConsumable =    "com.unity3d.test.services.purchasing.consumable";        // Google Play Store identifier for the consumable product.
		//private static string kProductNameGooglePlayNonConsumable = "com.unity3d.test.services.purchasing.nonconsumable";     // Google Play Store identifier for the non-consumable product.
		//private static string kProductNameGooglePlaySubscription =  "com.unity3d.test.services.purchasing.subscription";  // Google Play Store identifier for the subscription product.

    void checkForUnlockedLevels(){
		Debug.Log("check on android");
        if(PlayerPrefs.GetInt("playerOwns_TorontoIsland")==1){
			if(TorontoIsland_buy != null){
           	 	TorontoIsland_buy.SetActive(false);
			}
        }
        if(PlayerPrefs.GetInt("playerOwns_RockyMountain")==1){
			if(RockyMountain_buy != null){
            	RockyMountain_buy.SetActive(false);
			}
        }
        if(PlayerPrefs.GetInt("playerOwns_LaGuardia")==1){
			if(LaGuardia_buy != null){
            	LaGuardia_buy.SetActive(false);
			}
        }
        if(PlayerPrefs.GetInt("playerOwns_Vancouver")==1){
			if(Vancouver_buy != null){
            	Vancouver_buy.SetActive(false);
			}
        }
        if(PlayerPrefs.GetInt("playerOwns_Castlegar")==1){
			if(Castlegar_buy != null){
            	Castlegar_buy.SetActive(false);
			}
        }
		if(pleaseWaitText != null){
			Debug.Log("pleaseWaitText.SetActive(false)");
			pleaseWaitText.SetActive(false);
		}
    }
		void Start(){
			//hide the loader wheel, and add it after clicking any "buy" button or the "restore purchases" button, until response comes back
			pleaseWaitText.SetActive(false);

        	checkForUnlockedLevels();

			//if everything is unlocked, hide the 'restore purchases' button
			if(PlayerPrefs.GetInt("playerOwns_TorontoIsland")==1 && PlayerPrefs.GetInt("playerOwns_RockyMountain")==1 && PlayerPrefs.GetInt("playerOwns_LaGuardia")==1 
				&& PlayerPrefs.GetInt("playerOwns_Vancouver")==1 && PlayerPrefs.GetInt("playerOwns_Castlegar")==1){
				RestorePurchasesButton.SetActive(false);
			}

			// If we haven't set up the Unity Purchasing reference
			if (m_StoreController == null)
			{
				// Begin to configure our connection to Purchasing
				InitializePurchasing();
			}
		}

		public void InitializePurchasing() {
			// If we have already connected to Purchasing ...
			if (IsInitialized()){
				// ... we are done here.
				return;
			}

			// Create a builder, first passing in a suite of Unity provided stores.
			var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());

			builder.AddProduct(toronto_island, ProductType.NonConsumable, new IDs(){{ mac_toronto_island, AppleAppStore.Name },{ android_toronto_island,  GooglePlay.Name },});
			builder.AddProduct(rocky_mountain, ProductType.NonConsumable, new IDs(){{ mac_rocky_mountain, AppleAppStore.Name },{ android_rocky_mountain, GooglePlay.Name },});
			builder.AddProduct(laguardia, ProductType.NonConsumable, new IDs(){{ mac_laguardia, AppleAppStore.Name },{ android_laguardia, GooglePlay.Name },});
			builder.AddProduct(vancouver, ProductType.NonConsumable, new IDs(){{ mac_vancouver, AppleAppStore.Name },{ android_vancouver, GooglePlay.Name },});
			builder.AddProduct(castlegar, ProductType.NonConsumable, new IDs(){{ mac_castlegar, AppleAppStore.Name },{ android_castlegar, GooglePlay.Name },});

			// Add a product to sell / restore by way of its identifier, associating the general identifier with its store-specific identifiers.
			//builder.AddProduct(kProductIDConsumable, ProductType.Consumable, new IDs(){{ kProductNameAppleConsumable, AppleAppStore.Name },{ kProductNameGooglePlayConsumable, GooglePlay.Name },});
			//builder.AddProduct(kProductIDNonConsumable, ProductType.NonConsumable, new IDs(){{ kProductNameAppleNonConsumable,       AppleAppStore.Name },{ kProductNameGooglePlayNonConsumable,  GooglePlay.Name },});// And finish adding the subscription product.
			//builder.AddProduct(kProductIDSubscription, ProductType.Subscription, new IDs(){{ kProductNameAppleSubscription,       AppleAppStore.Name },{ kProductNameGooglePlaySubscription,  GooglePlay.Name },});// Kick off the remainder of the set-up with an asynchrounous call, passing the configuration and this class' instance. Expect a response either in OnInitialized or OnInitializeFailed.
			UnityPurchasing.Initialize(this, builder);
		}
		
		private bool IsInitialized(){
			// Only say we are initialized if both the Purchasing references are set.
			return m_StoreController != null && m_StoreExtensionProvider != null;
		}
		

		public void Buy_toronto_island(){
			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
			BuyProductID(toronto_island);
			
		}
		public void Buy_rocky_mountain(){
			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
			BuyProductID(rocky_mountain);
			
		}
		public void Buy_laguardia(){
			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
			BuyProductID(laguardia);
			
		}
		public void Buy_vancouver(){
			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
			BuyProductID(vancouver);
			
		}
		public void Buy_castlegar(){
			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
			BuyProductID(castlegar);
			
		}

//		public void BuyConsumable(){
//			// Buy the consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
//			BuyProductID(kProductIDConsumable);
//		}
//		public void BuyNonConsumable(){
//			// Buy the non-consumable product using its general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
//			BuyProductID(kProductIDNonConsumable);
//		}
//		public void BuySubscription(){
//			// Buy the subscription product using its the general identifier. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
//			BuyProductID(kProductIDSubscription);
//		}

		void BuyProductID(string productId){

			try{
				if(pleaseWaitText != null){
					Debug.Log("pleaseWaitText.SetActive(true)");
					pleaseWaitText.SetActive(true);
				}
			}
			catch (Exception e){
			}

			// If the stores throw an unexpected exception, use try..catch to protect my logic here.
			try{
				// If Purchasing has been initialized ...
				if (IsInitialized()){
					// ... look up the Product reference with the general product identifier and the Purchasing system's products collection.
					Product product = m_StoreController.products.WithID(productId);

					// If the look up found a product for this device's store and that product is ready to be sold ... 
					if (product != null && product.availableToPurchase){
						Debug.Log (string.Format("Purchasing product asychronously: '{0}'", product.definition.id));// ... buy the product. Expect a response either through ProcessPurchase or OnPurchaseFailed asynchronously.
						m_StoreController.InitiatePurchase(product);
					}
					// Otherwise ...
					else{
						// ... report the product look-up failure situation  
						Debug.Log ("BuyProductID: FAIL. Not purchasing product, either is not found or is not available for purchase");
					}
				}
				// Otherwise ...
				else{
					// ... report the fact Purchasing has not succeeded initializing yet. Consider waiting longer or retrying initiailization.
					Debug.Log("BuyProductID FAIL. Not initialized.");
				}
			}
			// Complete the unexpected exception handling ...
			catch (Exception e){
				// ... by reporting any unexpected exception for later diagnosis.
				Debug.Log ("BuyProductID: FAIL. Exception during purchase. " + e);
			}
		}
		
		// Restore purchases previously made by this customer. Some platforms automatically restore purchases. Apple currently requires explicit purchase restoration for IAP.
		public void RestorePurchases(){
			// If Purchasing has not yet been set up ...
			if (!IsInitialized()){
				// ... report the situation and stop restoring. Consider either waiting longer, or retrying initialization.
				Debug.Log("RestorePurchases FAIL. Not initialized.");
				return;
			}

			// If we are running on an Apple device ... 
			if (Application.platform == RuntimePlatform.IPhonePlayer || Application.platform == RuntimePlatform.OSXPlayer){
				// ... begin restoring purchases
				Debug.Log("RestorePurchases started ...");

				// Fetch the Apple store-specific subsystem.
				var apple = m_StoreExtensionProvider.GetExtension<IAppleExtensions>();
				// Begin the asynchronous process of restoring purchases. Expect a confirmation response in the Action<bool> below, and ProcessPurchase if there are previously purchased products to restore.
				apple.RestoreTransactions((result) => {
					// The first phase of restoration. If no more responses are received on ProcessPurchase then no purchases are available to be restored.
					Debug.Log("RestorePurchases continuing: " + result + ". If no further messages, no purchases available to restore.");
				});
			}
			// Otherwise ...
			else{
				// We are not running on an Apple device. No work is necessary to restore purchases.
				Debug.Log("RestorePurchases FAIL. Not supported on this platform. Current = " + Application.platform);
			}
			if(pleaseWaitText != null){
				pleaseWaitText.SetActive(true);
			}
		}


		//  
		// --- IStoreListener
		//

		public void OnInitialized(IStoreController controller, IExtensionProvider extensions){
			// Purchasing has succeeded initializing. Collect our Purchasing references.
			Debug.Log("OnInitialized: PASS");

			// Overall Purchasing system, configured with products for this application.
			m_StoreController = controller;
			// Store specific subsystem, for accessing device-specific store features.
			m_StoreExtensionProvider = extensions;
		}

		public void OnInitializeFailed(InitializationFailureReason error){
			// Purchasing set-up has not succeeded. Check error for reason. Consider sharing this reason with the user.
			Debug.Log("OnInitializeFailed InitializationFailureReason:" + error);
		}

	public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs args) {
		if (String.Equals(args.purchasedProduct.definition.id, toronto_island, StringComparison.Ordinal)){
			PlayerPrefs.SetInt("playerOwns_TorontoIsland", 1);
			TorontoIsland_buy.SetActive(false);
			Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));//If the consumable item has been successfully purchased, add 100 coins to the player's in-game score.
		}else if (String.Equals(args.purchasedProduct.definition.id, rocky_mountain, StringComparison.Ordinal)){
			PlayerPrefs.SetInt("playerOwns_RockyMountain", 1);
			RockyMountain_buy.SetActive(false);
			Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));}// Or ... a subscription product has been purchased by this user.
		else if (String.Equals(args.purchasedProduct.definition.id, laguardia, StringComparison.Ordinal)){
			PlayerPrefs.SetInt("playerOwns_LaGuardia", 1);
			LaGuardia_buy.SetActive(false);
			Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));}// Or ... an unknown product has been purchased by this user. Fill in additional products here.
		else if (String.Equals(args.purchasedProduct.definition.id, vancouver, StringComparison.Ordinal)){
			PlayerPrefs.SetInt("playerOwns_Vancouver", 1);
			Vancouver_buy.SetActive(false);
			Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));}// Or ... an unknown product has been purchased by this user. Fill in additional products here.
		else if (String.Equals(args.purchasedProduct.definition.id, castlegar, StringComparison.Ordinal)){
			PlayerPrefs.SetInt("playerOwns_Castlegar", 1);
			Castlegar_buy.SetActive(false);
			Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));}// Or ... an unknown product has been purchased by this user. Fill in additional products here.
		else{
			Debug.Log(string.Format("ProcessPurchase: FAIL. Unrecognized product: '{0}'", args.purchasedProduct.definition.id));}// Return a flag indicating wither this product has completely been received, or if the application needs to be reminded of this purchase at next app launch. Is useful when saving purchased products to the cloud, and when that save is delayed.
        checkForUnlockedLevels();
        return PurchaseProcessingResult.Complete;
	}
		
		public void OnPurchaseFailed(Product product, PurchaseFailureReason failureReason){
			// A product purchase attempt did not succeed. Check failureReason for more detail. Consider sharing this reason with the user.
			Debug.Log(string.Format("OnPurchaseFailed: FAIL. Product: '{0}', PurchaseFailureReason: {1}",product.definition.storeSpecificId, failureReason));
		}
	}

I created a brand new Google Play account, and tested my purchase system across two android devices with no issues. I confirmed that a couple of the complaints were from users who are now using different Google Play email accounts from when they first purchased the game levels.

I now suspect that these recent complaints are from users who are using a different Google Play account, or the 1% of users who are just having bad luck. I’ve put a statement in my update description, informing people of this known issue, and offering them my help email. I’ll give refunds to those who request them.

It really sucks spending months building an update, only to get your store rating tarnished :frowning:

It is happening to me with my own account (I have really bought my item, not with a test account), and I cannot find how to restore after reinstalling the app or on other device… I don’t know why!

That’s so frustrating.