程序博客网 > 中国人才流失数据

Google play billing(Google play 内支付) 下篇

来源：互联网 发布：中国人才流失数据 编辑：程序博客网 时间：2024/05/20 16:44

http://blog.csdn.net/change_from_now/article/details/36668017

html] view plaincopyprint?在CODE上查看代码片派生到我的代码片

  1. 开篇：  
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. 如billing开发文档所说，要在你的应用中实现In-app Billing只需要完成以下几步就可以了。  



[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. 第一,把你上篇下载的AIDL文件添加到你的工程里，第二,把<uses-permission android:name="com.android.vending.BILLING" />  
这个权限加到你工程的AndroidManifest.xml文件中，第三，创建一个ServiceConnection,并把它绑定到IInAppBillingService中。完成上面三条后就可以使用支付了。当然这只是一个简单的介绍。其实Google的这个支付，大部分都是你手机上的Google Play来进行处理的，你只需要处理购买请求，处理购买结果就行了。文档写的很好，先把这个文档看完，就知道支付流程了。
正文:
1.内购商品相关
针对我的项目而言，我们在Google后台设置的是受管理可消耗的商品("managed per user account")，具体的就是游戏里的水晶，玩家可以多次购买。但是Google后台的这种可重复购买商品（还有一种是只能购买一次的商品"subscription"）有个要求，就是你购买成功后需要主动向Google Play请求消耗这个商品，等消耗成功后你才可以再次下单购买。因此，在游戏里的支付会多出一个操作步骤就是请求消耗购买成功的商品。
2.检测设备是否支持Google Play Service
在正式开启支付前，Google billing会检查你的手机是否支持Google billing，这个下面会讲到。为了更好的用户体验，建议在Google billing检测之前，可以先检测一下用户的设备是否支持Google Play Service，其中基本要求就是安装了Google Play应用商店和Google Play Service。如果用户的设备不具备这两个，就可以弹出提示引导用户去安装。这里有两种方式可以用，一种是通过Google Play Service来进行检测，就是上篇下载的那个Service扩展包，一种是自己写代码，遍历设备上安装的应用程序，检查是否有安装Google Play。先说第一种。
(1)Google Play Service
上篇下载的Service包里会有一个库工程

把这个库工程导入你的eclipse,引用到你的工程里就可以用了，具体操作可以参加docs下的文档，so easy!导入成功后，调用其中的一个方法就可以了。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * Check the device to make sure it has the Google Play Services APK.If  
  3.  * it doesn't, display a dialog that allows users to download the APK from  
  4.  * the Google Play Store or enable it in the device's system settings  
  5.  */  
  6. private boolean checkPlayServices()  
  7. {  
  8.     int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);  
  9.     if(resultCode != ConnectionResult.SUCCESS)  
  10.     {  
  11.         if(GooglePlayServicesUtil.isUserRecoverableError(resultCode))  
  12.         {  
  13.             GooglePlayServicesUtil.getErrorDialog(resultCode, this,  
  14.                     PLAY_SERVICES_RESOLUTION_REQUEST).show();  
  15.         }  
  16.         else  
  17.         {  
  18.             Log.i(TAG, "This device is not supported");  
  19.             finish();  
  20.         }  
  21.         return false;  
  22.     }  
  23.     return true;  
  24. }  

如果当前设备的Google Service不可用，就会弹出提示，引导用户去设置安装。如果此设备不支持的话，就也不需要检测Google billing是否可用了。多说一句，Google Play Service可以做很多事的，如果觉得只用上面的功能太简单的话，就可以考虑把应用自动更新也加上，当你在Google Play上传了新版程序后，Google Play会帮你提示用户更新程序。还有一个比较好玩的就是如果引入了这个库工程后，就可以加GCM了(Google Cloud Messaging),就是消息推送推送功能，当然这个比较麻烦，有兴趣的可以去加加看。
(2)遍历包名
Google Play的程序包名是"com.android.vending",运行在设备上的Google Play Service的包名是"com.google.android.gms"，可以在程序启动的时候遍历下设备上的包名，如果没有这两个东西就引导用户去安装。
遍历包名方法
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. //Check Google Play  
  2. protected boolean isHaveGooglePlay(Context context, String packageName)  
  3. {  
  4.     //Get PackageManager  
  5.     final PackageManager packageManager = context.getPackageManager();  
  6.   
  7.     //Get The All Install App Package Name  
  8.     List<PackageInfo> pInfo = packageManager.getInstalledPackages(0);  
  9.       
  10.     //Create Name List  
  11.     List<String> pName = new ArrayList<String>();  
  12.       
  13.     //Add Package Name into Name List  
  14.     if(pInfo != null){  
  15.         for(int i=0; i<pInfo.size(); i++){  
  16.             String pn = pInfo.get(i).packageName;  
  17.             pName.add(pn);  
  18.               
  19.             //Log.v("Package Name", "PackAgeName: = " + pn);  
  20.         }  
  21.     }  
  22.       
  23.     //Check   
  24.     return pName.contains(packageName);  
  25. }  
提示安装方法 
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. Uri uri = Uri.parse("market://details?id=" + "要安装程序的包名");  
  2.             Intent it = new Intent(Intent.ACTION_VIEW, uri);   
  3.             startActivity(it);  
