devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity接入GooglePlay内购V4 V5 V6(源生Android方式)_unity接入google内购

作者：Guff_9hys | 2024-07-18 09:08:50

赞

踩

unity接入google内购

20230825更新

因为谷歌新政策要求，目前需要支持V5 V6，更新也很简单，将下面的改成5.0或6.0的aar即可

implementation("com.android.billingclient:billing:4.0.0")

改成

implementation("com.android.billingclient:billing:5.0.0")

或

implementation("com.android.billingclient:billing:6.0.0")

代码都是兼容的，亲测有效

-------------------------------------------------------------------

Unity接GooglePlay In-App Billing坑还是蛮多的，各种坑。

接的方式目前来看有三种：

  1. 采用Unity IAP插件，开启Unity的IAP Service
  2. 采用Android源生接入，在Android Studio接入，然后打包出jar或aar放到Unity项目，使用Unity调用
  3. 打包出Android工程，在Android工程中接入

这次介绍的是第二种，使用安卓源生方式接入，因为该方式一劳永逸，新项目可以很快就完成接入。

为什么不用第一种呢？直接导入IAP插件，然后设置参数，就可以很快实现了，该方式可以直接参考google文档。

第一种IAP插件的缺点：

虽然该方式只需要导入插件，然后进行一些参数的设置，但是此方式特别麻烦的一点是需要在Unity中开启Service，但是开启后又得填一大堆信息，巨麻烦无比，而且Unity的网络简直不能看，要么是打不开，要么是卡半死，而且网站老变，以及没有完整的文档。这些都是很恶心人的事情，甚至还要创建组织啥的，反正谁用谁恶心。

----------------------------------分割线------------------------------------------------------------------------

正式接入

接入之前需要的储备知识是：Unity如何与Android交互

准备jar和aar

我们的目标是导出自己封装的jar（里面封装了接口供Unity调用，也就是桥接层），以及找到谷歌官方提供的Billing V4插件(aar)。

因为从2021.8.2起，谷歌要求必须接入V3版以上的插件。所以我们这次干脆接了最新的V4.

接入文档可以参考指南：从 AIDL 迁移到 Google Play 结算库的迁移指南

获取aar文件

  • 打开Android Studio，创建一个工程
  • 创建一个Module，创建完如下（Module要选择Library）
  • 打开build.gradle，修改导出为Library，在dependencies中添加依赖，并同步。 
    1. implementation("com.android.billingclient:billing:4.0.0")
    2. 注意：plugins这边要改为'com.android.library'，导出才会是aar，否则是apk.
    1. plugins {
    2.     id 'com.android.library'
    3. }
    4.  
    5. android {
    6.     compileSdkVersion 30
    7.  
    8.     defaultConfig {
    9.         //applicationId "com.egogame.iapforgoogleplay"
    10.         minSdkVersion 19
    11.         targetSdkVersion 30
    12.         versionCode 1
    13.         versionName "1.0"
    14.  
    15.         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    16.     }
    17.  
    18.     buildTypes {
    19.         release {
    20.             minifyEnabled false
    21.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    22.         }
    23.     }
    24.     compileOptions {
    25.         sourceCompatibility JavaVersion.VERSION_1_8
    26.         targetCompatibility JavaVersion.VERSION_1_8
    27.     }
    28. }
    29.  
    30. dependencies {
    31.  
    32.     implementation 'androidx.appcompat:appcompat:1.3.0'
    33.     implementation 'com.google.android.material:material:1.3.0'
    34.     implementation 'org.jetbrains:annotations:15.0'
    35.     testImplementation 'junit:junit:4.+'
    36.     androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    37.     androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    38.  
    39.     implementation("com.android.billingclient:billing:4.0.0")
    40. }
  • 同步完成后，在gradle缓存路径下找到谷歌官方提供的.aar文件，复制到Unity工程Assets/Plugins/Android目录下，待用
    文件路径：C:\Users\xxx\.gradle\caches\modules-2\files-2.1\com.android.billingclient\billing\4.0.0\31aa58e2d4286f6b96480764e7a84d5de9935f02

