完整流程Google Pay 接入

最新推荐文章于 2025-01-24 15:52:09 发布
最新推荐文章于 2025-01-24 15:52:09 发布
阅读量6.6k 收藏 8
点赞数 3
文章标签： android sdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35431588/article/details/105514168
版权

前一段时间由于项目需求，产品需要接入Google Pay SDK,然后....大家都懂的...各种搜索，出现的文章要么就是很久以前的，要么就是各种问题,经过一番"泥里打滚"后，还是默默的选择了官方的教程文档,结果好吧官方的demo也不是直接能用的，经过一番修改后，最终测试通过了，目前线上使用中...代码里都有详细的注释，大家有不懂的可以评论区留言,第一次写博客，若有不适请多海涵哦

上代码

 

首先是一个购买管理类BillingManager

package com.example.googleiap;

import android.app.Activity;
import android.support.annotation.Nullable;
import android.util.Log;

import com.android.billingclient.api.AcknowledgePurchaseParams;
import com.android.billingclient.api.AcknowledgePurchaseResponseListener;
import com.android.billingclient.api.BillingClient;
import com.android.billingclient.api.BillingClient.BillingResponseCode;
import com.android.billingclient.api.BillingClient.SkuType;
import com.android.billingclient.api.BillingClient.FeatureType;
import com.android.billingclient.api.BillingClientStateListener;
import com.android.billingclient.api.BillingFlowParams;
import com.android.billingclient.api.BillingResult;
import com.android.billingclient.api.ConsumeParams;
import com.android.billingclient.api.ConsumeResponseListener;
import com.android.billingclient.api.Purchase;
import com.android.billingclient.api.Purchase.PurchasesResult;
import com.android.billingclient.api.PurchasesUpdatedListener;
import com.android.billingclient.api.SkuDetails;
import com.android.billingclient.api.SkuDetailsParams;
import com.android.billingclient.api.SkuDetailsResponseListener;