上面这个方法会打开你手机上的应用商店，定位到要安装的程序。 
不过还是推荐用Google Play Service来检测，貌似第二种，即使有的用户装了Google Play(像国内用户)，也不支持Google Play Service的。

3.添加代码(终于要加支付代码了)
把上篇下载的samples里util的代码全部拷到你的工程里，可以新建一个包，放到里面。

这个说明一下，其实这个例子的代码还是不错的，本着天下代码一大抄和拿来主义，就直接拿来用吧！当然如果你觉得这个代码写的不好，或者不适用你的工程，你就可以依据文档自己写适用的代码。当然文档里说过，为了防止别人破解你的游戏，最好把里面的变量和方法都改下名字，毕竟这里的代码任何人都看得到。我的做法是照搬过来了，只是把IabHelper.java改造了下，因为这个是整个支付的关键，其他都是辅助的，可以不管。
把这里的代码拷完，把该import的都import了，你就可以照samples中的代码开写自己的支付了。针对单机游戏，就需要考虑这个代码改造和本地的验证，加密了。针对网络游戏就要简单了。因为我其实对java不太熟悉吐舌头，所以单机的加密,base验证，混淆什么的就不做介绍了。下面主要说网络游戏。
(1)IabHelper.java
这个是支付的关键代码，其中已经把设置billing,商品查询，商品购买，商品回调，商品验证以及回调方法都写好了，你直接参照samples用就可以了。
01.设置billing
就是开篇所说的绑定ServiceConnection到IInAppBillingService。功能很完善，包括成功和失败都有回调，还有各种异常。在你程序的启动Activity里检测完设备是否Google Play Service后，就可以new一个IabHelper，来调用这个方法，根据不同的回调里做相应的处理。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.      * Starts the setup process. This will start up the setup process asynchronously.  
  3.      * You will be notified through the listener when the setup process is complete.  
  4.      * This method is safe to call from a UI thread.  
  5.      *  
  6.      * @param listener The listener to notify when the setup process is complete.  
  7.      */  
  8.     public void startSetup(final OnIabSetupFinishedListener listener) {  
  9.         // If already set up, can't do it again.  
  10.         checkNotDisposed();  
  11.         if (mSetupDone) throw new IllegalStateException("IAB helper is already set up.");  
  12.   
  13.         // Connection to IAB service  
  14.         logDebug("Starting in-app billing setup.");  
  15.         mServiceConn = new ServiceConnection() {  
  16.             @Override  
  17.             public void onServiceDisconnected(ComponentName name) {  
  18.                 logDebug("Billing service disconnected.");  
  19.                 mService = null;  
  20.             }  
  21.   
  22.             @Override  
  23.             public void onServiceConnected(ComponentName name, IBinder service) {  
  24.                 if (mDisposed) return;  
  25.                 logDebug("Billing service connected.");  
  26.                 mService = IInAppBillingService.Stub.asInterface(service);  
  27.                 String packageName = mContext.getPackageName();  
  28.                 try {  
  29.                     logDebug("Checking for in-app billing 3 support.");  
  30.   
  31.                     // check for in-app billing v3 support  
  32.                     int response = mService.isBillingSupported(3, packageName, ITEM_TYPE_INAPP);  
  33.                     if (response != BILLING_RESPONSE_RESULT_OK) {  
  34.                         if (listener != null) listener.onIabSetupFinished(new IabResult(response,  
  35.                                 "Error checking for billing v3 support."));  
  36.   
  37.                         // if in-app purchases aren't supported, neither are subscriptions.  
  38.                         mSubscriptionsSupported = false;  
  39.                         return;  
  40.                     }  
  41.                     logDebug("In-app billing version 3 supported for " + packageName);  
  42.   
  43.                     // check for v3 subscriptions support  
  44.                     response = mService.isBillingSupported(3, packageName, ITEM_TYPE_SUBS);  
  45.                     if (response == BILLING_RESPONSE_RESULT_OK) {  
  46.                         logDebug("Subscriptions AVAILABLE.");  
  47.                         mSubscriptionsSupported = true;  
  48.                     }  
  49.                     else {  
  50.                         logDebug("Subscriptions NOT AVAILABLE. Response: " + response);  
  51.                     }  
  52.   
  53.                     mSetupDone = true;  
  54.                 }  
  55.                 catch (RemoteException e) {  
  56.                     if (listener != null) {  
  57.                         listener.onIabSetupFinished(new IabResult(IABHELPER_REMOTE_EXCEPTION,  
  58.                                                     "RemoteException while setting up in-app billing."));  
  59.                     }  
  60.                     e.printStackTrace();  
  61.                     return;  
  62.                 }  
  63.   
  64.                 if (listener != null) {  
  65.                     listener.onIabSetupFinished(new IabResult(BILLING_RESPONSE_RESULT_OK, "Setup successful."));  
  66.                 }  
  67.             }  
  68.         };  
  69.   
  70.         Intent serviceIntent = new Intent("com.android.vending.billing.InAppBillingService.BIND");  
  71.         serviceIntent.setPackage("com.android.vending");  
  72.         if (!mContext.getPackageManager().queryIntentServices(serviceIntent, 0).isEmpty()) {  
  73.             // service available to handle that Intent  
  74.             mContext.bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);  
  75.         }  
  76.         else {  
  77.             // no service available to handle that Intent  
  78.             if (listener != null) {  
  79.                 listener.onIabSetupFinished(  
  80.                         new IabResult(BILLING_RESPONSE_RESULT_BILLING_UNAVAILABLE,  
  81.                         "Billing service unavailable on device."));  
  82.             }  
  83.         }  
  84.     }  
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. samples中的代码  
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. // Create the helper, passing it our context and the public key to verify signatures with  
  2.         Log.d(TAG, "Creating IAB helper.");  
  3.         mHelper = new IabHelper(this, base64EncodedPublicKey);  
  4.   
  5.   
  6.         // enable debug logging (for a production application, you should set this to false).  
  7.         mHelper.enableDebugLogging(true);  
  8.   
  9.   
  10.         // Start setup. This is asynchronous and the specified listener  
  11.         // will be called once setup completes.  
  12.         Log.d(TAG, "Starting setup.");  
  13.         mHelper.startSetup(new IabHelper.OnIabSetupFinishedListener() {  
  14.             public void onIabSetupFinished(IabResult result) {  
  15.                 Log.d(TAG, "Setup finished.");  
  16.   
  17.   
  18.                 if (!result.isSuccess()) {  
  19.                     // Oh noes, there was a problem.  
  20.                     complain("Problem setting up in-app billing: " + result);  
  21.                     return;  
  22.                 }  
  23.   
  24.   
  25.                 // Have we been disposed of in the meantime? If so, quit.  
  26.                 if (mHelper == null) return;  
  27.   
  28.   
  29.                 // IAB is fully set up. Now, let's get an inventory of stuff we own.  
  30.                 Log.d(TAG, "Setup successful. Querying inventory.");  
  31.                 mHelper.queryInventoryAsync(mGotInventoryListener);  
  32.             }  
  33.         });  
  34.     }  
