oneStore 支付集合

最新推荐文章于 2025-07-26 02:40:02 发布

原创最新推荐文章于 2025-07-26 02:40:02 发布 · 749 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

本文档主要介绍了如何使用iap_sdk-v19.00.01.aar版本的SDK进行oneStore支付的对接，包括下载SDK、引入项目、封装支付类OneStorelePay，并在登录后初始化支付类，调用支付接口的步骤。详细参数配置和前提条件可参考oneStore中文文档。

前言：

oneStore 支付对于某些没有接触过的来对接，可能很费工夫。毕竟没有参考没有demo着实为难。

本菜鸟也刚刚从坑里爬出来，本着大爱无私的情操，就直接上代码，有需要的可能参考代码实现自己的对接。

1.onestore支付的sdk;

本文封装的时候使用的sdk为iap_sdk-v19.00.01.aar版本。

若需要下载或查看的，请点击onestore 中文文档跳转查看吧。

2.下载好sdk后，就引用吧。

implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])

3.前两步处理好了，就直接把封装好的 OneStorelePay.java直接拷贝到自己的项目中。

直接上封装好的代码类OneStorelePay

package //包名路径，本菜鸟就直接隐藏了哈

import android.app.Activity;
import android.os.Handler;
import android.util.Log;

import com.gaa.sdk.iap.AcknowledgeListener;
import com.gaa.sdk.iap.AcknowledgeParams;
import com.gaa.sdk.iap.ConsumeListener;
import com.gaa.sdk.iap.ConsumeParams;
import com.gaa.sdk.iap.IapResult;
import com.gaa.sdk.iap.IapResultListener;
import com.gaa.sdk.iap.ProductDetailsListener;
import com.gaa.sdk.iap.ProductDetailsParams;
import com.gaa.sdk.iap.PurchaseClient;
import com.gaa.sdk.iap.PurchaseClientStateListener;
import com.gaa.sdk.iap.PurchaseData;
import com.gaa.sdk.iap.PurchaseFlowParams;
import com.gaa.sdk.iap.PurchasesListener;
import com.gaa.sdk.iap.PurchasesUpdatedListener;
import com.gaa.sdk.iap.RecurringProductListener;
import com.gaa.sdk.iap.RecurringProductParams;
import com.gaa.sdk.iap.StoreInfoListener;