import java.io.IOError;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class BillingManager implements PurchasesUpdatedListener{

    private static final String TAG = "BillingManager";

    /*购买key*/
    private static final String BASE_64_ENCODED_PUBLIC_KEY = "这里填写你的Google后台生成的一串Base64秘钥";
    /*未初始化标记*/
    public static final int BILLING_MANAGER_NOT_INITIALIZED  = -1;
    /*客户端*/
    private BillingClient billingClient;

    /*活动*/
    private final Activity mActivity;

    /*监听*/
    private final BillingUpdatesListener mBillingUpdatesListener;

    /*是否连接成功*/
    private boolean mIsServiceConnected;

    /*客户端当前状态*/
    private @BillingResponseCode int curBillingClientResponseCode = BillingResponseCode.SERVICE_DISCONNECTED;

    /*商品列表*/
    private final List<Purchase> PurchaseList = new ArrayList<>();

    /*消耗令牌*/
    private Set<String> mTokensToBeConsumed;

    /*监听接口*/
    public interface BillingUpdatesListener{
        void onBillingClientSetupFinished();
        void onConsumeFinished(String token, @BillingResponseCode int result);
        void onPurchasesUpdated(List<Purchase> purchases);
        void onFailedHandle(@BillingResponseCode int result);
    }

    public BillingManager(Activity activity,final BillingUpdatesListener updatesListener){
        Log.d(TAG, "创建Billing客户端");
        mActivity = activity;
        mBillingUpdatesListener = updatesListener;
        billingClient = BillingClient.newBuilder(mActivity).enablePendingPurchases().setListener(this).build();
        Log.d(TAG, "开始设置信息");
        startServiceConnection(new Runnable() {
            @Override
            public void run() {
                mBillingUpdatesListener.onBillingClientSetupFinished();
                Log.d(TAG, "设置客户端成功，开始请求商品库存");
                OnQueryPurchases();
            }
        });

    }

    /*开始连接Play*/
    public void startServiceConnection(final Runnable executeOnSuccess){
        billingClient.startConnection(new BillingClientStateListener() {
            @Override
            public void onBillingSetupFinished(BillingResult billingResult) {
                Log.d(TAG, "Setup finished. Response code: " + billingResult);
                if(billingResult.getResponseCode() == BillingResponseCode.OK){
                    mIsServiceConnected = true;
                    if(executeOnSuccess != null){
                        executeOnSuccess.run();
                    }
                }
                curBillingClientResponseCode = billingResult.getResponseCode();
            }

            @Override
            public void onBillingServiceDisconnected() {
                mIsServiceConnected = false;
            }
        });
    }

    /*请求商品库存*/
    public void  OnQueryPurchases() {
        Runnable queryToExecute = new Runnable() {
            @Override
            public void run() {
                //系统当前时间
                long time = System.currentTimeMillis();
                //请求内购商品
                PurchasesResult purchasesResult = billingClient.queryPurchases(SkuType.INAPP);
                Log.i(TAG, "请求请内购商品花费时间:" + (System.currentTimeMillis() - time) + "ms");

                //支持订阅
                if(areSubscriptionsSupported()){
                    PurchasesResult subscriptionResult = billingClient.queryPurchases(SkuType.SUBS);

                    Log.i(TAG, "请求订阅商品后花费的时间: "
                            + (System.currentTimeMillis() - time) + "ms");

                    if(subscriptionResult.getResponseCode() == BillingResponseCode.OK){
                        Log.i(TAG, "请求订阅消息返回 Code: "
                                + subscriptionResult.getResponseCode()
                                + " res: " + subscriptionResult.getPurchasesList().size());

                        purchasesResult.getPurchasesList().addAll(subscriptionResult.getPurchasesList());
                    }
                    else {
                        Log.e(TAG, "获取订阅商品失败请见Code");
                    }
                }
                else if (purchasesResult.getResponseCode() == BillingResponseCode.OK){
                    Log.i(TAG, "跳过请求订阅商品，因为设备不支持");
                }
                else{
                    Log.w(TAG, "请求商品失败返回: "
                            + purchasesResult.getResponseCode());
                }
                onQueryPurchasesFinished(purchasesResult);
            }
        };

        executeServiceRequest(queryToExecute);
    }

    /*是否支持订阅*/
    public boolean areSubscriptionsSupported(){
        int responseCode = billingClient.isFeatureSupported(FeatureType.SUBSCRIPTIONS).getResponseCode();
        if(responseCode != BillingResponseCode.OK)
        {
            Log.w(TAG, "areSubscriptionsSupported() got an error response: " + responseCode);
        }
        return responseCode == BillingResponseCode.OK;
    }

    /*请求商品信息完成*/
    private void  onQueryPurchasesFinished(PurchasesResult result){
        if(billingClient == null || result.getResponseCode() != BillingResponseCode.OK){
            Log.w(TAG, "billingClient is null or result code (" + result.getResponseCode()
                    + ") was bad - quitting");
            return;
        }
        Log.d(TAG, "请求商品信息完成");
        PurchaseList.clear();
        onPurchasesUpdated(result.getBillingResult(),result.getPurchasesList());
    }

    /*更新商品*/
    @Override
    public void onPurchasesUpdated(BillingResult billingResult,List<Purchase> purchases){
        if(billingResult.getResponseCode() == BillingResponseCode.OK){
            for (Purchase purchase : purchases){
                HandlePurchase(purchase);
            }
            mBillingUpdatesListener.onPurchasesUpdated(PurchaseList);
        }
        else{
            if(billingResult.getResponseCode() == BillingResponseCode.USER_CANCELED){
                Log.i(TAG, "onPurchasesUpdated() - 用户取消购买当前商品");
            }
            else{
                Log.w(TAG, "onPurchasesUpdated() got unknown resultCode: " + billingResult.getResponseCode());
            }
            mBillingUpdatesListener.onFailedHandle(billingResult.getResponseCode());
        }

    }

    /*商品处理*/
    private void HandlePurchase(Purchase purchase){
        //验证签名数据
        Log.i(TAG,"getSignature => "+ purchase.getSignature());
        if(!VerifyValidSignature(purchase.getOriginalJson(),purchase.getSignature())){
            Log.i(TAG, "Got a purchase: " + purchase + "; but signature is bad. Skipping...");
            return;
        }
        Log.d(TAG, "Got a verified purchase: " + purchase);
        PurchaseList.add(purchase);
    }

    /*验证签名*/
    private boolean VerifyValidSignature(String signedData,String signature){

       try{
            return Security.verifyPurchase(BASE_64_ENCODED_PUBLIC_KEY,signedData,signature);
       }
       catch (IOException e){
           Log.e(TAG, "Got an exception trying to validate a purchase: " + e);
           return false;
       }
    }

    /*执行服务请求*/
    private void executeServiceRequest(Runnable runnable) {
        if(mIsServiceConnected){
            runnable.run();
        }
        else{
            startServiceConnection(runnable);
        }
    }

    public void consumeAsync(final String purchaseToken) {
        if (mTokensToBeConsumed == null) {
            mTokensToBeConsumed = new HashSet<>();
        } else if (mTokensToBeConsumed.contains(purchaseToken)) {
            Log.i(TAG, "Token was already scheduled to be consumed - skipping...");
            return;
        }
        mTokensToBeConsumed.add(purchaseToken);

        //消耗监听
        final ConsumeResponseListener onConsumeListener = new ConsumeResponseListener() {
            @Override
            public void onConsumeResponse(BillingResult  responseCode, String purchaseToken) {
                // If billing service was disconnected, we try to reconnect 1 time
                // (feel free to introduce your retry policy here).

                mBillingUpdatesListener.onConsumeFinished(purchaseToken, responseCode.getResponseCode());
            }
        };

        final ConsumeParams consumeParams = ConsumeParams.newBuilder().setPurchaseToken(purchaseToken).build();
        Runnable consumeRequest = new Runnable() {
            @Override
            public void run() {
                // Consume the purchase async
                billingClient.consumeAsync(consumeParams, onConsumeListener);
            }
        };
        executeServiceRequest(consumeRequest);
    }

    /*查询内购商品详情*/
    public void querySkuDetailsAsync(@SkuType final String itemType, final List<String> skuList,
                                     final SkuDetailsResponseListener listener) {
        Runnable queryRequest = new Runnable(){
            @Override
            public void run() {
                SkuDetailsParams.Builder params = SkuDetailsParams.newBuilder();
                params.setSkusList(skuList).setType(itemType);
                billingClient.querySkuDetailsAsync(params.build(),
                        new SkuDetailsResponseListener() {
                            @Override
                            public void onSkuDetailsResponse(BillingResult billingResult,
                                                             List<SkuDetails> skuDetailsList) {
                                listener.onSkuDetailsResponse(billingResult, skuDetailsList);
                            }
                        });
            }
        };
        executeServiceRequest(queryRequest);
    }

//    /*开始一个购买流程*/
//    public void initiatePurchaseFlow(final SkuDetails skuDetails, final @SkuType String billingType) {
//        initiatePurchaseFlow(skuDetails);
//    }

    /*启动购买，订购流程*/
    public void initiatePurchaseFlow(final SkuDetails skuDetails) {
        Runnable purchaseFlowRequest = new Runnable() {
            @Override
            public void run() {
//                Log.d(TAG, "Launching in-app purchase flow. Replace old SKU? " + (oldSkus != null));

                BillingFlowParams purchaseParams = BillingFlowParams.newBuilder()
                        .setSkuDetails(skuDetails).build();
                billingClient.launchBillingFlow(mActivity, purchaseParams);
            }
        };
        executeServiceRequest(purchaseFlowRequest);
    }

    public void acknowledgePurchase(AcknowledgePurchaseParams acknowledgePurchaseParams, AcknowledgePurchaseResponseListener Listener){
        billingClient.acknowledgePurchase(acknowledgePurchaseParams,Listener);
    }


    /* 释放连接*/
    public void destroy(){
        Log.d(TAG, "Destroying the manager.");
        if (billingClient != null && billingClient.isReady()) {
            billingClient.endConnection();
            billingClient = null;
        }
    }

}
然后是一个商品验证类