02.查询商品
在setup方法的最后有一个
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. mHelper.queryInventoryAsync(mGotInventoryListener);  
是用来查询你目前拥有的商品的。其中的回调的代码如下 
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. // Listener that's called when we finish querying the items and subscriptions we own  
  2.     IabHelper.QueryInventoryFinishedListener mGotInventoryListener = new IabHelper.QueryInventoryFinishedListener() {  
  3.         public void onQueryInventoryFinished(IabResult result, Inventory inventory) {  
  4.             Log.d(TAG, "Query inventory finished.");  
  5.   
  6.             // Have we been disposed of in the meantime? If so, quit.  
  7.             if (mHelper == null) return;  
  8.   
  9.             // Is it a failure?  
  10.             if (result.isFailure()) {  
  11.                 complain("Failed to query inventory: " + result);  
  12.                 return;  
  13.             }  
  14.   
  15.             Log.d(TAG, "Query inventory was successful.");  
  16.   
  17.             /*  
  18.              * Check for items we own. Notice that for each purchase, we check  
  19.              * the developer payload to see if it's correct! See  
  20.              * verifyDeveloperPayload().  
  21.              */  
  22.   
  23.             // Do we have the premium upgrade?  
  24.             Purchase premiumPurchase = inventory.getPurchase(SKU_PREMIUM);  
  25.             mIsPremium = (premiumPurchase != null && verifyDeveloperPayload(premiumPurchase));  
  26.             Log.d(TAG, "User is " + (mIsPremium ? "PREMIUM" : "NOT PREMIUM"));  
  27.   
  28.             // Do we have the infinite gas plan?  
  29.             Purchase infiniteGasPurchase = inventory.getPurchase(SKU_INFINITE_GAS);  
  30.             mSubscribedToInfiniteGas = (infiniteGasPurchase != null &&  
  31.                     verifyDeveloperPayload(infiniteGasPurchase));  
  32.             Log.d(TAG, "User " + (mSubscribedToInfiniteGas ? "HAS" : "DOES NOT HAVE")  
  33.                         + " infinite gas subscription.");  
  34.             if (mSubscribedToInfiniteGas) mTank = TANK_MAX;  
  35.   
  36.             // Check for gas delivery -- if we own gas, we should fill up the tank immediately  
  37.             Purchase gasPurchase = inventory.getPurchase(SKU_GAS);  
  38.             if (gasPurchase != null && verifyDeveloperPayload(gasPurchase)) {  
  39.                 Log.d(TAG, "We have gas. Consuming it.");  
  40.                 mHelper.consumeAsync(inventory.getPurchase(SKU_GAS), mConsumeFinishedListener);  
  41.                 return;  
  42.             }  
  43.   
  44.             updateUi();  
  45.             setWaitScreen(false);  
  46.             Log.d(TAG, "Initial inventory query finished; enabling main UI.");  
  47.         }  
  48.     };  

因为目前我们的内购商品是可重复购买的，所以在成功查询到我们已经购买的商品后进行了消耗商品操作。消耗的代码在这里 
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. // Check for gas delivery -- if we own gas, we should fill up the tank immediately  
  2. Purchase gasPurchase = inventory.getPurchase(SKU_GAS);  
  3. if (gasPurchase != null && verifyDeveloperPayload(gasPurchase)) {  
  4.     Log.d(TAG, "We have gas. Consuming it.");  
  5.     mHelper.consumeAsync(inventory.getPurchase(SKU_GAS), mConsumeFinishedListener);  
  6.     return;  
  7. }  

