Athana SDK

For Games

应用内购服务

查询商店是否可用

返回不可用的情况：

  • 服务建立连接阶段
  • Play Store 未登录账号
  • Google Play Services 不可用
  • 网络故障
1
2
3
4
// Example
private fun isAvailable(): Boolean {
    return Athana.getInstance().iapService.isAvailable()
}
1
2
3
4
// Example
private boolean isAvailable() {
    return Athana.getInstance().getIapService().isAvailable()
}

查询商品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Example
private fun queryProduct(keys: Set<String>) {
    Athana.getInstance().queryProducts(
        keys = keys,
        requestListener = object : AthanaRequestListener<List<IapProduct>> {  
            override fun onSuccess(data: List<IapProduct>) {  
                // 查询成功
                // 如果数量不一致，则存在无效的 key
            }
  
            override fun onError(error: AthanaError) {  
                // 调用异常
            }
        })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Example
private void queryProduct(Set<String> keys) {  
    Athana.getInstance().queryProducts(  
        keys,  
        new AthanaRequestListener<>() {  
            @Override  
            public void onSuccess(List<IapProduct> iapProducts) {  
                // 查询成功
                // 如果数量不一致，则存在无效的 key
            }  
  
            @Override  
            public void onError(@NonNull AthanaError athanaError) {  
                // 调用异常
            }  
        });  
}

购买

注意，如需限制一个账号只能购买一次，则需要设置 consumable = false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Example
private fun purchase(  
    product: IapProduct,
    customOrderId: Long?, // 游戏订单号
    consumable: Boolean = true // 是否可消耗
) {  
    Athana.getInstance().purchase(  
        product = product,  
        clientOrderId = customOrderId,  
        consumable = consumable,
        requestListener = object : AthanaRequestListener<Unit> {  
            override fun onSuccess(data: Unit) {  
                // 支付成功
            }  
  
            override fun onError(error: AthanaError) {  
                // 支付失败
            }  
        })  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Example
private void purchase(  
    IapProduct product,  
    @Nullable Long customOrderId, // 游戏订单号  
    @Nullable Boolean consumable // 是否可消耗
) {  
    Athana.getInstance().purchase(  
            product,
            customOrderId,
            null,
            consumable, 
            new AthanaRequestListener<>() {  
                @Override  
                public void onSuccess(Unit data) {  
                    // 支付成功  
                }  
  
                @Override  
                public void onError(@NonNull AthanaError athanaError) {  
                    // 支付失败  
                }  
            });  
}

查询记录

符合以下条件的订单才能够被查询：

  • 非消耗一次性商品
  • 订阅类商品
  • 未确认的订单
1
2
3
4
5
6
7
8
9
10
11
12
13
// Example
private fun queryPurchaseHistory() {  
    Athana.getInstance().iapService.queryPurchaseHistory(  
        object : StoreRequestListener<List<IapPurchaseDetail>> {  
            override fun onSuccess(result: List<IapPurchaseDetail>) {  
                // 查询结果
            }  
  
            override fun onError(error: Throwable?) {  
                // 查询失败
            }  
        })  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Example
private void queryPurchaseHistory() {  
    Athana.getInstance().getIapService().queryPurchaseHistory(new StoreRequestListener<>() {  
  
        @Override  
        public void onResponse(List<IapPurchaseDetail> iapPurchaseDetails) {  
            // 查询结果
        }  
  
        @Override  
        public void onError(@Nullable Throwable throwable) {  
            // 查询失败
        }  
    });  
}
0%