package com.example.googleiap;

import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import com.android.billingclient.util.BillingHelper;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;

public class Security {
    private static final String TAG = "GoogleIap/Security";
    private static final String KEY_FACTORY_ALGORITHM = "RSA";
    private static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
    public static boolean verifyPurchase(String base64PublicKey, String signedData,
                                         String signature) throws IOException {
        if (TextUtils.isEmpty(signedData) || TextUtils.isEmpty(base64PublicKey)
                || TextUtils.isEmpty(signature)) {
            Log.w(TAG,"购买验证失败,数据丢失");
            return false;
        }
        PublicKey key = generatePublicKey(base64PublicKey);
        return verify(key, signedData, signature);
    }

    public static PublicKey generatePublicKey(String encodedPublicKey) throws IOException {
        try {
            byte[] decodedKey = Base64.decode(encodedPublicKey, Base64.DEFAULT);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);
            return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
        } catch (NoSuchAlgorithmException e) {
            // "RSA" is guaranteed to be available.
            throw new RuntimeException(e);
        } catch (InvalidKeySpecException e) {
            String msg = "Invalid key specification: " + e;
            BillingHelper.logWarn(TAG, msg);
            throw new IOException(msg);
        }
    }

    public static boolean verify(PublicKey publicKey, String signedData, String signature) {
        byte[] signatureBytes;
        try {
            signatureBytes = Base64.decode(signature, Base64.DEFAULT);
        } catch (IllegalArgumentException e) {
            BillingHelper.logWarn(TAG, "Base64 decoding failed.");
            return false;
        }
        try {
            Signature signatureAlgorithm = Signature.getInstance(SIGNATURE_ALGORITHM);
            signatureAlgorithm.initVerify(publicKey);
            signatureAlgorithm.update(signedData.getBytes());
            if (!signatureAlgorithm.verify(signatureBytes)) {
                BillingHelper.logWarn(TAG, "Signature verification failed.");
                return false;
            }
            return true;
        } catch (NoSuchAlgorithmException e) {
            // "RSA" is guaranteed to be available.
            throw new RuntimeException(e);
        } catch (InvalidKeyException e) {
            BillingHelper.logWarn(TAG, "Invalid key specification.");
        } catch (SignatureException e) {
            BillingHelper.logWarn(TAG, "Signature exception.");
        }
        return false;
    }

}

