如何在Android应用程序中实现应用内计费？

Question

看来在Android应用程序中实现应用内计费是相当复杂的。我怎么能这样做呢？ SDK 中的示例应用程序只有一个 Activity，这对于像我这样具有多个 Activity 的应用程序来说过于简化了。

Answer 1

好吧，我会尝试解释一下我的经历。我不认为自己是这方面的专家，但几天来我伤透了脑筋。

对于初学者来说，我在尝试理解示例和应用程序的工作流程时经历了一段非常糟糕的时光。我认为最好从一个简单的示例开始，但是将代码分成小块并且不知道是否破坏了任何内容非常困难。我将告诉您我拥有什么以及我对示例进行了哪些更改以使其正常工作。

我有一个活动，我的所有购买都来自其中。它被称为专业版。

首先，您应该使用公共市场开发人员密钥更新 Security 类中的变量 base64EncodedPublicKey，否则您将看到一个不错的异常。

好吧，我将 Activity 绑定到 BillingService，如下所示：

      public class Pro extends TrackedActivity implements OnItemClickListener {

            private BillingService mBillingService;
            private BillingPurchaseObserver mBillingPurchaseObserver;
            private Handler mHandler;

            @Override
            protected void onCreate(Bundle savedInstanceState) {    
                super.onCreate(savedInstanceState);     
                setContentView(R.layout.pro);


                //Do my stuff

                mBillingService = new BillingService();
                mBillingService.setContext(getApplicationContext());

                mHandler = new Handler();
                mBillingPurchaseObserver = new BillingPurchaseObserver(mHandler);

            }

        }



    @Override
    protected void onStart() {
       //Register the observer to the service
        super.onStart();
        ResponseHandler.register(mBillingPurchaseObserver);   
    }


    @Override
    protected void onStop() {
        //Unregister the observer since you dont need anymore
        super.onStop();
        ResponseHandler.unregister(mBillingPurchaseObserver);
    }

    @Override
    protected void onDestroy() {
       //Unbind the service
        super.onDestroy();
        mBillingService.unbind();
    }

这样，所有购买都会与该服务通信，然后该服务会将 JSON 请求发送到市场。您可能认为购买是在同一时刻进行的，但事实并非如此。您发送请求，购买可能会在几分钟或几小时后完成。我认为这主要是服务器过载和信用卡审批问题。

然后我有一个包含我的商品的 ListView，并在每个商品上打开一个 AlertDialog，邀请他们购买该商品。当他们单击某个项目时，我会执行以下操作：

  private class BuyButton implements DialogInterface.OnClickListener {

       private BillingItem item = null;
       private String developerPayload;

       public BuyButton(BillingItem item, String developerPayload) {
        this.item = item;
        this.developerPayload = developerPayload;
        }

            @Override
            public void onClick(DialogInterface dialog, int which) {

                if (GeneralHelper.isOnline(getApplicationContext())){
                    //I track the buy here with GA SDK. 

        mBillingService.requestPurchase(this.item.getSku(), this.developerPayload);             
                } else {                
                    Toast.makeText(getApplicationContext(), R.string.msg_not_online, Toast.LENGTH_SHORT).show();
                }

            }

        }

好吧，您应该看到市场打开，并且用户完成或取消购买。

那么重要的是我的 PurChaseObserver，它处理市场发送的所有事件。这是它的精简版本，但您应该明白要点（通过代码查看我的评论）：

private class BillingPurchaseObserver extends PurchaseObserver {
        public BillingPurchaseObserver(Handler handler) {
            super(Pro.this, handler);
        }

        @Override
        public void onBillingSupported(boolean supported) {

            if (supported) {
                //Enable buy functions. Not required, but you can do stuff here. The market first checks if billing is supported. Maybe your country is not supported, for example. 
            } else {
                Toast.makeText(getApplicationContext(), R.string.billing_not_supported, Toast.LENGTH_LONG).show();
            }
        }