打包jar 

  • 创建BaseMainActivity.java类，该类创建了一些供Unity调用的接口格式。
    当前类还未开始接入GP插件接口。 
    1. package com.egogame;
    2.  
    3. import java.lang.reflect.InvocationTargetException;
    4. import java.lang.reflect.Method;
    5. import java.util.ArrayList;
    6. import org.json.JSONArray;
    7. import org.json.JSONException;
    8. import org.json.JSONObject;
    9.  
    10. import android.app.Activity;
    11. import android.content.Context;
    12. import android.os.Bundle;
    13. import android.os.Handler;
    14. import android.os.Looper;
    15. import android.widget.Toast;
    16.  
    17.  
    18. public class BaseMainActivity{
    19. 	public static String UNITY_GO_NAME="IAP";
    20. 	public static final String LOG_TAG = "EgoGameLog";
    21.  
    22. 	protected Handler uiHandler = new Handler(Looper.getMainLooper());
    23.  
    24. 	//unity项目启动时的上下文
    25. 	private Activity unityActivity;
    26. 	private Context context;
    27.     
    28.     public void Init(final String goName,final String googlePlayPublicKey){
    29. 		PrintLog("Init："+goName+"===="+googlePlayPublicKey);
    30. 		uiHandler.post(new Runnable() {
    31.  
    32. 			@Override
    33. 			public void run() {
    34. 				UNITY_GO_NAME=goName;
    35. 				OnInitHandle(googlePlayPublicKey);
    36. 			}
    37. 		});
    38. 	}
    39.     
    40.     public void PrintLog(final String message,final Boolean toast){
    41. 		android.util.Log.d(LOG_TAG, message);
    42.     	uiHandler.post(new Runnable() {
    43. 			@Override
    44. 			public void run() {
    45. 				if(toast) Toast.makeText(getActivity(), message, Toast.LENGTH_LONG).show();
    46. 			}
    47. 		});
    48. 	}
    49. 	
    50.     public boolean IsIAPSupported(){
    51. 		return false;
    52. 	}
    53.  
    54. 	final public void RequstProduct(final String idsJson){
    55. 		uiHandler.post(new Runnable() {
    56.  
    57. 			@Override
    58. 			public void run() {
    59. 				String[] realProducts=null;
    60. 				try {
    61. 					JSONObject jObject=new JSONObject(idsJson);
    62. 					JSONArray jArray=jObject.getJSONArray("productIds");
    63. 					realProducts=new String[jArray.length()];
    64. 					for (int i = 0; i < jArray.length(); i++) {
    65. 						realProducts[i]=jArray.getString(i);
    66. 					}
    67. 				} catch (Exception e) {
    68. 					PrintLog("RequstProduct数据传输错误："+e.getMessage());
    69. 				}
    70. 				if(realProducts!=null){
    71. 					OnRequstProduct(realProducts);
    72. 				}else{
    73. 					RequestProductsFail("数据解析错误："+idsJson);
    74. 				}
    75. 			}
    76. 		});
    77. 	}
    78.  
    79. 	final public void BuyProduct(final String productJson){
    80. 		uiHandler.post(new Runnable() {
    81.  
    82. 			@Override
    83. 			public void run() {
    84. 				try {
    85. 					JSONObject jObject=new JSONObject(productJson);
    86. 					String productId=jObject.getString("productId");
    87. 					boolean isConsumable=jObject.getBoolean("isConsumable");
    88. 					
    89. 					OnBuyProduct(productId,isConsumable);
    90. 				} catch (Exception e) {
    91. 					PrintLog("BuyProduct数据传输错误："+e.getMessage());
    92. 				}
    93. 			}
    94. 		});
    95. 	}
    96. 	
    97. 	protected void OnInitHandle(String googlePlayPublicKey){
    98. 	}
    99.  
    100. 	protected void OnRequstProduct(String[] productId){
    101. 	}
    102. 	protected void OnBuyProduct(String productId,boolean isConsumable){
    103. 	}
    104. 	
    105. 	protected void BuyComplete(String productId){
    106. 		PrintLog("购买成功："+productId);
    107. 		SendUnityMessage("ProductBuyComplete", productId);
    108. 	}
    109. 	
    110. 	protected void BuyCancle(String productId){
    111. 		PrintLog("购买取消："+productId);
    112. 		SendUnityMessage("ProductBuyCancled", productId);
    113. 	}
    114. 	
    115. 	protected void BuyFail(String productId,String error){
    116. 		PrintLog("购买失败："+productId+"原因："+error);
    117. 		try {
    118. 			JSONObject jObject=new JSONObject();
    119. 			jObject.put("productId", productId);
    120. 			jObject.put("error", error);
    121. 			SendUnityMessage("ProductBuyFailed", jObject.toString());
    122. 		} catch (JSONException e) {
    123. 			PrintLog("BuyFail数据错误："+e.getMessage());
    124. 		}
    125. 	}
    126. 	
    127. 	protected void RequestProductsFail(String message){
    128. 		SendUnityMessage("ProductRequestFail", message);
    129. 	}
    130. 	
    131. 	protected void RecieveProductInfo(ArrayList<SkuItem> skuItems,ArrayList<String> invalidProductIds){
    132. 		JSONObject jsonObject=new JSONObject();
    133. 		try {
    134. 			JSONArray skuArray=new JSONArray();
    135. 			JSONObject tmpObj = null;
    136. 			for (int i = 0; i < skuItems.size(); i++) {
    137. 				SkuItem skuItem=skuItems.get(i);
    138. 				tmpObj = new JSONObject();
    139. 			    tmpObj.put("productId" , skuItem.productId);
    140. 			    tmpObj.put("title" , skuItem.title);
    141. 			    tmpObj.put("desc" , skuItem.desc);
    142. 			    tmpObj.put("price" , skuItem.price);
    143. 			    tmpObj.put("formatPrice" , skuItem.formatPrice);
    144. 			    tmpObj.put("priceCurrencyCode" , skuItem.priceCurrencyCode);
    145. 			    tmpObj.put("skuType" , skuItem.skuType);
    146. 			    skuArray.put(tmpObj);
    147. 			}
    148. 			
    149. 			JSONArray invalidArray=new JSONArray();
    150. 			for (int i = 0; i < invalidProductIds.size(); i++) {
    151. 				invalidArray.put(invalidProductIds.get(i));
    152. 			}
    153. 			jsonObject.put("skuItems", skuArray);
    154. 			jsonObject.put("invalidIds", invalidArray);
    155. 		} catch (JSONException e) {
    156. 			PrintLog("Json数据错误："+e.getMessage());
    157. 		}
    158. 		String info=jsonObject.toString();
    159. 		PrintLog("当前产品信息："+info);
    160. 		SendUnityMessage("RecieveProductInfos", info);
    161. 	}
    162.     
    163. 	public void PrintLog(String message){
    164. 		PrintLog(message,false);
    165. 	}
    166. 	
    167. 	public void SendUnityMessage(String func,String value){
    168. 		CallUnity(UNITY_GO_NAME, func, value);
    169. 	}
    170.  
    171. 	public Activity CurrentActivity(){
    172. 		return getActivity();
    173. 	}
    174.  
    175. 	/**
    176. 	 * Android调用Unity的方法
    177. 	 * @param gameObjectName    调用的GameObject的名称
    178. 	 * @param functionName      方法名
    179. 	 * @param args              参数
    180. 	 * @return                  调用是否成功
    181. 	 */
    182. 	boolean CallUnity(String gameObjectName, String functionName, String args){
    183. 		try {
    184. 			Class<?> classtype = Class.forName("com.unity3d.player.UnityPlayer");
    185. 			Method method =classtype.getMethod("UnitySendMessage", String.class,String.class,String.class);
    186. 			method.invoke(classtype,gameObjectName,functionName,args);
    187. 			return true;
    188. 		} catch (ClassNotFoundException e) {
    189. 			System.out.println(e.getMessage());
    190. 		} catch (NoSuchMethodException e) {
    191. 			System.out.println(e.getMessage());
    192. 		} catch (IllegalAccessException e) {
    193. 			System.out.println(e.getMessage());
    194. 		} catch (InvocationTargetException e) {
    195.  
    196. 		}
    197. 		return false;
    198. 	}
    199.  
    200. 	/**
    201. 	 * 利用反射机制获取unity项目的上下文
    202. 	 * @return
    203. 	 */
    204. 	Activity getActivity(){
    205. 		if(null == unityActivity) {
    206. 			try {
    207. 				Class<?> classtype = Class.forName("com.unity3d.player.UnityPlayer");
    208. 				Activity activity = (Activity) classtype.getDeclaredField("currentActivity").get(classtype);
    209. 				unityActivity = activity;
    210. 				context = activity;
    211. 			} catch (ClassNotFoundException e) {
    212. 				System.out.println(e.getMessage());
    213. 			} catch (IllegalAccessException e) {
    214. 				System.out.println(e.getMessage());
    215. 			} catch (NoSuchFieldException e) {
    216. 				System.out.println(e.getMessage());
    217. 			}
    218. 		}
    219. 		return unityActivity;
    220. 	}
    221. }
    222.  
    1. package com.egogame;
    2.  
    3. public class SkuItem {
    4. 	public String productId;
    5. 	public String title;
    6. 	public String desc;
    7. 	public String price;
    8. 	public String formatPrice;//格式化价格，包括其货币符号
    9. 	public String priceCurrencyCode;//货币代码
    10. 	public String skuType;//内购还是订阅
    11. }
  • 创建MainActivity类，开始接入billing插件（该命名为Activity其实没有继承Activity，因为继承Activity后，需要Unity那边AndroidManfiest文件指定为Activity才能生效，所以这里不采用继承Activity） 
    1. package com.egogame;
    2.  
    3. import android.os.Bundle;
    4. import android.os.Handler;
    5. import android.os.Looper;
    6. import android.text.TextUtils;
    7.  
    8. import androidx.annotation.NonNull;
    9. import androidx.annotation.Nullable;
    10.  
    11. import com.android.billingclient.api.BillingClient;
    12. import com.android.billingclient.api.BillingClientStateListener;
    13. import com.android.billingclient.api.BillingFlowParams;
    14. import com.android.billingclient.api.BillingResult;
    15. import com.android.billingclient.api.ConsumeParams;
    16. import com.android.billingclient.api.Purchase;
    17. import com.android.billingclient.api.PurchasesUpdatedListener;
    18. import com.android.billingclient.api.SkuDetails;
    19. import com.android.billingclient.api.SkuDetailsParams;
    20. import com.android.billingclient.api.SkuDetailsResponseListener;
    21.  
    22. import java.util.ArrayList;
    23. import java.util.Arrays;
    24. import java.util.HashMap;
    25. import java.util.List;
    26. import java.util.Map;
    27.  
    28. public class MainActivity extends BaseMainActivity implements PurchasesUpdatedListener,BillingClientStateListener {
    29.     private static final long RECONNECT_TIMER_START_MILLISECONDS = 1L * 1000L;
    30.     private static final long RECONNECT_TIMER_MAX_TIME_MILLISECONDS = 1000L * 60L * 15L; // 15 mins
    31.  
    32.     private static final Handler handler = new Handler(Looper.getMainLooper());
    33.     private BillingClient billingClient;
    34.     private String[] cacheRequestList;
    35.     private Map<String, SkuDetails> skuDetailsLiveDataMap=new HashMap<>();
    36.     private boolean isConsumable;
    37.     private String buyProductId;
    38.     private boolean billingSetupComplete = false;
    39.     // how long before the data source tries to reconnect to Google play
    40.     private long reconnectMilliseconds = RECONNECT_TIMER_START_MILLISECONDS;
    41.  
    42.     @Override
    43.     protected void OnInitHandle(String googlePlayPublicKey) {
    44.         super.OnInitHandle(googlePlayPublicKey);
    45.  
    46.         if (googlePlayPublicKey.contains("CONSTRUCT_YOUR")) {
    47.             throw new RuntimeException("Please put your app's public key in MainActivity.java. See README.");
    48.         }
    49.         billingClient = BillingClient.newBuilder(CurrentActivity()).setListener(this).enablePendingPurchases().build();
    50.         billingClient.startConnection(this);
    51.     }
    52.  
    53.     private void retryBillingServiceConnectionWithExponentialBackoff() {
    54.         handler.postDelayed(() ->
    55.                         billingClient.startConnection(this),
    56.                 reconnectMilliseconds);
    57.         reconnectMilliseconds = Math.min(reconnectMilliseconds * 2,
    58.                 RECONNECT_TIMER_MAX_TIME_MILLISECONDS);
    59.     }
    60.  
    61.     @Override
    62.     protected void OnRequstProduct(String[] productId) {
    63.         super.OnRequstProduct(productId);
    64.  
    65.         List<String> skuList = new ArrayList<>();
    66.         skuList.addAll(Arrays.asList(productId));
    67.         cacheRequestList=productId;
    68.         SkuDetailsParams.Builder params = SkuDetailsParams.newBuilder();
    69.         params.setSkusList(skuList).setType(BillingClient.SkuType.INAPP);
    70.         billingClient.querySkuDetailsAsync(params.build(),
    71.                 new SkuDetailsResponseListener() {
    72.                     @Override
    73.                     public void onSkuDetailsResponse(BillingResult billingResult,
    74.                                                      List<SkuDetails> skuDetailsList) {
    75.                         int responseCode = billingResult.getResponseCode();
    76.                         PrintLog("onSkuDetailsResponse:"+billingResult+" code:"+GetResponseText(responseCode));
    77.  
    78.                         switch (responseCode){
    79.                             case BillingClient.BillingResponseCode.OK:
    80.                                 RecieveProducts(skuDetailsList);
    81.                                 break;
    82.                             default:
    83.                                 RequestProductsFail("Failed to query inventory: " + billingResult.getDebugMessage());
    84.                                 PrintLog("Failed to query inventory: "+billingResult.getDebugMessage());
    85.                                 break;
    86.                         }
    87.                     }
    88.                 });
    89.     }
    90.  
    91.     private String GetResponseText(int responseCode){
    92.         switch (responseCode){
    93.             case BillingClient.BillingResponseCode.OK:
    94.                 return "OK";
    95.             case BillingClient.BillingResponseCode.SERVICE_TIMEOUT:
    96.                 return "SERVICE_TIMEOUT";
    97.             case BillingClient.BillingResponseCode.FEATURE_NOT_SUPPORTED:
    98.                 return "FEATURE_NOT_SUPPORTED";
    99.             case BillingClient.BillingResponseCode.USER_CANCELED:
    100.                 return "USER_CANCELED";
    101.             case BillingClient.BillingResponseCode.SERVICE_DISCONNECTED:
    102.                 return "SERVICE_DISCONNECTED";
    103.             case BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE:
    104.                 return "SERVICE_UNAVAILABLE";
    105.             case BillingClient.BillingResponseCode.BILLING_UNAVAILABLE:
    106.                 return "BILLING_UNAVAILABLE";
    107.             case BillingClient.BillingResponseCode.ITEM_UNAVAILABLE:
    108.                 return "ITEM_UNAVAILABLE";
    109.             case BillingClient.BillingResponseCode.DEVELOPER_ERROR:
    110.                 return "DEVELOPER_ERROR";
    111.             case BillingClient.BillingResponseCode.ERROR:
    112.                 return "ERROR";
    113.             case BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED:
    114.                 return "ITEM_ALREADY_OWNED";
    115.             case BillingClient.BillingResponseCode.ITEM_NOT_OWNED:
    116.                 return "ITEM_NOT_OWNED";
    117.             default:
    118.                 return "UnKnown";
    119.         }
    120.     }
    121.  
    122.     private void RecieveProducts(List<SkuDetails> skuDetailsList){
    123.         ArrayList<SkuItem> skuItems=new ArrayList<SkuItem>();
    124.         ArrayList<String> invaildIds=new ArrayList<String>();
    125.         PrintLog("cacheRequestList:"+cacheRequestList);
    126.         int length=cacheRequestList.length;
    127.         if(cacheRequestList!=null && length>0){
    128.             for(int i=0;i<length;i++){
    129.                 String productId=cacheRequestList[i];
    130.                 if(!TextUtils.isEmpty(productId)){
    131.                     SkuDetails detail=null;
    132.                     for (SkuDetails skuDetails : skuDetailsList) {
    133.                         if(skuDetails.getSku().equals(productId)){
    134.                             detail=skuDetails;
    135.                             break;
    136.                         }
    137.                     }
    138.  
    139.                     if(detail==null){
    140.                         PrintLog("未找到该产品信息:"+productId);
    141.                         invaildIds.add(productId);
    142.                         continue;
    143.                     }
    144.                     skuDetailsLiveDataMap.put(productId,detail);
    145.  
    146.                     String price=detail.getPrice();
    147.                     String formatPrice=price;
    148.  
    149.                     SkuItem skuItem=new SkuItem();
    150.                     skuItem.productId=productId;
    151.                     skuItem.title=detail.getTitle();
    152.                     skuItem.desc=detail.getDescription();
    153.                     skuItem.price=price;
    154.                     skuItem.formatPrice=formatPrice;
    155.                     skuItem.priceCurrencyCode=detail.getPriceCurrencyCode();
    156.                     skuItem.skuType=detail.getType();
    157.  
    158.                     skuItems.add(skuItem);
    159.                 }
    160.             }
    161.         }
    162.         RecieveProductInfo(skuItems,invaildIds);
    163.     }
    164.  
    165.     @Override
    166.     public boolean IsIAPSupported() {
    167.         return true;
    168.     }
    169.  
    170.     @Override
    171.     protected void OnBuyProduct(String productId, boolean isConsumable) {
    172.         super.OnBuyProduct(productId, isConsumable);
    173.  
    174.         SkuDetails skuDetails=skuDetailsLiveDataMap.get(productId);
    175.         if(null!=skuDetails){
    176.             buyProductId=productId;
    177.             this.isConsumable=isConsumable;
    178.  
    179.             BillingFlowParams purchaseParams =
    180.                     BillingFlowParams.newBuilder()
    181.                             .setSkuDetails(skuDetails)
    182.                             .build();
    183.  
    184.             billingClient.launchBillingFlow(CurrentActivity(), purchaseParams);
    185.         }else{
    186.             BuyFail(productId,"Can not find SkuDetails:"+productId);
    187.             PrintLog("未请求商品数据，请先请求:"+productId);
    188.         }
    189.     }
    190.  
    191.     @Override
    192.     public void onPurchasesUpdated(@NonNull BillingResult billingResult, @Nullable List<Purchase> list) {
    193.         int responseCode = billingResult.getResponseCode();
    194.  
    195.         PrintLog("BillingResult [" + GetResponseText(responseCode) + "]: "
    196.                 + billingResult.getDebugMessage());
    197.         switch (responseCode) {
    198.             case BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED:
    199.             case BillingClient.BillingResponseCode.OK:
    200.                 FlowFinish(true,null,list);
    201.                 break;
    202.             case BillingClient.BillingResponseCode.USER_CANCELED:
    203.                 String productId=buyProductId;
    204.                 buyProductId=null;
    205.                 BuyCancle(productId);
    206.                 break;
    207.             default:
    208.                 FlowFinish(false,billingResult.getDebugMessage(),list);
    209.                 break;
    210.         }
    211.     }
    212.  
    213.     private void FlowFinish(Boolean isSuccess,String message,List<Purchase> purchases){
    214.         if(isSuccess){
    215.             if(buyProductId!=null){
    216.                 String productId=buyProductId;
    217.                 buyProductId=null;
    218.                 String purchaseToken=null;
    219.                 for (Purchase purchase : purchases) {
    220.                     for (String skus : purchase.getSkus()) {
    221.                         //需要校验付款状态
    222.                         if(skus.contains(productId) &&
    223.                                 purchase.getPurchaseState()==Purchase.PurchaseState.PURCHASED){
    224.                             purchaseToken=purchase.getPurchaseToken();
    225.                             break;
    226.                         }
    227.                         if(purchaseToken!=null) break;
    228.                     }
    229.                 }
    230.  
    231.                 if(isConsumable){
    232.                     if(purchaseToken==null){
    233.                         CallBackBuyFail("unknown purchaseToken:"+productId);
    234.                     }else {
    235.                         ConsumeParams consumeParams =
    236.                                 ConsumeParams.newBuilder()
    237.                                         .setPurchaseToken(purchaseToken)
    238.                                         .build();
    239.                         billingClient.consumeAsync(consumeParams,(billingResult, token) -> {
    240.                             if(billingResult.getResponseCode()==BillingClient.BillingResponseCode.OK){
    241.                                 BuyComplete(productId);
    242.                             }else{
    243.                                 CallBackBuyFail(billingResult.getDebugMessage());
    244.                             }
    245.                         });
    246.                     }
    247.                 }else{
    248.                     BuyComplete(productId);
    249.                 }
    250.             }
    251.         }else{
    252.             if(buyProductId!=null){
    253.                 CallBackBuyFail(message);
    254.             }
    255.         }
    256.     }
    257.  
    258.     private void CallBackBuyFail(String message){
    259.         String productId=buyProductId;
    260.         buyProductId=null;
    261.         BuyFail(productId, message);
    262.         PrintLog("Error purchasing: " + message);
    263.     }
    264.  
    265.     @Override
    266.     public void onBillingServiceDisconnected() {
    267.         PrintLog("onBillingServiceDisconnected");
    268.         billingSetupComplete = false;
    269.         retryBillingServiceConnectionWithExponentialBackoff();
    270.     }
    271.  
    272.     @Override
    273.     public void onBillingSetupFinished(@NonNull BillingResult billingResult) {
    274.         int responseCode = billingResult.getResponseCode();
    275.         String debugMessage = billingResult.getDebugMessage();
    276.         PrintLog("onBillingSetupFinished: " + debugMessage+"("+ GetResponseText(responseCode)+")",true);
    277.         switch (responseCode) {
    278.             case BillingClient.BillingResponseCode.OK:
    279.                 // The billing client is ready. You can query purchases here.
    280.                 // This doesn't mean that your app is set up correctly in the console -- it just
    281.                 // means that you have a connection to the Billing service.
    282.                 reconnectMilliseconds = RECONNECT_TIMER_START_MILLISECONDS;
    283.                 billingSetupComplete = true;
    284.                 break;
    285.             case BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE:
    286.             case BillingClient.BillingResponseCode.BILLING_UNAVAILABLE:
    287.                 PrintLog("Billing Service Unavailable:"+debugMessage,true);
    288.                 break;
    289.             default:
    290.                 retryBillingServiceConnectionWithExponentialBackoff();
    291.                 break;
    292.         }
    293.     }
    294. }
  • 选择Module，并且点击Build Module，将会导出aar文件
  • 我们将aar改为rar格式，然后用压缩软件打开，取出里面的classes.jar，我们只需要该jar即可，该jar是我们封装好的接口，后续有用，为了方便认，我将名字改为IAPForGooglePlay.jar
  • 将jar放置到Unity工程下，Assets/Plugins/Android目录下，该目录下文件如下：
    注意：jar要放在Android目录下，而不是Android/libs目录下，经试验放libs下会识别不到
  • Android这边的工作就结束了，后面我们来写Unity这边的代码

 编写Unity接口

  • 创建类GooglePlay_IAPBridge，编写调用Android我们封装好的jar里的接口的桥接类 
    1. #if UNITY_ANDROID
    2. using System;
    3. using UnityEngine;
    4. using System.Collections;
    5. using System.Collections.Generic;
    6. using Newtonsoft.Json;
    7.  
    8. public class GooglePlay_IAPBridge{
    9. 	class BuyProductData
    10. 	{
    11. 		public string productId;
    12. 		public bool isConsumable;
    13. 	}
    14. 	private AndroidJavaObject javaObject;
    15.  
    16. 	private GooglePlay_IAPBridge() {
    17. 		if (Application.platform != RuntimePlatform.Android)
    18. 			return;
    19. 		javaObject = new AndroidJavaObject("com.egogame.MainActivity");
    20. 	}
    21.  
    22. 	private volatile static GooglePlay_IAPBridge _instance = null;
    23. 	private static readonly object lockHelper = new object();
    24. 	public static GooglePlay_IAPBridge getInstance()
    25. 	{
    26. 		if(_instance == null)
    27. 		{
    28. 			lock(lockHelper)
    29. 			{
    30. 				if(_instance == null)
    31. 					_instance = new GooglePlay_IAPBridge();
    32. 			}
    33. 		}
    34. 		return _instance;
    35. 	}
    36. 	public void Init(string goName,string publicKey){
    37. 		Debug.Log ("[GooglePlay_IAPBridge]Init：" + goName + "=====" + publicKey);
    38. 		if (Application.platform != RuntimePlatform.Android)
    39. 			return;
    40. 		javaObject.Call ("Init", goName, publicKey);
    41. 	}
    42.  
    43. 	public bool IsIAPSupported(){
    44. 		if (Application.platform != RuntimePlatform.Android)
    45. 			return false;
    46. 		return javaObject.Call<bool> ("IsIAPSupported");
    47. 	}
    48.  
    49. 	public void RequestProducts(string jsonData)
    50. 	{
    51. 		Debug.Log ("[GooglePlay_IAPBridge]RequstProduct：" + jsonData);
    52. 		if (Application.platform != RuntimePlatform.Android)
    53. 			return;
    54. 		javaObject.Call ("RequstProduct", jsonData);
    55. 	}
    56.  
    57. 	public void BuyProduct(string productId,bool isConsumable){
    58. 		BuyProductData buyProductData=new BuyProductData();
    59. 		buyProductData.productId = productId;
    60. 		buyProductData.isConsumable = isConsumable;
    61. 		string jsonData = JsonConvert.SerializeObject(buyProductData);
    62. 		Debug.Log ("[GooglePlay_IAPBridge]BuyProduct：" + jsonData);
    63. 		if (Application.platform != RuntimePlatform.Android)
    64. 			return;
    65. 		javaObject.Call ("BuyProduct", jsonData);
    66. 	}
    67. }
    68. #endif
    这里面我们直接 javaObject = new AndroidJavaObject("com.egogame.MainActivity");实例化我们jar封装好的类，即可直接调用public方法。请注意：因为Android和Unity线程不一样，所以jar处理时需要规避线程的同步性。
  • 再封装一个IAPBridge类，用来分流不同渠道，转接不同接口文件 
    1. using UnityEngine;
    2. using System.Collections.Generic;
    3. using Newtonsoft.Json;
    4.  
    5. public class IAPBridge{
    6. 	class RequestSkuData
    7. 	{
    8. 		public string[] productIds;
    9. 	}
    10. 	
    11. 	public static void InitIAp(string goName,string publicKey=""){
    12. 		Debug.Log("[IAPBridge]InitIAp:" + goName + "==" + publicKey);
    13. #if UNITY_IPHONE
    14. 		if(Application.platform==RuntimePlatform.IPhonePlayer){
    15. 			iOS_IAPBridge.InitIAPManager(goName);
    16. 		}
    17. #elif UNITY_ANDROID
    18. 		if(Application.platform==RuntimePlatform.Android){
    19. 			GooglePlay_IAPBridge.getInstance().Init(goName,publicKey);
    20. 		}
    21. #endif
    22. 	}
    23.  
    24. 	public static bool IAPEnabeld(){
    25. #if UNITY_IPHONE
    26. 		if(Application.platform==RuntimePlatform.IPhonePlayer){
    27. 			return iOS_IAPBridge.IsProductAvailable();
    28. 		}
    29. #elif UNITY_ANDROID
    30. 		if(Application.platform==RuntimePlatform.Android){
    31. 			return GooglePlay_IAPBridge.getInstance().IsIAPSupported();
    32. 		}
    33. #endif
    34. 		return false;
    35. 	}
    36.  
    37. 	public static void RequstProducts(List<string> productIds){
    38. 		RequestSkuData data=new RequestSkuData();
    39. 		data.productIds = productIds.ToArray();
    40. 		string jsonData = JsonConvert.SerializeObject(data);
    41. 		Debug.Log("[IAPBridge]RequstProducts:"+jsonData);
    42. #if UNITY_IPHONE
    43. 		iOS_IAPBridge.RequstProductInfo(jsonData);
    44. #elif UNITY_ANDROID
    45. 		if (Application.platform == RuntimePlatform.Android){
    46. 			GooglePlay_IAPBridge.getInstance().RequestProducts(jsonData);
    47. 		}
    48. #endif
    49. 	}
    50.  
    51. 	public static void SendBuyProduct(string productId,bool isConsumable){
    52. 		Debug.Log(string.Format("[IAPBridge]SendBuyProduct:{0} isConsumable:{1}",productId,isConsumable));
    53. #if UNITY_IPHONE
    54. 		if(Application.platform==RuntimePlatform.IPhonePlayer){
    55. 			iOS_IAPBridge.BuyProduct(productId);
    56. 		}
    57. #elif UNITY_ANDROID
    58. 		if (Application.platform == RuntimePlatform.Android){
    59. 			GooglePlay_IAPBridge.getInstance().BuyProduct(productId, isConsumable);
    60. 		}
    61. #endif
    62. 	}
    63.  
    64. 	public static void RestoreProduct(){
    65. 		Debug.Log("[IAPBridge]Restore!");
    66. #if UNITY_IPHONE
    67. 		if(Application.platform==RuntimePlatform.IPhonePlayer){
    68. 			iOS_IAPBridge.Restore();
    69. 		}
    70. #endif
    71. 	}
    72. }

  • 然后Unity这边要接收下Android那边传过来的接口，将这个类挂载到某个GameObject下，如GameObject名为IAPObject，则上面初始化时调用IAPBridge.InitIAP将该gameObject名作为goName参数传过去即可。 
    1. using Newtonsoft.Json;
    2. using UnityEngine;
    3. #pragma warning disable 0649
    4.  
    5. /// <summary>
    6. /// 该类主要用于接收iOS和Android回调，做一个桥接用途
    7. /// </summary>
    8. public class IAPMessage : MonoBehaviour {
    9. 	class BuyFailData
    10. 	{
    11. 		public string productId;
    12. 		public string error;
    13. 	}
    14. 	
    15. 	#region callback from Objective-c/JAR
    16. 	//获取到产品列表回调
    17. 	void RecieveProductInfos(string jsonData)
    18. 	{
    19. 		if(string.IsNullOrEmpty(jsonData)) return;
    20. 		var infoData = JsonConvert.DeserializeObject<IAPProductInfoData>(jsonData);
    21. 		OnProductInfoReceived (infoData);
    22. 	}
    23.  
    24. 	//产品列表请求失败
    25. 	void ProductRequestFail(string message)
    26. 	{
    27. 		OnProductInfoFail(message);
    28. 	}
    29.  
    30. 	//购买成功回调
    31. 	void ProductBuyComplete(string productId)
    32. 	{
    33. 		OnProductBuyComplete(productId);
    34. 	}
    35. 	
    36. 	//购买失败回调
    37. 	void ProductBuyFailed(string jsonData)
    38. 	{
    39. 		var infoData = JsonConvert.DeserializeObject<BuyFailData>(jsonData);
    40. 		OnBuyProductFail (infoData.productId, infoData.error);
    41. 	}
    42. 	
    43. 	//获取商品回执回调
    44. 	void ProvideContent(string msg){}
    45.  
    46. 	//购买取消回调
    47. 	void ProductBuyCancled(string productId)
    48. 	{
    49. 		OnBuyProductCancled(productId);
    50. 	}
    51. 	
    52. 	/// <summary>
    53. 	/// 恢复购买成功
    54. 	/// </summary>
    55. 	/// <param name="productId"></param>
    56. 	void RestoreComplete(string productId){
    57. 		OnRestoreCompleted (productId);
    58. 	}
    59. 	#endregion
    60. 	
    61. 	//接收到产品信息
    62. 	void OnProductInfoReceived(IAPProductInfoData info){
    63. 		Debug.Log("[IAPMessage]Unity接收到商品信息:" + info.ToString());
    64. 		IAPManager.internal_CallBySDK_ProductInfosReceive(info);
    65. 	}
    66. 	
    67. 	//接收到产品信息
    68. 	void OnProductInfoFail(string error){
    69. 		Debug.Log("[IAPMessage]Unity商品信息请求失败:" + error);
    70. 		IAPManager.internal_RequestProductInfoFail(error);
    71. 	}
    72. 	
    73. 	//购买完成
    74. 	void OnProductBuyComplete(string productId){
    75. 		Debug.Log ("[IAPMessage]购买完成" + productId);
    76. 		IAPManager.internal_CallBySDK_BuyComplete(productId);
    77. 	}
    78.  
    79. 	//购买失败
    80. 	void OnBuyProductFail(string productId,string error){
    81. 		Debug.Log(string.Format("[IAPMessage]购买失败:{0} 错误信息{1}", productId, error));
    82. 		IAPManager.internal_CallBySDK_BuyFail(productId, error);
    83. 	}
    84. 	
    85. 	//购买取消
    86. 	void OnBuyProductCancled(string productId){
    87. 		Debug.Log ("[IAPMessage]购买取消" + productId);
    88. 		IAPManager.internal_CallBySDK_BuyCanceled(productId);
    89. 	}
    90. 	
    91. 	//恢复完成
    92. 	void OnRestoreCompleted(string productId){
    93. 		Debug.Log ("[IAPMessage]恢复购买完成:"+productId);
    94. 		IAPManager.internal_CallBySDK_RestoreCompleted(productId);
    95. 	}
    96. }
    97.  
    98. #pragma warning restore 0649
    1. using System.Collections.Generic;
    2.  
    3. public class IAPProductInfoData
    4. {
    5.     public List<IAPSkuItem> skuItems;//请求到的产品列表
    6.     public string[] invalidIds;//无效产品id
    7. }
    8.  
    9. public struct IAPSkuItem{
    10.     public string productId;//后台产品id
    11.     public string title;//后台标题
    12.     public string desc;//后台描述
    13.     public string price;//格式化价格，显示请用formatPrirce
    14.     public string formatPrice;//格式化价格，包括其货币符号
    15.     public string priceCurrencyCode;//货币代码
    16.     public string skuType;//内购还是订阅 subscription/inapp
    17.  
    18.     public override string ToString ()
    19.     {
    20.         return string.Format(
    21.             "[productId]:{0} [title]:{1} [desc]:{2} [price]:{3} [formatPrice]:{4} [priceCurrencyCode]:{5} [skuType:]{6}",
    22.             productId, title, desc, price, formatPrice, priceCurrencyCode, skuType);
    23.     }
    24. }
    25.  
    26. public struct IAPProvideData
    27. {
    28.     public string cfgId;
    29.     public string title;
    30.     public string desc;
    31.     public string formatPrice;
    32. }

  • 到这里就接入完成了，调用对应接口即可实现IAP的接入。

 请注意：

*打包的apk不要对安卓代码进行混淆，否则代码会被裁剪导致调用不到java代码，如下

Minify和Custom Proguard File不要勾选

 如果接入有问题，可以加Q群进行提问

Android部分源码可以在这里下载到：https://download.csdn.net/download/egostudio/20463417 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/844677
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号

        
cppcmd=keepalive&