我是把BillingManager和Security 单独作为库文件是因为方便以后的项目移植

然后是使用方法了

本类不处理任何商品逻辑，只作为中转站，下面是部分使用的逻辑

在你的android工程中创建类继承至

extends UnityPlayerActivity implements BillingManager.BillingUpdatesListener

用到的成员属性

private static Dictionary<String,SkuDetails> ProductList = new Hashtable<String,SkuDetails>();
/*商品token*/
private static Dictionary<String,Purchase> m_PurchaseListByToken = new Hashtable<>();
/*商品*/
private static Dictionary<String,Purchase> m_PurchaseListBySku = new Hashtable<>();
/*内购是否初始化完成*/
private boolean bSetupFinis;
/*商品是否初始化完成*/
private boolean bInitProduct;
private final String Buy = "Buy";
private final String Consume = "Consume";
private final String Success = "Success";
/*内购客户端*/
private BillingManager m_BillingManager;

然后在你项目需要的地方去初始化BillingManager,我的项目是游戏loading加载完后初始化


/*初始化*/   
public void  InitBilling(String nil){
        Log.w(TAG,"InitBilling");
        m_BillingManager = new BillingManager(this,this);
    }

    /*客户端设置成功回调*/
    @Override public void onBillingClientSetupFinished()
    {
        bSetupFinis = true;
        Log.i(TAG, "onBillingClientSetupFinished");
        BeginQuestProuect();
    }