        @Override
        public void onPurchaseStateChange(PurchaseState purchaseState, String itemId,
                int quantity, long purchaseTime, String developerPayload) {

//This is the method that is called when the buy is completed or refunded I believe. 
// Here you can do something with the developerPayload. Its basically a Tag you can use to follow your transactions. i dont use it. 

        BillingItem item = BillingItem.getBySku(getApplicationContext(), itemId);

        if (purchaseState == PurchaseState.PURCHASED) {
            if (item != null){
//This is my own implementation that sets the item purchased in my database. BillingHelper is a class with methods I use to check if the user bought an option and update the UI. You should also check for refunded. You can see the Consts class to find what you need to check for. 

                    boolean resu = item.makePurchased(getApplicationContext());
                    if (resu){                      
                        Toast.makeText(getApplicationContext(), R.string.billing_item_purchased, Toast.LENGTH_LONG).show();
                    }
                }
            }
        }

        private void trackPurchase(BillingItem item, long purchaseTime) {           
            //My code to track the purchase in GA
        }

        @Override
        public void onRequestPurchaseResponse(RequestPurchase request,
                ResponseCode responseCode) {

               //This is the callback that happens when you sent the request. It doesnt mean you bought something. Just that the Market received it. 

            if (responseCode == ResponseCode.RESULT_OK) {               

                Toast.makeText(getApplicationContext(), R.string.billing_item_request_sent, Toast.LENGTH_SHORT).show();

            } else if (responseCode == ResponseCode.RESULT_USER_CANCELED) {
                //The user canceled the item. 
            } else {
            //If it got here, the Market had an unexpected problem. 
            }
        }

        @Override
        public void onRestoreTransactionsResponse(RestoreTransactions request,
                ResponseCode responseCode) {
            if (responseCode == ResponseCode.RESULT_OK) {
//Restore transactions should only be run once in the lifecycle of your application unless you reinstalled the app or wipe the data. 

                SharedPreferences.Editor edit = PreferencesHelper.getInstance().getDefaultSettings(getApplicationContext()).edit();
                edit.putBoolean(Consts.DB_INITIALIZED, true);
                edit.commit();

            } else {
    //Something went wrong
            }
        }
    }

而且我相信您不需要编辑其他任何内容。其余代码“有效”。
您可以首先在自己的项目“android.test.purchased”中尝试使用示例 SKU。到目前为止，我已经对此进行了测试并且它有效，但是我仍然需要涵盖诸如退款状态之类的所有内容。在这种情况下，我让用户保留这些功能，但我想在修改它之前确保它完美运行。

我希望它对您和其他人有所帮助。

Answer 2

V3：这是一个快速入门教程。他正在使用 google 示例中的帮助程序类（Trivial Drive）...就像第一个“Hello Billing”一样好..

http://www.techotopia.com/index.php/Integrating_Google_Play_In-app_Billing_into_an_Android_Application_%E2%80% 93_A_教程

Answer 3

这里有一个 Android In-App Billing v3 的完整示例，并附有屏幕截图。请查看教程：
使用 ServiceConnection 的 Android 应用内结算 v3类

希望能有所帮助。

如需更多说明，请阅读本教程：在版本 3 API 中实现应用内结算< /a>

在我们的项目中集成应用内计费库的步骤

更新您的 AndroidManifest.xml 文件。

创建 ServiceConnection 并将其绑定到 IInAppBillingService。

将应用程序内计费请求从您的应用程序发送到 IInAppBillingService。

处理来自 Google Play 的应用内结算响应。

更新AndroidManifest.xml

<uses-permission android:name="com.android.vending.BILLING" />

在Manifest.xml文件中添加权限

将 AIDL 文件添加到您的项目中

构建您的应用程序。您应该在项目的 /gen 目录中看到一个名为 IInAppBillingService.java 的生成文件。

更新 build.gradle 文件

