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) {  
                    // 支付失败  
                }  
            });  
}

查询记录

可作为 Restore Purchase 机制使用

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

  • 非消耗一次性商品
  • 订阅类商品
  • 未确认的订单

IapPurchaseDetail 参数说明

参数名 类型 说明
productId String 商品 Key，和 IapProduct 的 key
state PurchaseState 订单状态：
处理中 - PENDING
已购买 - PURCHASED
错误 - ERROR
取消 - CANCEL
purchaseId String? 商店订单流水号
purchaseToken String? 商店订单凭证
isAcknowledged Boolean? 是否已确认，如果未确认（false），则需要调用 verifyOrder 重新验证订单
isAutoRenewing Boolean? 是否自动续订，如果是订阅类商品/服务，返回 true 
1
2
3
4
5
6
7
8
9
10
11
12
13
// Example
private fun queryPurchaseHistory() {  
    Athana.getInstance().queryPurchaseHistory(  
        object : AthanaRequestListener<List<IapPurchaseDetail>> {  
            override fun onSuccess(result: List<IapPurchaseDetail>) {  
                // 查询结果
            }  
  
            override fun onError(error: AthanaError) {  
                // 查询失败
            }  
        })  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Example
private void queryPurchaseHistory() {  
    Athana.getInstance().queryPurchaseHistory(new AthanaRequestListener<>() {  
  
        @Override  
        public void onSuccess(List<IapPurchaseDetail> iapPurchaseDetails) {  
            // 查询结果
        }  
  
        @Override  
        public void onError(AthanaError throwable) {  
            // 查询失败
        }  
    });  
}

重新验单

IapPurchaseDetail 可从 queryPurchaseHistory 查询获得

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Example
private fun verifyOrder(purchase: IapPurchaseDetail, consumable: Boolean) {  
    Athana.getInstance().verifyOrder(
        purchase = purchase,
        consumable = consumable,
        requestListener = object : AthanaRequestListener<List<IapPurchaseDetail>> {  
            override fun onSuccess(result: List<IapPurchaseDetail>) {
                // 验证结果
            }
  
            override fun onError(error: AthanaError) {
                // 查询失败
            }
        })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Example
private void verifyOrder(IapPurchaseDetail purchase, Boolean consumable) {  
    Athana.getInstance().verifyOrder(
        purchase,
        null,
        consumable,
        new AthanaRequestListener<>() {  

            @Override  
            public void onSuccess(List<IapPurchaseDetail> iapPurchaseDetails) {  
                // 验证结果
            }  
  
            @Override  
            public void onError(@Nullable Throwable throwable) {  
                // 查询失败
            }  
    });  
}
0%