然后就是初始化商品列表（在你觉得什么时候可以调用的地方调用就是了），有人会想我不是在谷歌后台配置了商品列表吗？怎么还要初始化商品呢,这里是因为要获取一些购买时的所需要的验证数据，所以得请求一次，把你本地的商品配置的id用符号格式化，然后把返回的商品信息存下来 ,ProductList.put(skuDetail.getSku(),skuDetail);

public void  InitProduceList(String productid){
    String[] sArray =  productid.split("#");
        for(String sku : sArray){
            ProductKeys.add(sku);
        }
        bInitProduct = true;
        BeginQuestProuect();
}

/*准备请求商品信息*/
private void BeginQuestProuect(){
    if(!bInitProduct || !bSetupFinis){
            return;
    }
    /*我这里是为了图方便都注册一次*/
    addProduct(ProductKeys,SkuType.INAPP);
    addProduct(ProductKeys,SkuType.SUBS);
}

 
/*添加商品*/
    public void addProduct(List<String> skusList, final @SkuType String billingType)
    {
        m_BillingManager.querySkuDetailsAsync(billingType, skusList, new SkuDetailsResponseListener() {
            @Override
            public void onSkuDetailsResponse(BillingResult billingResult, List<SkuDetails> skuDetailsList) {
                if (billingResult.getResponseCode() != BillingResponseCode.OK) {
                    Log.w(TAG, "Unsuccessful query for type: " + billingType
                            + ". Error code: " + billingResult.getResponseCode());
                }else if(skuDetailsList != null && skuDetailsList.size() > 0){
                        for(SkuDetails skuDetail : skuDetailsList){
                            Log.i(TAG, "Adding sku: " + skuDetail);
                            /*把返回的商品信息存下来*/
                            ProductList.put(skuDetail.getSku(),skuDetail);
                        }
                }

            }
        });
    }

商品更新的回调，第一次初始化内购的时候也会返回一些商品信息，这里我们保留已经购买的和激活(这个意思就是说待确认的商品)的商品，购买成功也走的这里,那怎么区分是购买还是初始化触发的呢？因为购买商品肯定是一次一次请求的,如果已经在购买一类商品肯定是需要等待这次购买结束才能发起下一次购买的(所以你判断有没有购买请求就知道啦)

    /*商品更新回调*/
    @Override public void onPurchasesUpdated(List<Purchase> purchases)
    {
        UnitySendMessage("State.0");
        String parame;
        for (Purchase purchase :  purchases){
            if (purchase.getPurchaseState() == PurchaseState.PURCHASED || purchase.isAcknowledged()) {
                m_PurchaseListByToken.put(purchase.getPurchaseToken(),purchase);
                m_PurchaseListBySku.put(purchase.getSku(),purchase);
                parame = String.format("%s.%s.0.%s",Buy,purchase.getSku(),purchase.getPurchaseTime() / 1000);
                UnitySendMessage(parame);
                }
            }
        UnitySendMessage("State.1");
        Log.i(TAG, "onPurchasesUpdated");
    }

    /*失败处理*/
    public void onFailedHandle(@BillingResponseCode int result){
       String code =  String.format("%s.-1.%s.0",Buy,result);
        Log.i(TAG, "onFailedHandle code = " + code);
        UnitySendMessage(code);
    }