在讲消耗前，先解释下以上这么操作的原因。在内购商品那里讲过，如果是设置的是可重复商品，当你在成功购买这个商品后是需要主动消耗的，只有消耗成功后才可以再次购买。可能有些人觉得这种设定不好，我的商品本来就是可重复购买的，为什么还要在买成功后通知Google Play消耗掉商品呢(可能本身商品没用消耗掉，这只是一种叫法)？我个人觉得这样设定，第一，可以避免用户重复下单购买，第二，可以保证每笔消费订单的唯一。有了以上两点就可以很好地处理漏单。 so,上面代码在成功设置billing后，第一个操作就是查询拥有的商品，就是做的漏单处理。因为支付过程其实就是你的应用程序----->Google Play程序(通过Google Play Service)------>Google服务器------->Google Play程序(通过Google Play Service)------>你的应用程序。这样一个交互过程，还需要网络支持，所以每次支付操作不会保证百分百成功，这样就会产生漏单现象，就是用户付费成功了，但是Google Play在通知你的应用程序支付结果时，因为某些原因断掉了，这样你的程序就不知道支付是否操作成功了，so,只好在下次进游戏时查查有没有已经购买的，但是还没有消耗的商品，有的话就消耗掉，然后再把商品发送给用户。因为这个商品在消耗之前，用户是无法再次购买的，所以单个用户就只会对应单一的漏单，不会有重复的漏单。这些信息都是存到Google服务器上的，直接调代码里的查询代码就可以了。
02.消耗商品
消耗商品会在两个地方出现。一，查询商品中所说的漏单中，二，就是你每次购买成功后的消耗。消耗商品也有一个回调，如下
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. // Called when consumption is complete  
  2.    IabHelper.OnConsumeFinishedListener mConsumeFinishedListener = new IabHelper.OnConsumeFinishedListener() {  
  3.        public void onConsumeFinished(Purchase purchase, IabResult result) {  
  4.            Log.d(TAG, "Consumption finished. Purchase: " + purchase + ", result: " + result);  
  5.   
  6.            // if we were disposed of in the meantime, quit.  
  7.            if (mHelper == null) return;  
  8.   
  9.            // We know this is the "gas" sku because it's the only one we consume,  
  10.            // so we don't check which sku was consumed. If you have more than one  
  11.            // sku, you probably should check...  
  12.            if (result.isSuccess()) {  
  13.                // successfully consumed, so we apply the effects of the item in our  
  14.                // game world's logic, which in our case means filling the gas tank a bit  
  15.                Log.d(TAG, "Consumption successful. Provisioning.");  
  16.                mTank = mTank == TANK_MAX ? TANK_MAX : mTank + 1;  
  17.                saveData();  
  18.                alert("You filled 1/4 tank. Your tank is now " + String.valueOf(mTank) + "/4 full!");  
  19.            }  
  20.            else {  
  21.                complain("Error while consuming: " + result);  
  22.            }  
  23.            updateUi();  
  24.            setWaitScreen(false);  
  25.            Log.d(TAG, "End consumption flow.");  
  26.        }  
  27.    };  