apply plugin: 'com.android.application'
android {
    compileSdkVersion 24
    buildToolsVersion "24.0.0"
    defaultConfig {
        applicationId "com.inducesmile.androidinapppurchase"
        minSdkVersion 14
        targetSdkVersion 24
        versionCode 2
        versionName "1.1"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:24.1.1'
    compile 'com.intuit.sdp:sdp-android:1.0.3'
    compile 'com.android.support:support-annotations:24.1.1'
    compile 'org.jetbrains:annotations-java5:15.0'
}

InAppPurchaseActivity.java 和 Activity_in_app_purchase.xml

中的依赖项这将为我们的应用程序用户提供进行应用程序内购买的机会。在布局文件中，我们将为用户提供以不同面额进行购买的机会。

InAppPurchaseActivity.java

注意： getAllUserPurchase() 和 itemPurchaseAvailability() 方法应在非 UI 线程中调用，以避免应用程序崩溃。

public class InAppPurchaseActivity extends AppCompatActivity {
    private static final String TAG = InAppPurchaseActivity.class.getSimpleName();
    private IInAppBillingService mService;
    private CustomSharedPreference customSharedPreference;
    String[] productIds = new String[]{Helper.ITEM_ONE_ID, Helper.ITEM_TWO_ID, Helper.ITEM_THREE_ID};
    private ImageView buyOneButton, buyTwoButton, buyThreeButton;
    private static final char[] symbols = new char[36];
    static {
        for (int idx = 0; idx < 10; ++idx)
            symbols[idx] = (char) ('0' + idx);
        for (int idx = 10; idx < 36; ++idx)
            symbols[idx] = (char) ('a' + idx - 10);
    }
    private String appPackageName;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_in_app_purchase);
        appPackageName = this.getPackageName();
        Intent serviceIntent = new Intent("com.android.vending.billing.InAppBillingService.BIND");
        serviceIntent.setPackage("com.android.vending");
        bindService(serviceIntent, mServiceConn, Context.BIND_AUTO_CREATE);
        customSharedPreference = new CustomSharedPreference(InAppPurchaseActivity.this);
        buyOneButton = (ImageView)findViewById(R.id.buy_one);
        buyOneButton.setVisibility(View.GONE);
        assert buyOneButton != null;
        buyOneButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(!isBillingSupported()){
                    Helper.displayMessage(InAppPurchaseActivity.this, getString(R.string.in_app_support));
                    return;
                }
                purchaseItem(Helper.ITEM_ONE_ID);
            }
        });
        buyTwoButton = (ImageView)findViewById(R.id.buy_two);
        buyTwoButton.setVisibility(View.GONE);
        assert buyTwoButton != null;
        buyTwoButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(!isBillingSupported()){
                    Helper.displayMessage(InAppPurchaseActivity.this, getString(R.string.in_app_support));
                    return;
                }
                purchaseItem(Helper.ITEM_TWO_ID);
            }
        });
        buyThreeButton = (ImageView)findViewById(R.id.buy_three);
        buyThreeButton.setVisibility(View.GONE);
        assert buyThreeButton != null;
        buyThreeButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(!isBillingSupported()){
                    Helper.displayMessage(InAppPurchaseActivity.this, getString(R.string.in_app_support));
                    return;
                }
                purchaseItem(Helper.ITEM_THREE_ID);
            }
        });
    }
    ServiceConnection mServiceConn = new ServiceConnection() {
        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
        }
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = IInAppBillingService.Stub.asInterface(service);
            AvailablePurchaseAsyncTask mAsyncTask = new AvailablePurchaseAsyncTask(appPackageName);
            mAsyncTask.execute();
        }
    };
    private void purchaseItem(String sku){
        String generatedPayload = getPayLoad();
        customSharedPreference.setDeveloperPayLoad(generatedPayload);
        try {
            Bundle buyIntentBundle = mService.getBuyIntent(3, getPackageName(), sku, "inapp", generatedPayload);
            PendingIntent pendingIntent = buyIntentBundle.getParcelable("BUY_INTENT");
            try {
                startIntentSenderForResult(pendingIntent.getIntentSender(), Helper.RESPONSE_CODE, new Intent(), Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(0));
            } catch (IntentSender.SendIntentException e) {
                e.printStackTrace();
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == Helper.RESPONSE_CODE) {
            int responseCode = data.getIntExtra("RESPONSE_CODE", 0);
            String purchaseData = data.getStringExtra("INAPP_PURCHASE_DATA");
            String dataSignature = data.getStringExtra("INAPP_DATA_SIGNATURE");
            if (resultCode == RESULT_OK) {
                try {
                    JSONObject purchaseJsonObject = new JSONObject(purchaseData);
                    String sku = purchaseJsonObject.getString("productId");
                    String developerPayload = purchaseJsonObject.getString("developerPayload");
                    String purchaseToken = purchaseJsonObject.getString("purchaseToken");
                    //the developerPayload value is better stored in remote database but in this tutorial
                    //we will use a shared preference
                    for(int i = 0; i < productIds.length; i++){
                        if(productIds[i].equals(sku) && developerPayload.equals(customSharedPreference.getDeveloperPayload())){
                            customSharedPreference.setPurchaseToken(purchaseToken);
                            //access to private content
                            Intent contentIntent = new Intent(InAppPurchaseActivity.this, PrivateContentActivity.class);
                            startActivity(contentIntent);
                        }
                    }
                }
                catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private String getPayLoad(){
        RandomString randomString = new RandomString(36);
        String payload = randomString.nextString();
        return payload;
    }
    public class RandomString {
        private final Random random = new Random();
        private final char[] buf;
        public RandomString(int length) {
            if (length < 1)
                throw new IllegalArgumentException("length < 1: " + length);
            buf = new char[length];
        }
        public String nextString() {
            for (int idx = 0; idx < buf.length; ++idx)
                buf[idx] = symbols[random.nextInt(symbols.length)];
            return new String(buf);
        }
    }
    public final class SessionIdentifierGenerator {
        private SecureRandom random = new SecureRandom();
        public String nextSessionId() {
            return new BigInteger(130, random).toString(32);
        }
    }
    private class AvailablePurchaseAsyncTask extends AsyncTask<Void, Void, Bundle> {
        String packageName;
        public AvailablePurchaseAsyncTask(String packageName){
            this.packageName = packageName;
        }
        @Override
        protected Bundle doInBackground(Void... voids) {
            ArrayList<String> skuList = new ArrayList<String>();
            skuList.add(Helper.ITEM_ONE_ID);
            skuList.add(Helper.ITEM_TWO_ID);
            skuList.add(Helper.ITEM_THREE_ID);
            Bundle query = new Bundle();
            query.putStringArrayList(Helper.ITEM_ID_LIST, skuList);
            Bundle skuDetails = null;
            try {
                skuDetails = mService.getSkuDetails(3, packageName, "inapp", query);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            return skuDetails;
        }
        @Override
        protected void onPostExecute(Bundle skuDetails) {
            List<AvailablePurchase> canPurchase = new ArrayList<AvailablePurchase>();
            int response = skuDetails.getInt("RESPONSE_CODE");
            if (response == 0) {
                ArrayList<String> responseList = skuDetails.getStringArrayList("DETAILS_LIST");
                if(responseList != null){
                    for (String thisResponse : responseList) {
                        JSONObject object = null;
                        try {
                            object = new JSONObject(thisResponse);
                            String sku = object.getString("productId");
                            String price = object.getString("price");
                            canPurchase.add(new AvailablePurchase(sku, price));
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            if(checkIfPurchaseIsAvailable(canPurchase, productIds[0])){
                buyOneButton.setVisibility(View.VISIBLE);
            }else{
                buyOneButton.setVisibility(View.GONE);
            }
            if(checkIfPurchaseIsAvailable(canPurchase, productIds[1])){
                buyTwoButton.setVisibility(View.VISIBLE);
            }else{
                buyTwoButton.setVisibility(View.GONE);
            }
            if(checkIfPurchaseIsAvailable(canPurchase, productIds[2])){
                buyThreeButton.setVisibility(View.VISIBLE);
            }else{
                buyThreeButton.setVisibility(View.GONE);
            }
        }
    }
    @org.jetbrains.annotations.Contract("null, _ -> false")
    private boolean checkIfPurchaseIsAvailable(List<AvailablePurchase> all, String productId){
        if(all == null){ return false;}
        for(int i = 0; i < all.size(); i++){
            if(all.get(i).getSku().equals(productId)){
                return true;
            }
        }
        return false;
    }
    public boolean isBillingSupported(){
        int response = 1;
        try {
            response = mService.isBillingSupported(3, getPackageName(), "inapp");
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        if(response > 0){
            return false;
        }
        return true;
    }
    public void consumePurchaseItem(String purchaseToken){
        try {
            int response = mService.consumePurchase(3, getPackageName(), purchaseToken);
            if(response != 0){
                return;
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    public Bundle getAllUserPurchase(){
        Bundle ownedItems = null;
        try {
            ownedItems = mService.getPurchases(3, getPackageName(), "inapp", null);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        return ownedItems;
    }
    public List<UserPurchaseItems> extractAllUserPurchase(Bundle ownedItems){
        List<UserPurchaseItems> mUserItems = new ArrayList<UserPurchaseItems>();
        int response = ownedItems.getInt("RESPONSE_CODE");
        if (response == 0) {
            ArrayList<String> ownedSkus = ownedItems.getStringArrayList("INAPP_PURCHASE_ITEM_LIST");
            ArrayList<String>  purchaseDataList = ownedItems.getStringArrayList("INAPP_PURCHASE_DATA_LIST");
            ArrayList<String>  signatureList = ownedItems.getStringArrayList("INAPP_DATA_SIGNATURE_LIST");
            String continuationToken = ownedItems.getString("INAPP_CONTINUATION_TOKEN");
            if(purchaseDataList != null){
                for (int i = 0; i < purchaseDataList.size(); ++i) {
                    String purchaseData = purchaseDataList.get(i);
                    assert signatureList != null;
                    String signature = signatureList.get(i);
                    assert ownedSkus != null;
                    String sku = ownedSkus.get(i);
                    UserPurchaseItems allItems = new UserPurchaseItems(sku, purchaseData, signature);
                    mUserItems.add(allItems);
                }
            }
        }
        return mUserItems;
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mService != null) {
            unbindService(mServiceConn);
        }
    }
}

创建 Helper 包目录

创建一个新的包文件夹并将其命名为 helpers。在包内，创建一个新的 java 文件 Helper.java。

Helper.java

public class Helper {
    public static final String ITEM_ID_LIST = "ITEM_ID_LIST";
    public static final String ITEM_ONE_ID = "productone";
    public static final String ITEM_TWO_ID = "producttwo";
    public static final String ITEM_THREE_ID = "productthree";
    public static final int RESPONSE_CODE = 1001;
    public static final String SHARED_PREF = "shared_pref";
    public static final String DEVELOPER_PAYLOAD = "developer_payload";
    public static final String PURCHASE_TOKEN = "purchase_token";
    public static void displayMessage(Context context, String message){
        Toast.makeText(context.getApplicationContext(), message, Toast.LENGTH_LONG).show();
    }
}

测试应用内结算购买

1. 创建 Google+ 帐户（不要使用主帐户）
2. 添加将在您的群组或社区中测试应用的用户。

您在应用内购买测试期间可能会遇到错误，

您请求的商品无法购买

解决方案 - 根据 Stackoverflow 的 AndreiBogdan 的说法，

所有功劳都归功于 Inducesmile 的 教程

Android 开发者博客还推荐了有关销售应用内产品的培训课程。要查看完整的实现并了解如何测试应用程序，请查看本教程：销售应用内产品

Answer 4

好吧，这是网上没有太多可用文档的事情之一，所以我将尽力一步一步解释所有内容。取自我的博客文章，这是一个更详细的版本（带有屏幕截图），在 Millibit 上。言归正传，

第一步：权限
这是最简单的一步。导航到您的manifest.xml 文件并在您的标签下添加以下行：

<uses-permission android:name="com.android.vending.BILLING" />

这将为您的应用授予访问应用内结算的权限。如果您的目标版本高于 API 22，则需要确保在运行时授予此权限。

第二步：Play 管理中心
现在您需要将应用程序上传到 Google Play 管理中心。我们还没有向公众发布我们的应用程序（不用担心），我们只是将其上传到 BETA RELEASE 部分，这将使我们能够测试应用内购买。我们需要这样做的原因是 Google 需要上传您的 APK 的某个版本才能使计费流程真正发挥作用。

1. 转至https://play.google.com/apps/publish/< /p>

2. < p>创建应用程序

3. 按照设置应用程序的步骤

4. 转到应用程序版本

5. 导航到测试版

6. 创建在 Android studio 中创建应用的 APK，并将其上传到 Play Console 中的 Beta 版本

（在发布之前，请确保您已经填写了商店列表，内容分级、定价和分发）

7. 点击魔术按钮（发布！）

第三步：设置项目
好的，这是您必须复制并粘贴一堆文件的部分。

首先，获取 这个 文件，下载它，并将其放在 src/main 下，它应该将自己构建到一个文件夹中
接下来，获取 整个 util 文件夹并将其粘贴到src/java 文件夹中。 然后重建您的项目以解决错误。
Util 文件夹包含以下类：

• IabBroadcastReceiver
• IabException
• IabHelper
• IabResult
• 库存
• 采购
• 安全
• SkuDetails

第四步： 创建产品

1. 创建托管产品

2. 单击保存并创建“定价模板”

在这里，您将选择该产品的价格。您可以选择不同国家/地区的价格，或者如果您只选择价格下的所有国家/地区，则价格会自动调整：

3. 确保应用内商品最后一次被激活并与控制台中的正确应用程序链接。

最后，记下您的产品 ID。我们将在接下来的几个步骤中使用此 ID。

4. 获取 Base64EncodedString

前往“服务和服务” API”并获取您的 Base64EncodedString。将其复制并粘贴到记事本中的某个位置，以便您可以访问它。不要与任何人分享这个，他们将能够用它来做恶意的事情。

第五步：终于！我们可以开始编码：
我们首先会绑定应用内计费库，并查询用户已购买/未购买的商品。然后，我们将购买我们之前设置的产品。

首先，导入我们之前设置的所有内容：

import util.*;

现在我们将使用一个名为 mHelper 的 IabHelper 对象，我们将用它来做所有事情。

base64EncodedPublicKey = ""; //PUT YOUR BASE64KEY HERE

mHelper = new IabHelper(this, base64EncodedPublicKey);
mHelper.enableDebugLogging(false); //set to false in real app


mHelper.startSetup(new IabHelper.OnIabSetupFinishedListener() {
    public void onIabSetupFinished(IabResult result) {
        if (!result.isSuccess()) {
            // Oh no, there was a problem.

            if (result.getResponse() == 3) {
                new AlertDialog.Builder(MainActivity.this)
                        .setTitle("In app billing")
                        .setMessage("This device is not compatible with In App Billing, so" +
                                " you may not be able to buy the premium version on your phone. ")
                        .setPositiveButton("Okay", null)
                        .show();
            }

            Log.v(TAG, "Problem setting up In-app Billing: " + result);
        } else {
            Log.v(TAG, "YAY, in app billing set up! " + result);
            try {
                mHelper.queryInventoryAsync(mGotInventoryListener); //Getting inventory of purchases and assigning listener
            } catch (IabHelper.IabAsyncInProgressException e) {
                e.printStackTrace();
            }
        }
    }
});

好吧，让我来分析一下这里发生了什么。基本上，我们调用“startSetup”来初始化我们的“IabHelper”。如果设置成功，我们会查询用户已经购买了哪些商品，并将响应存储在 mGotInventoryListener 中，我们接下来将对其进行编码：

IabHelper.QueryInventoryFinishedListener mGotInventoryListener
        = new IabHelper.QueryInventoryFinishedListener() {
    public void onQueryInventoryFinished(IabResult result,
                                         Inventory inventory) {

        i = inventory;

        if (result.isFailure()) {
            // handle error here

            Log.v(TAG, "failure in checking if user has purchases");
        } else {
            // does the user have the premium upgrade?
            if (inventory.hasPurchase("premium_version")) {

                premiumEditor.putBoolean("hasPremium", true);
                premiumEditor.commit(); 

                Log.v(TAG, "Has purchase, saving in storage");

            } else {

                premiumEditor.putBoolean("hasPremium", false);
                premiumEditor.commit();

                Log.v(TAG, "Doesn't have purchase, saving in storage");

            }
        }
    }
};

上面的代码非常不言自明。基本上，它只是检查用户已经购买了什么。现在我们知道用户是否已经购买了我们的产品，我们就知道是否要求他们购买我们的产品！如果他们以前从未购买过我们的产品，让我们开始一个购买请求：

public void buyPremium() {
    try {

     mHelper.flagEndAsync();//If any async is going, make sure we have it stop eventually
     mHelper.launchPurchaseFlow(this, "premium_version", 9, mPurchaseFinishedListener, "SECURITYSTRING"); //Making purchase request and attaching listener
    } catch (Exception e) {
        e.printStackTrace();

mHelper.flagEndAsync();//If any async is going, make sure we have it stop eventually




        new AlertDialog.Builder(MainActivity.this)
                .setTitle("Error")
                .setMessage("An error occurred in buying the premium version. Please try again.")
                .setPositiveButton("Okay", null)
                .show();
    }
}


    @Override

protected void onActivityResult(int requestCode, int resultCode, Intent data) {

    Log.d(TAG, "onActivityResult(" + requestCode + "," + resultCode + "," + data);

    // Pass on the activity result to the helper for handling

    if (!mHelper.handleActivityResult(requestCode, resultCode, data)) {

    }

    else 
        Log.d(TAG, "onActivityResult handled by IABUtil.");
    }

}

IabHelper.OnIabPurchaseFinishedListener mPurchaseFinishedListener
        = new IabHelper.OnIabPurchaseFinishedListener() {
    public void onIabPurchaseFinished(IabResult result, Purchase purchase) {

        Log.v(TAG, "purchase finished");

        if (purchase != null) {

            if (purchase.getSku().equals("premium_version")) {

                Toast.makeText(MainActivity.this, "Purchase successful!", Toast.LENGTH_SHORT).show();

                premiumEditor.putBoolean("hasPremium", true);
                premiumEditor.commit();
            }
        } else {
            return;
        }
        if (result.isFailure()) {
            return;
        }
    }
};

这里我们使用以下内容购买商品（使用我们之前在游戏控制台中生成的 ID）：

 mHelper.launchPurchaseFlow(this, "premium_version", 9, mPurchaseFinishedListener, "SECURITYSTRING"); //Making purchase request and attaching listener

请注意，我们将 mPurchaseFinishedListener 传递给了参数。这意味着购买的结果将返回给这个监听器。然后，我们只需检查购买是否为空，如果不为空，则奖励用户他们购买的任何功能。

别让听众泄密！当应用程序销毁时，我们必须销毁它们。

@Override
public void onDestroy() {
    super.onDestroy();
    if (mHelper != null)
        try {
            mHelper.dispose();
            mHelper = null;

        } catch (IabHelper.IabAsyncInProgressException e) {
            e.printStackTrace();
        }
}

最后，如果您想使用您购买的产品并使其可供再次购买，您可以轻松做到这一点。一个例子是，如果用户为虚拟汽车购买了汽油，但汽油用完了。他们需要再次购买相同的产品，您可以通过消费将其用于第二次购买：

public void consume(){

    //MAKING A QUERY TO GET AN ACCURATE INVENTORY
    try {
        mHelper.flagEndAsync(); //If any async is going, make sure we have it stop eventually

        mHelper.queryInventoryAsync(mGotInventoryListener); //Getting inventory of purchases and assigning listener

        if(i.getPurchase("gas")==null){
            Toast.makeText(this, "Already consumed!", Toast.LENGTH_SHORT).show();
        }
    } catch (IabHelper.IabAsyncInProgressException e) {
        e.printStackTrace();

        Toast.makeText(this, "Error, try again", Toast.LENGTH_SHORT).show();
        mHelper.flagEndAsync();//If any async is going, make sure we have it stop eventually
    }

    //ACTUALLY CONSUMING
    try {
        mHelper.flagEndAsync();//If any async is going, make sure we have it stop eventually

        this.mHelper.consumeAsync(this.i.getPurchase("gas"), new IabHelper.OnConsumeFinishedListener() {
            public void onConsumeFinished(Purchase paramAnonymousPurchase, IabResult paramAnonymousIabResult) {
//resell the gas to them
            }
        });

        return;
    } catch (IabHelper.IabAsyncInProgressException localIabAsyncInProgressException) {
        localIabAsyncInProgressException.printStackTrace();
        Toast.makeText(this, "ASYNC IN PROGRESS ALREADY!!!!" +localIabAsyncInProgressException, Toast.LENGTH_LONG).show();
        Log.v("myTag", "ASYNC IN PROGRESS ALREADY!!!");

        mHelper.flagEndAsync();
    }
}

就是这样！您现在可以开始赚钱了。真的就是这么简单！

再次强调，如果您想要本教程的更详细版本（包含屏幕截图和图片），请访问 原始帖子在这里。如果您还有其他问题，请在评论中告诉我。

Answer 5

为了更好地了解如何使用 google play billing 库进行应用内结算，请参阅下面的流程图：

您可以按照我在本文中解释的逐步集成进行操作：

https://medium.com/@surabhichoudhary/in -app-purchasing-with-google-play-billing-library-6a72e289a78e

如果您需要演示关于这一点，这是项目链接：https://github.com/surabhi6/InAppPurchaseDemo

Answer 6

如果您想使用一个简单的库在 Google Play 和 Amazon Appstore 上发布，您可以使用 RoboBillingLibrary。它将两者的细节抽象为一个易于使用的库。详细说明位于 Github 页面上。

Answer 7

我开发了 Android 应用内计费库，它使用“com.android.billingclient:billing:2.1.0”

以下是它的属性：

1. “INAPP”支持库
2. 稍后将支持订阅！
3. 库为您的产品使用 Roomdb，您不需要实施来检查产品的状态
4. 库使用共享依赖项。您的应用程序的大小将更小，并且不需要 multidex
5. 库会在每次应用程序启动时检查您的产品状态。您可以获得状态（购买或未购买）！
6. 客户购买的每件产品都需要在 SUCCES 状态中得到“确认”。图书馆正在为你做这个！
7. 库支持（立即购买、响应延迟购买 succus、响应延迟购买拒绝、用户取消购买）

库源

Answer 8

基本上你需要在两个地方购买代码

首先在你的 MainActivity 中
您的应用程序每次都会打开，因此请检查那里的购买状态。需要实施购买更新的监听器。

其次，当单击按钮开始购买时。因此，您的按钮所在的位置其活动需要
实施购买更新的监听器。
如果您的按钮位于 MainActivity 下，那么您只需要在一个地方（即 MainActivity）购买代码。

有关更多信息，您可以在此处关注我的工作教程：

https://programtown.com/how-to-make-multiple-in-app-purchase-in-android-using-google-play-billing-library/