然后是购买商品，这里就用到了之前初始化所需要的商品数据了

    /*购买商品*/
    public void BuyProduct(String product){
        Log.d(TAG,"BuyProduct:" + product);
        SkuDetails skuDetails= ProductList.get(product);
        if(skuDetails != null){
            m_BillingManager.initiatePurchaseFlow(skuDetails);
        }else{
            Log.w(TAG, "not found  product in ProductList ,product=> " + product);
        }
    }

然后是消耗商品了,这里请注意！！！google后台是不区分消耗和非消耗商品,这里需要你自己来管理,通过配置判断

   /*消耗商品*/
    public void consumeAsync(String product,String type){
//        type = "2";
        Log.i(TAG,"consumeAsync product = " + product + ",type = " + type);
       Purchase purchase =  m_PurchaseListBySku.get(product);
       if(purchase != null){
           m_PurchaseListBySku.remove(product);
           if(type.equals("1")){ //消耗品
               m_BillingManager.consumeAsync(purchase.getPurchaseToken());
           }
           else if (type.equals("0")){
               if(!purchase.isAcknowledged()){
                   Log.i(TAG,"前往确认商品");
                    AcknowledgePurchaseParams acknowledgePurchaseParams =
                            AcknowledgePurchaseParams.newBuilder()
                                    .setPurchaseToken(purchase.getPurchaseToken())
                                    .build();
                    m_BillingManager.acknowledgePurchase(acknowledgePurchaseParams, new AcknowledgePurchaseResponseListener() {
                        @Override
                        public void onAcknowledgePurchaseResponse(BillingResult billingResult) {
                            Log.i(TAG,"前往确认商品返回 code = " +billingResult.getResponseCode() );
                           String parame = String.format("%s.-1.%s.-1",Consume,billingResult.getResponseCode());
                            UnitySendMessage(parame);
                        }
                    });
                }
               else{
                   String parame = String.format("%s.-1.0.-1",Consume);
                   UnitySendMessage(parame);
               }
           }
       }
    }

商品消耗完成

    /*商品消耗完成回调*/
    @Override public void  onConsumeFinished(String token, @BillingResponseCode int result)
    {
        Purchase purchases = m_PurchaseListByToken.get(token);
        Log.i(TAG, "onConsumeFinished (purchases)=>" + purchases);
        if(purchases != null){
            String code =  String.format("%s.%s.%s.%s",Consume,purchases.getSku(),result,purchases.getPurchaseTime());
            UnitySendMessage(code);
            m_PurchaseListByToken.remove(purchases.getPurchaseToken());
        }
    }

然后是后台切换的时候也需要调用一次商品更新,因为有可能玩家是在谷歌商店购买的游戏商品

    @Override protected void onResume(){
        super.onResume();
        if(m_BillingManager != null){
            m_BillingManager.OnQueryPurchases();
        }
    }

补充：项目的build.gradle设置

dependencies{
    implementation 'com.android.billingclient:billing:2.0.3'
}

断开连接

 @Override protected void onDestroy (){
        if(m_BillingManager != null)
        {
            m_BillingManager.destroy();
        }
        super.onDestroy();
    }

 