代码比较简单，针对自己的游戏逻辑，在里面稍做改动即可。 
03.购买商品
按重要程度，购买商品应该排在第一位的，只是按支付流程走的话，购买商品却不是第一位，这里就根据支付流程来走吧。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.     * Initiate the UI flow for an in-app purchase. Call this method to initiate an in-app purchase,  
  3.     * which will involve bringing up the Google Play screen. The calling activity will be paused while  
  4.     * the user interacts with Google Play, and the result will be delivered via the activity's  
  5.     * {@link android.app.Activity#onActivityResult} method, at which point you must call  
  6.     * this object's {@link #handleActivityResult} method to continue the purchase flow. This method  
  7.     * MUST be called from the UI thread of the Activity.  
  8.     *  
  9.     * @param act The calling activity.  
  10.     * @param sku The sku of the item to purchase.  
  11.     * @param itemType indicates if it's a product or a subscription (ITEM_TYPE_INAPP or ITEM_TYPE_SUBS)  
  12.     * @param requestCode A request code (to differentiate from other responses --  
  13.     *     as in {@link android.app.Activity#startActivityForResult}).  
  14.     * @param listener The listener to notify when the purchase process finishes  
  15.     * @param extraData Extra data (developer payload), which will be returned with the purchase data  
  16.     *     when the purchase completes. This extra data will be permanently bound to that purchase  
  17.     *     and will always be returned when the purchase is queried.  
  18.     */  
  19.    public void launchPurchaseFlow(Activity act, String sku, String itemType, int requestCode,  
  20.                        OnIabPurchaseFinishedListener listener, String extraData) {  
  21.        checkNotDisposed();  
  22.        checkSetupDone("launchPurchaseFlow");  
  23.        flagStartAsync("launchPurchaseFlow");  
  24.        IabResult result;  
  25.   
  26.        if (itemType.equals(ITEM_TYPE_SUBS) && !mSubscriptionsSupported) {  
  27.            IabResult r = new IabResult(IABHELPER_SUBSCRIPTIONS_NOT_AVAILABLE,  
  28.                    "Subscriptions are not available.");  
  29.            flagEndAsync();  
  30.            if (listener != null) listener.onIabPurchaseFinished(r, null);  
  31.            return;  
  32.        }  
  33.   
  34.        try {  
  35.            logDebug("Constructing buy intent for " + sku + ", item type: " + itemType);  
  36.            Bundle buyIntentBundle = mService.getBuyIntent(3, mContext.getPackageName(), sku, itemType, extraData);  
  37.            int response = getResponseCodeFromBundle(buyIntentBundle);  
  38.            if (response != BILLING_RESPONSE_RESULT_OK) {  
  39.                logError("Unable to buy item, Error response: " + getResponseDesc(response));  
  40.                flagEndAsync();  
  41.                result = new IabResult(response, "Unable to buy item");  
  42.                if (listener != null) listener.onIabPurchaseFinished(result, null);  
  43.                return;  
  44.            }  
  45.   
  46.            PendingIntent pendingIntent = buyIntentBundle.getParcelable(RESPONSE_BUY_INTENT);  
  47.            logDebug("Launching buy intent for " + sku + ". Request code: " + requestCode);  
  48.            mRequestCode = requestCode;  
  49.            mPurchaseListener = listener;  
  50.            mPurchasingItemType = itemType;  
  51.            act.startIntentSenderForResult(pendingIntent.getIntentSender(),  
  52.                                           requestCode, new Intent(),  
  53.                                           Integer.valueOf(0), Integer.valueOf(0),  
  54.                                           Integer.valueOf(0));  
  55.        }  
  56.        catch (SendIntentException e) {  
  57.            logError("SendIntentException while launching purchase flow for sku " + sku);  
  58.            e.printStackTrace();  
  59.            flagEndAsync();  
  60.   
  61.            result = new IabResult(IABHELPER_SEND_INTENT_FAILED, "Failed to send intent.");  
  62.            if (listener != null) listener.onIabPurchaseFinished(result, null);  
  63.        }  
  64.        catch (RemoteException e) {  
  65.            logError("RemoteException while launching purchase flow for sku " + sku);  
  66.            e.printStackTrace();  
  67.            flagEndAsync();  
  68.   
  69.            result = new IabResult(IABHELPER_REMOTE_EXCEPTION, "Remote exception while starting purchase flow");  
  70.            if (listener != null) listener.onIabPurchaseFinished(result, null);  
  71.        }  
  72.    }  

以上是IabHelper中的支付购买代码，其中包括了重复购买商品类型和一次购买商品类型的处理。主要的代码是try里面的这一块 
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. try {  
  2.     logDebug("Constructing buy intent for " + sku + ", item type: " + itemType);  
  3.     Bundle buyIntentBundle = mService.getBuyIntent(3, mContext.getPackageName(), sku, itemType, extraData);  
  4.     int response = getResponseCodeFromBundle(buyIntentBundle);  
  5.     if (response != BILLING_RESPONSE_RESULT_OK) {  
  6.         logError("Unable to buy item, Error response: " + getResponseDesc(response));  
  7.         flagEndAsync();  
  8.         result = new IabResult(response, "Unable to buy item");  
  9.         if (listener != null) listener.onIabPurchaseFinished(result, null);  
  10.         return;  
  11.     }  
  12.   
  13.     PendingIntent pendingIntent = buyIntentBundle.getParcelable(RESPONSE_BUY_INTENT);  
  14.     logDebug("Launching buy intent for " + sku + ". Request code: " + requestCode);  
  15.     mRequestCode = requestCode;  
  16.     mPurchaseListener = listener;  
  17.     mPurchasingItemType = itemType;  
  18.     act.startIntentSenderForResult(pendingIntent.getIntentSender(),  
  19.                                    requestCode, new Intent(),  
  20.                                    Integer.valueOf(0), Integer.valueOf(0),  
  21.                                    Integer.valueOf(0));  
  22. }  
一，调用In-app Billing中的getBuyIntent方法，会传几个参数，第一个参数 3 代表的是当前所用的支付API的版本，第二个参数是你的包名，第三个参数就是你内购商品的ID,第四个参数是这次购买的类型，“inapp”和"subs",我们用的是第一个，第二个是只能购买一次的类型，第五个参数是订单号。需要讲的只有第三个和第五个参数。
第三个参数，商品Id，就是你在Google开发者后台上设置的内购商品的名字。每个商品的名字要唯一。推荐用商品名字加下划线加价格的组合，比如"crystal_0.99",这样你一看名字就知道这个商品的价格是0.99美金，商品是水晶。
第三个参数，订单号。如果本地有支付服务器的话，这个订单号可以由支付服务器生成，然后再传给客户端，这样的话本地服务器也可以记录下订单信息，方便以后的查询和操作。订单号的格式推荐用时间戳加商品名字和价格，这样也可以容易看出订单信息。这个订单号会传给Google，购买成功后Google会原样传给你，所以也可以在其中加个标示信息，可以做下比对。
二，在getBuyIntent成功后，返回的Bundle中会有个BILLING_RESPONSE_RESULT_OK返回码，这就代表成功了。然后再用这个Bundle得到一个PendingIntent.如上面代码演示。
三，进行支付
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. act.startIntentSenderForResult(pendingIntent.getIntentSender(),  
  2.                                requestCode, new Intent(),  
  3.                                Integer.valueOf(0), Integer.valueOf(0),  
  4.                                Integer.valueOf(0));  
这个方法是Activity中的一个方法，调用这个方法后，回有一个回调来接收结果。除了第一个PengdingIntent参数外，其他的可以按参数类型随便写。 
四，支付完成
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.     * Handles an activity result that's part of the purchase flow in in-app billing. If you  
  3.     * are calling {@link #launchPurchaseFlow}, then you must call this method from your  
  4.     * Activity's {@link android.app.Activity@onActivityResult} method. This method  
  5.     * MUST be called from the UI thread of the Activity.  
  6.     *  
  7.     * @param requestCode The requestCode as you received it.  
  8.     * @param resultCode The resultCode as you received it.  
  9.     * @param data The data (Intent) as you received it.  
  10.     * @return Returns true if the result was related to a purchase flow and was handled;  
  11.     *     false if the result was not related to a purchase, in which case you should  
  12.     *     handle it normally.  
  13.     */  
  14.    public boolean handleActivityResult(int requestCode, int resultCode, Intent data) {  
  15.        IabResult result;  
  16.        if (requestCode != mRequestCode) return false;  
  17.   
  18.        checkNotDisposed();  
  19.        checkSetupDone("handleActivityResult");  
  20.   
  21.        // end of async purchase operation that started on launchPurchaseFlow  
  22.        flagEndAsync();  
  23.   
  24.        if (data == null) {  
  25.            logError("Null data in IAB activity result.");  
  26.            result = new IabResult(IABHELPER_BAD_RESPONSE, "Null data in IAB result");  
  27.            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);  
  28.            return true;  
  29.        }  
  30.   
  31.        int responseCode = getResponseCodeFromIntent(data);  
  32.        String purchaseData = data.getStringExtra(RESPONSE_INAPP_PURCHASE_DATA);  
  33.        String dataSignature = data.getStringExtra(RESPONSE_INAPP_SIGNATURE);  
  34.   
  35.        if (resultCode == Activity.RESULT_OK && responseCode == BILLING_RESPONSE_RESULT_OK) {  
  36.            logDebug("Successful resultcode from purchase activity.");  
  37.            logDebug("Purchase data: " + purchaseData);  
  38.            logDebug("Data signature: " + dataSignature);  
  39.            logDebug("Extras: " + data.getExtras());  
  40.            logDebug("Expected item type: " + mPurchasingItemType);  
  41.   
  42.            if (purchaseData == null || dataSignature == null) {  
  43.                logError("BUG: either purchaseData or dataSignature is null.");  
  44.                logDebug("Extras: " + data.getExtras().toString());  
  45.                result = new IabResult(IABHELPER_UNKNOWN_ERROR, "IAB returned null purchaseData or dataSignature");  
  46.                if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);  
  47.                return true;  
  48.            }  
  49.   
  50.            Purchase purchase = null;  
  51.            try {  
  52.                purchase = new Purchase(mPurchasingItemType, purchaseData, dataSignature);  
  53.                String sku = purchase.getSku();  
  54.   
  55.                // Verify signature  
  56.                if (!Security.verifyPurchase(mSignatureBase64, purchaseData, dataSignature)) {  
  57.                    logError("Purchase signature verification FAILED for sku " + sku);  
  58.                    result = new IabResult(IABHELPER_VERIFICATION_FAILED, "Signature verification failed for sku " + sku);  
  59.                    if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, purchase);  
  60.                    return true;  
  61.                }  
  62.                logDebug("Purchase signature successfully verified.");  
  63.            }  
  64.            catch (JSONException e) {  
  65.                logError("Failed to parse purchase data.");  
  66.                e.printStackTrace();  
  67.                result = new IabResult(IABHELPER_BAD_RESPONSE, "Failed to parse purchase data.");  
  68.                if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);  
  69.                return true;  
  70.            }  
  71.   
  72.            if (mPurchaseListener != null) {  
  73.                mPurchaseListener.onIabPurchaseFinished(new IabResult(BILLING_RESPONSE_RESULT_OK, "Success"), purchase);  
  74.            }  
  75.        }  
  76.        else if (resultCode == Activity.RESULT_OK) {  
  77.            // result code was OK, but in-app billing response was not OK.  
  78.            logDebug("Result code was OK but in-app billing response was not OK: " + getResponseDesc(responseCode));  
  79.            if (mPurchaseListener != null) {  
  80.                result = new IabResult(responseCode, "Problem purchashing item.");  
  81.                mPurchaseListener.onIabPurchaseFinished(result, null);  
  82.            }  
  83.        }  
  84.        else if (resultCode == Activity.RESULT_CANCELED) {  
  85.            logDebug("Purchase canceled - Response: " + getResponseDesc(responseCode));  
  86.            result = new IabResult(IABHELPER_USER_CANCELLED, "User canceled.");  
  87.            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);  
  88.        }  
  89.        else {  
  90.            logError("Purchase failed. Result code: " + Integer.toString(resultCode)  
  91.                    + ". Response: " + getResponseDesc(responseCode));  
  92.            result = new IabResult(IABHELPER_UNKNOWN_PURCHASE_RESPONSE, "Unknown purchase response.");  
  93.            if (mPurchaseListener != null) mPurchaseListener.onIabPurchaseFinished(result, null);  
  94.        }  
  95.        return true;  
  96.    }  
  97.   
  98.    public Inventory queryInventory(boolean querySkuDetails, List<String> moreSkus) throws IabException {  
  99.        return queryInventory(querySkuDetails, moreSkus, null);  
  100.    }  