import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class OneStorelePay  implements PurchasesUpdatedListener {

    private final String TAG = OneStorelePay.class.getSimpleName();
    private Activity mActivity;
    private PurchaseClient mPurchaseClient;

    private Set<String> mTokenToBe;
    private boolean isServiceConnected;

    public OneStorelePay(Activity activity) {
        mActivity = activity;
        //避免多个支付端，所以初始化时，需要进行判断释放。
        if(mPurchaseClient!=null)destroy();
        mPurchaseClient = PurchaseClient.newBuilder(activity)
                //
                .setBase64PublicKey(mActivity.getString("onestore的key"))
                .setListener(this)
                .build();

        startConnection(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "Setup successful. Querying inventory.");
                queryPurchasesAsync();
            }
        });
    }

    public void destroy() {
        if (mPurchaseClient != null) {
            mPurchaseClient.endConnection();
            mPurchaseClient = null;
        }
    }

    /**
     * 开始 onestore 服务连接
     * **/
    public void startConnection(final Runnable executeOnSuccess) {
        mPurchaseClient.startConnection(new PurchaseClientStateListener() {
            @Override
            public void onSetupFinished(IapResult iapResult) {
                if (iapResult.isSuccess()) {
                    isServiceConnected = true;
                    if (executeOnSuccess != null) {
                        executeOnSuccess.run();
                    }
                    return;
                }
                /*
                 * 避免出现发生NullPointerException异常问题
                 * delay time 延迟时间
                 */
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        handleErrorCode(iapResult);
                    }
                }, 300);
            }

            @Override
            public void onServiceDisconnected() {
                isServiceConnected = false;
            }
        });
    }

    /**
     * 确保
     * **/
    private void executeServiceRequest(Runnable runnable) {
        if (isServiceConnected) {
            runnable.run();
        } else {
            startConnection(runnable);
        }
    }

    private void handleErrorCode(IapResult iapResult) {
        if (iapResult.getResponseCode() == PurchaseClient.ResponseCode.RESULT_NEED_LOGIN) {
            Log.w(TAG, "handleErrorCode() RESULT_NEED_LOGIN");
            //One store登录
            launchLoginFlow(new IapResultListener() {
                @Override
                public void onResponse(IapResult iapResult) {
                    if (iapResult.isSuccess()) {
                        //登陆成功
                    } else {
                        Log.w(TAG, "launchLoginFlow() got an error response code: " + iapResult.getResponseCode());
                    }
                }
            });
        } else if (iapResult.getResponseCode() == PurchaseClient.ResponseCode.RESULT_NEED_UPDATE) {
            //安装或更新支付模块
            Log.w(TAG, "handleErrorCode() RESULT_NEED_UPDATE");
            launchUpdateOrInstall(new IapResultListener() {
                @Override
                public void onResponse(IapResult iapResult) {
                    if (iapResult.isSuccess()) {
                        startConnection(new Runnable() {
                            @Override
                            public void run() {
                                queryPurchasesAsync();
                            }
                        });
                    } else {
                        Log.w(TAG, "launchUpdateOrInstall() got an error response code: " + iapResult.getResponseCode());
                    }
                }
            });
        } else {
            String message = iapResult.getMessage() + "(" + iapResult.getResponseCode() + ")";
            Log.d(TAG, "handleErrorCode() error: " + message);
//            mCallback.onError(message);
        }
    }


    /**
     * 根据查询到的商品信息进行处理
     *
     * **/
    @Override
    public void onPurchasesUpdated(IapResult iapResult, List<PurchaseData> purchases) {
        if (iapResult.isSuccess()) {
            for (PurchaseData purchase: purchases) {
                //调用消耗处理
                consumeAsync(purchase);
            }
            return;
        }

        handleErrorCode(iapResult);
    }

    /**
     * 登陆oneStore
     * **/
    public void launchLoginFlow(IapResultListener listener) {
        mPurchaseClient.launchLoginFlowAsync(mActivity, listener);
    }

    /**
     * 更新或安装onestore支付模块
     * **/
    public void launchUpdateOrInstall(IapResultListener listener) {
        mPurchaseClient.launchUpdateOrInstallFlow(mActivity, listener);
    }

    /**
     * 开始购买(在需要调起onestore支付的时候，执行该方法。把对应的参数传过来)
     * **/
    public void buy(String content){
        try {
            JSONObject obj = new JSONObject(content);
            PurchaseFlowParams params = PurchaseFlowParams.newBuilder()
                    .setProductId(obj.getString("goodsId"))//商品id
                    .setProductType(obj.getString("productType"))//商品类型：inapp：管理类商品，auto：包月型商品
                    .setDeveloperPayload(obj.getString("cpOrderNo"))//透传参数
                    .setProductName(obj.getString("desc"))//商品名字
                    .setGameUserId(obj.getString("roleId"))//角色id
                    .setPromotionApplicable(false)
                    .build();

            launchPurchaseFlow(params);

        } catch (JSONException e) {
            e.printStackTrace();
        }

    }
    /**
     * 调用购买界面(onestore的购买界面)
     * **/
    public void launchPurchaseFlow(final PurchaseFlowParams params) {
        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                mPurchaseClient.launchPurchaseFlow(mActivity, params);
            }
        });
    }

    public void queryProductDetailAsync(final List<String> productIdList, @PurchaseClient.ProductType final String productType, final ProductDetailsListener listener) {
        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                ProductDetailsParams params = ProductDetailsParams.newBuilder()
                        .setProductIdList(productIdList)
                        .setProductType(productType)
                        .build();
                mPurchaseClient.queryProductDetailsAsync(params, listener);
            }
        });
    }

    /**
     * 调用消耗商品
     * **/
    public void consumeAsync(final PurchaseData data) {
        if (mTokenToBe == null) {
            mTokenToBe = new HashSet<>();
        } else if (mTokenToBe.contains(data.getPurchaseToken())) {
            Log.i(TAG, "Token was already scheduled to be consumed - skipping...");
            return;
        }

        mTokenToBe.add(data.getPurchaseToken());

        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                ConsumeParams params = ConsumeParams.newBuilder().setPurchaseData(data).build();
                mPurchaseClient.consumeAsync(params, new ConsumeListener() {
                    @Override
                    public void onConsumeResponse(IapResult iapResult, PurchaseData purchaseData) {
                        if (iapResult.isSuccess()) {
                            if (purchaseData.getPurchaseToken().equals(data.getPurchaseToken())) {
                                mTokenToBe.remove(data.getPurchaseToken());
                            }
                            Log.i(TAG, "消耗成功");
                        } else {
                            handleErrorCode(iapResult);
                        }
                    }
                });
            }
        });
    }

    public void acknowledgeAsync(final PurchaseData data) {
        if (mTokenToBe == null) {
            mTokenToBe = new HashSet<>();
        } else if (mTokenToBe.contains(data.getPurchaseToken())) {
            Log.i(TAG, "Token was already scheduled to be acknowledged - skipping...");
            return;
        }

        mTokenToBe.add(data.getPurchaseToken());

        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                AcknowledgeParams params = AcknowledgeParams.newBuilder().setPurchaseData(data).build();
                mPurchaseClient.acknowledgeAsync(params, new AcknowledgeListener() {
                    @Override
                    public void onAcknowledgeResponse(IapResult iapResult, PurchaseData purchaseData) {
                        if (iapResult.isSuccess()) {
                            if (data.getPurchaseToken().equals(purchaseData.getPurchaseToken())) {
                                mTokenToBe.remove(data.getPurchaseToken());
//                                mCallback.onAcknowledgeFinished(purchaseData, iapResult);
                            } else {
//                                mCallback.onError("purchaseToken not equal");
                            }
                        } else {
                            handleErrorCode(iapResult);
                        }
                    }
                });
            }
        });
    }

    /**
     * 查询App商品详细信息
     */
    public void queryPurchasesAsync() {
        final List<PurchaseData> result = new ArrayList<>();
        final long time = System.currentTimeMillis();
        //查询包月型商品详细信息
        final Runnable auto = new Runnable() {
            @Override
            public void run() {
                mPurchaseClient.queryPurchasesAsync(PurchaseClient.ProductType.AUTO, new PurchasesListener() {
                    @Override
                    public void onPurchasesResponse(IapResult iapResult, List<PurchaseData> purchaseData) {
                        Log.i(TAG, "AUTO - Querying purchases elapsed time: " + (System.currentTimeMillis() - time + "ms"));
                        if (iapResult.isSuccess()) {
                            result.addAll(purchaseData);
                        } else {
                            Log.w(TAG, "AUTO - queryPurchasesAsync() got an error response code: " + iapResult.getResponseCode());
                        }

                        onPurchasesUpdated(iapResult, result);
                    }
                });
            }
        };

        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                //查询管理型商品详细信息
                mPurchaseClient.queryPurchasesAsync(PurchaseClient.ProductType.INAPP, new PurchasesListener() {
                    @Override
                    public void onPurchasesResponse(IapResult iapResult, List<PurchaseData> purchaseData) {
                        Log.i(TAG, "INAPP - Querying purchases elapsed time: " + (System.currentTimeMillis() - time + "ms"));
                        if (iapResult.isSuccess()) {
                            result.addAll(purchaseData);
                        } else {
                            Log.w(TAG, "INAPP - queryPurchasesAsync() got an error response code: " + iapResult.getResponseCode());
                        }
                        auto.run();
                    }
                });
            }
        });
    }

    public void queryPurchasesAsync(@PurchaseClient.ProductType String productType) {
        final long time = System.currentTimeMillis();
        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                mPurchaseClient.queryPurchasesAsync(productType, new PurchasesListener() {
                    @Override
                    public void onPurchasesResponse(IapResult iapResult, List<PurchaseData> purchaseData) {
                        Log.i(TAG, productType + " - Querying purchases elapsed time: " + (System.currentTimeMillis() - time + "ms"));
                        if (iapResult.isSuccess()) {
//                            mCallback.onPurchaseUpdated(purchaseData);
                        } else {
                            Log.w(TAG, productType + " - queryPurchasesAsync() got an error response code: " + iapResult.getResponseCode());
                            handleErrorCode(iapResult);
                        }
                    }
                });
            }
        });
    }

    public void manageRecurringProductAsync(final PurchaseData purchaseData, final String recurringAction, final RecurringProductListener listener) {
        executeServiceRequest(new Runnable() {
            @Override
            public void run() {
                RecurringProductParams params = RecurringProductParams.newBuilder()
                        .setPurchaseData(purchaseData)
                        .setRecurringAction(recurringAction)
                        .build();
                mPurchaseClient.manageRecurringProductAsync(params, listener);
            }
        });
    }
}

4.拷贝好后，就开始初始化支付类，该类在哪里初始化，就看个人，本菜鸟是在登录账号拿到登录数据后初始化的，支付类里面有个别地方需要自己替换成自己的项目的参数的，比如：onestore的key这个参数是什么不用我说太清楚吧？

5.调用支付类。

//content为json字符串，里面是需要用到的参数。
//比如道具id，商品类型(inapp：管理类商品，auto：包月型商品)，透传参数(订单信息)，商品名字，角色id等
oneStorelePay.buy(content);

结束：

至此，整个对接oneStore的支付就算完成了。至于onestore等前提参数等等，就不在这里详细说明了，可以直接参考onestore的中文文档。