-MrWhite
关注
Google 登录和支付接入
lostfound的博客
09-24 4145
应用上架应用市场，接入google 登录和支付是一个必不可少的流程，本文就介绍一下接入google登录和支付的流程。
Android 接入 Google 支付（Google Play Billing）
最新发布
u010207898的博客
03-24 507
在发布应用之前，你需要进行充分的测试，确保支付流程正常工作。可以使用 Google Play 控制台的测试账号进行测试。测试通过后，就可以将应用正式发布到 Google Play 商店。在 Google Play 控制台中，为你的应用配置内购商品（一次性购买）或订阅商品。你需要提供商品的名称、描述、价格等信息。在你的 Android 项目中，添加 Google Play Billing 库的依赖。当用户完成购买后，你需要处理购买结果并确认购买。这可以防止用户重复购买。
google play 结算服务接入流程
蛋蛋的博客
08-02 3298
公司有部分需求用到google play 结算服务（google 订阅），去实现商品的订阅，所以研究了一下，记录一下这次开发流程。 流程说明： 订阅流程： 用户从 Google Play 下载安装 APP, 通过APP的支付接口调用 Google Play 的支付界面, 成功后，App 获取到 Google 返回的携带 Token, productId, 与本APP的用户信息, 发送到后端, 进行验证, 验证成功后 发放/开通 相应权限; 续订流程： 订单续订后，google会发生通知到服务端..
Google Pay Java 后端验证方式一
chen1234219的博客
03-30 1511
将上面的{XX}替换成创建api项目时填写的重定向地址，和clientId，然后将连接放到浏览器中打开，就会吊起授权界面，使用你的开发者账号授权登录。，它只会在第一次请求中返回，后续用在发一样的请求不会返回refreshtoken，如果不慎弄丢了，需要去重新创建一个WebClientId。这里可以看到，重定向地址上有两个参数code和scope，我们只需要code就行了，这里的code是。client_id=创建api项目是的clientId（客户端ID）
Android Google Pay接入(1)
2401_84149339的博客
04-09 1303
其实很简单就下面这张图，含概了Android所有需要学的知识点，一共8大板块：架构师筑基必备技能Android框架体系架构（高级UI+FrameWork源码）360°Androidapp全方位性能调优设计思想解读开源框架NDK模块开发移动架构师专题项目实战环节移动架构师不可不学习微信小程序混合开发的flutterAndroid学习的资料我呢，把上面八大板块的分支都系统的做了一份学习系统的资料和视频，大概就下面这些，我就不全部写出来了，不然太长了影响大家的阅读。
Google 支付从入门到跳坑
a457886115的专栏
06-22 2022
转载：http://leenjewel.github.io/blog/2016/06/21/google-zhi-fu-cong-ru-men-dao-tiao-keng/ Google 支付从入门到跳坑 Google 支付真的不难，难的是由于“你懂的”的国内网络环境导致的复杂的测试流程和 Google Console “天花烂缀”的各种配置项目还有那些“文不达意”的报错信息。
谷歌pay服务端文档_在Web端接入Google Pay
weixin_39787606的博客
12-19 2084
Google Pay 是2018年1月9日，谷歌发布的新的支付平台。Google Pay品牌将在移动应用、网站、和线下支付终端中陆续上线，而已有的Android Pay品牌则将下线。注意：Google Pay 并不是常用的手机端应用内支付方式 Google Play！！！虽说是与 Apple Pay 对标的产品，Google Pay 的知名度和普及度似乎很低，在网上搜索的对接资料相当之少，以至于中...
Google Pay接入流程
weixin_33786077的博客
06-02 6278
应用创建 创建应用需要上传一个签名后的包。可以是个空包，也就是说，可以上传一个和正式包一样包名和签名的就可以提前获得回复的key。 GooglePay内购及订阅概念 1.GoogleInapp(内购) GoogleInapp也叫google内购，内购分为两个步骤，第一步为购买。购买成功后，需要消耗该商品。如果该商品未消耗，那么当前设备下次购买该商品将会失败，返回code码为7.用户如果第一次购买该...
Google支付接入
makai554892700的专栏
10-02 4007
本文章仅作为个人笔记 官方文档 Google支付接入前提： 开发者： 拥有google开发者账号 设置定价模板 打开定价模板页面 填写相应信息创建模板 如果出现此页面表示没有在应用内添加billing权限，在将应用AndroidManifest.xml文件内添加 权限，重新打包上传到googlePlay测试或者正式环境（一般此时测试环境就好）即可。 添加好权限后会出现创建受管理...
Android Google Pay接入
2501_90389560的博客
01-24 1000
此外，您的应用还应在其 onResume() 和 onCreate() 方法中调用 queryPurchasesAsync()，以处理您的应用未在运行时过渡到 PURCHASED 状态的购买交易。BillingClient 您还必须调用 setListener()，将传递给引用， PurchasesUpdatedListener 以接收有关您的应用发起的购买以及Google Play商店发起的购买的更新。在 Google 通知您已通过用户的付款方式成功扣款之前，您的应用不得授予对这些类型的购买交易的权利。
Google 在中国的支付通道
Fenng's Blog
09-05 1268
&#13; 前几天购买了 Google 广告服务, 惊奇的发现, Google 的 Adwords 现在已经可以通过银联网络支付了。目前可用的支付方法： 后付款： 万事达卡, 及具有 MasterCard 或 Visa 标记的国际卡（信用卡或借记卡）, 维萨卡 预付款： 我们的支付合作伙伴银联支持的银行卡 一直以为 Google 的 Checkout 服务暂时不会进入国内，...
谷歌支付接入流程(一次性支付，连续订阅)
jiayuanwai的博客
04-20 6051
谷歌支付接入流程
Google Pay接入
Painend的博客
04-24 3400
1、由于业务需求，准备接入Google Pay，一开始本人接到这个需求的时候，就开始到Google Pay官网以及Google、百度上搜索如何接入Google Pay，也是有发现一些文章。在我处理了一部分的时候，后端人员问我，这个你是不是只需要写一点点代码就可以了。啥？为什么我发现好多地方要配置，这是才只是原来是采坑了。 2、Google17年的时候在印度推出Tez移动支付应用，但是在18年的时...
Google Pay支付遇到的问题
2401_89690312的博客
12-16 2604
1.新增国家/地区，但是汇率未刷新。(刷新汇率即可，下面问题同样有效)2.依照以下步骤清除装置上的缓存试试看是否问题仍持续发生。打开设备的主应用。点按或（显示选项可能因设备而异）。点按。点按。依次点按。依次点按。点按后退箭头以返回主菜单。选择或。依次点按。依次点按。重新启动应用。
Google支付的接入详解
热门推荐
lzp2015的博客
06-14 3万+
Google支付的详细集成过程
接入Google Play 支付经历
mingzaizai_123的专栏
06-26 2221
APP内的谷歌结算库订阅调用流程图1.0： APP内的谷歌结算库订阅调用流程图2.0： APP内的谷歌结算库一次性购买调用流程图3.0： 工程接入Google结算库需要做的事情： 在 gradle 中引用的依赖： implementation 'com.android.billingclient:billing:3.0.0' 在 AndroidManifest 中添加的权限 <uses-permission android:name="com.android...
安卓集成Google Play支付(谷歌支付)最新版本
Jason_HD的博客
09-21 8417
安卓集成Google Play支付最新版本
安卓接入Google支付
u012080441的专栏
08-30 6520
确保安装版本与后台的版本一致，包含AppVersion，bundleVersion，签名。确保支付的账号在测试人员列表中。对于每个产品，您需要提供唯一的产品 ID、标题、描述和定价信息。后台的商品分为一次性消耗和订阅２中类型。后台创建商品的话需要先在后台上传一个带有支付功能的草稿包，确保包名、签名、支付库就可构建APK上传。注册需要准备Gmail邮箱、手机号、Visa卡（谷歌开发者账号注册需要支付25美元）。设置开发者帐户后，必须发布包含 Google Play 结算库的应用版本。无法购买您要买的商品"..
服务端验证Google Pay订单的两种方式
Jason_HD的博客
04-20 1万+
服务端验证Google Pay订单的两种方式
Google Pay接入教程与Billing介绍
根据给定的文件信息，标题为 "billing.zip"，描述提到了 "googlepay接入"，并且文件标签为 "android google"。压缩包内文件名称列表中只有一个文件名为 "billing"。这些信息涉及到了 Android 应用的 Google Play ...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值