支付结果返回后会调用上面这个方法，对于支付失败和其中的错误，代码写的很清楚，可以自行处理。现在来关注支付成功后的结果验证。在上面方法中会从支付结果的数据中取得两个json数据。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int responseCode = getResponseCodeFromIntent(data);  
  2. String purchaseData = data.getStringExtra(RESPONSE_INAPP_PURCHASE_DATA);  
  3. String dataSignature = data.getStringExtra(RESPONSE_INAPP_SIGNATURE);  
就是purchaseData和dataSignature。验证支付就是需要这两个参数和publicKey,例子里的验证方法是写在Security.java里的。里面写了三个方法来完成支付结果的验证。
对于有本地支付服务器的游戏来说，这个操作就可以放到服务端了，客户端只需要把purchaseData和dataSignature传给支付服务器即可。然后有支付服务器把验证结果传给客户端，再做成功和失败的处理。成功后则要进行消耗商品的操作。对于没有支付服务器的游戏来说，我个人觉得本地的操作要达到安全，还是比较难的。不过对于服务器验证支付结果，也是存在风险的，只是风险要小。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.     * Verifies that the data was signed with the given signature, and returns  
  3.     * the verified purchase. The data is in JSON format and signed  
  4.     * with a private key. The data also contains the {@link PurchaseState}  
  5.     * and product ID of the purchase.  
  6.     * @param base64PublicKey the base64-encoded public key to use for verifying.  
  7.     * @param signedData the signed JSON string (signed, not encrypted)  
  8.     * @param signature the signature for the data, signed with the private key  
  9.     */  
  10.    public static boolean verifyPurchase(String base64PublicKey, String signedData, String signature) {  
  11.        if (TextUtils.isEmpty(signedData) || TextUtils.isEmpty(base64PublicKey) ||  
  12.                TextUtils.isEmpty(signature)) {  
  13.            Log.e(TAG, "Purchase verification failed: missing data.");  
  14.            return false;  
  15.        }  
  16.   
  17.        PublicKey key = Security.generatePublicKey(base64PublicKey);  
  18.        return Security.verify(key, signedData, signature);  
  19.    }  
  20.   
  21.    /**  
  22.     * Generates a PublicKey instance from a string containing the  
  23.     * Base64-encoded public key.  
  24.     *  
  25.     * @param encodedPublicKey Base64-encoded public key  
  26.     * @throws IllegalArgumentException if encodedPublicKey is invalid  
  27.     */  
  28.    public static PublicKey generatePublicKey(String encodedPublicKey) {  
  29.        try {  
  30.            byte[] decodedKey = Base64.decode(encodedPublicKey);  
  31.            KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);  
  32.            return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));  
  33.        } catch (NoSuchAlgorithmException e) {  
  34.            throw new RuntimeException(e);  
  35.        } catch (InvalidKeySpecException e) {  
  36.            Log.e(TAG, "Invalid key specification.");  
  37.            throw new IllegalArgumentException(e);  
  38.        } catch (Base64DecoderException e) {  
  39.            Log.e(TAG, "Base64 decoding failed.");  
  40.            throw new IllegalArgumentException(e);  
  41.        }  
  42.    }  
  43.   
  44.    /**  
  45.     * Verifies that the signature from the server matches the computed  
  46.     * signature on the data.  Returns true if the data is correctly signed.  
  47.     *  
  48.     * @param publicKey public key associated with the developer account  
  49.     * @param signedData signed data from server  
  50.     * @param signature server signature  
  51.     * @return true if the data and signature match  
  52.     */  
  53.    public static boolean verify(PublicKey publicKey, String signedData, String signature) {  
  54.        Signature sig;  
  55.        try {  
  56.            sig = Signature.getInstance(SIGNATURE_ALGORITHM);  
  57.            sig.initVerify(publicKey);  
  58.            sig.update(signedData.getBytes());  
  59.            if (!sig.verify(Base64.decode(signature))) {  
  60.                Log.e(TAG, "Signature verification failed.");  
  61.                return false;  
  62.            }  
  63.            return true;  
  64.        } catch (NoSuchAlgorithmException e) {  
  65.            Log.e(TAG, "NoSuchAlgorithmException.");  
  66.        } catch (InvalidKeyException e) {  
  67.            Log.e(TAG, "Invalid key specification.");  
  68.        } catch (SignatureException e) {  
  69.            Log.e(TAG, "Signature exception.");  
  70.        } catch (Base64DecoderException e) {  
  71.            Log.e(TAG, "Base64 decoding failed.");  
  72.        }  
  73.        return false;  
  74.    }  
PublicKey:
这个PublicKey是用来验证支付结果的，所以这绝对是个Key，不可以让其他人知道的，这个Key放到支付服务器端，本地不存。
samples里的这段代码写的很有意思，能看出笑点不？
单机游戏的话，想办法把这个key存到某个地方加个密什么的，最好不要直接写到代码里。（其实对于单机游戏，如果没有自己的服务器来验证支付结果，本地不管如何操作，都是很容易被破解的，如果游戏比较大卖，推荐自己写个支付服务器端来验证支付结果）。
[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. /* base64EncodedPublicKey should be YOUR APPLICATION'S PUBLIC KEY  
  2.  * (that you got from the Google Play developer console). This is not your  
  3.  * developer public key, it's the *app-specific* public key.  
  4.  *  
  5.  * Instead of just storing the entire literal string here embedded in the  
  6.  * program,  construct the key at runtime from pieces or  
  7.  * use bit manipulation (for example, XOR with some other string) to hide  
  8.  * the actual key.  The key itself is not secret information, but we don't  
  9.  * want to make it easy for an attacker to replace the public key with one  
  10.  * of their own and then fake messages from the server.  
  11.  */  
  12. String base64EncodedPublicKey = "CONSTRUCT_YOUR_KEY_AND_PLACE_IT_HERE";  
  13.   
  14. // Some sanity checks to see if the developer (that's you!) really followed the  
  15. // instructions to run this sample (don't put these checks on your app!)  
  16. if (base64EncodedPublicKey.contains("CONSTRUCT_YOUR")) {  
  17.     throw new RuntimeException("Please put your app's public key in MainActivity.java. See README.");  
  18. }  
  19. if (getPackageName().startsWith("com.example")) {  
  20.     throw new RuntimeException("Please change the sample's package name! See README.");  
  21. }  

本地服务器验证补充： 
关于支付结果的验证，本地服务器除了用publicKey做签名验证外，还可以到Google后台请求下支付结果验证。这个需要本地服务器和Google服务器交互通信。可以参考这个文档。

不过对于国内的开发者而言，在Google日益被封锁加重的情况下，在与Google服务器通信上绝对会有障碍，因为通信阻碍，会导致你验证失败，所以这个功能可选，有兴趣的可以添加上。
补充1：
如果是直接用samples的代码的话还需要注意几点。第一，把错误提示改成用户友好型的。因为samples的错误提示主要是给开发者看的，所以提示的很详细，但是用户不需要，你只要告诉用户成功，失败以及简单的失败原因就行了。第二，在发布正式版时把打印信息关掉。第三，修改类名和变量名。
补充2：
如果在测试支付时遇到一下错误，可做的处理。
1.当前应用程序不支持购买此商品:确定你手机上装的程序包名和签名和后台上传的一致。p.s.上传后台后APK需要等一段时间才能生效。
2.购买的商品不存在 ：确保你代码里的商品名字和后台的一致，如果一致，则可能需要等一两个小时再测试，Google后台的问题。
3.loading了很长时间，最后给你提示未知错误：这个不管它，Google后台的问题，等会再测。
最后国内开发者确保是在vpn下进行测试！！！！
写在后面：
以上就是Google In-app Billing的代码添加了，其实就是把samples讲了一下吐舌头，所以还是推荐去看下官方文档和samples吧，在那里你会学到更多。
                                             
        0        0           
	
				
		









 中国人才流失数据
    		中国人才流失数据



原创粉丝点击



		

热门IT博客


加州大学欧文分校 知乎加州大学欧文分校 知乎




java 弱引用java 弱引用




淘宝手机类目排名




python与nodejs




网络手游赚钱排行榜




无敌淘宝网下载




mac版本pr怎么降噪音




绣花打版用什么软件




精仿浪琴手表淘宝店铺




apache ant 1.9.3 bin




手机画漫画的软件




纯html5游戏源码




软件合集下载




进出口业务流程知乎




美工设计工作流程




手机淘宝怎样交电费




hashmapput源码




网络歌手夕阳醉了




网易跟帖知乎




淘宝新店首页怎么装修



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    思考的意思
    思考是
    许霆案思考
    换位思考的本质
    思考名言警句
    思考的近义词
    像山那样思考
    关于思考的名言
    换位思考作文
    2018版毛概思考题答案文库
    思考林胞磷胆碱钠胶囊
    思考者雕像托腮还是顶额头
    换位思考的句子
    换位思考图片
    人类一思考上帝就发笑
    思考的名言警句
    像山那样思考教案
    换位思考的例子
    独立思考的重要性
    换位思考例子
    换位思考的名言
    像山那样思考ppt
    换位思考名言
    思考人生的句子
    人在思考的图片
    关于思考的句子
    有关思考的名言
    关于思考的作文
    2018毛概课后思考题答案
    密立根油滴实验思考题
    思茅金凤
    思茅坪
    思茅蛇菰
    思茅
    思茅货运
    思茅在哪里
    思茅哪里好玩
    普洱思茅
    思茅景点
    思茅吧
    云南思茅


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里