china-pay-android

KO | EN

gitlite — search

#python #php #java #dotfiles #c #c-plus-plus #javascript #shell #ruby #cross-language #gtk #clojure

china-pay-android

★ 32 Open GitHub ↗

Kotlin-first Android payment SDK for Jetpack Compose with coroutine-based APIs and StateFlow-driven results for WeChat APP Pay, Alipay APP Pay, and UnionPay.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# china-pay-android

[简体中文](README_zh-CN.md)

Kotlin-first Android payment SDK for Jetpack Compose. The current API is a full rewrite and does not maintain compatibility with the legacy Java API.

## Supported Payments

- WeChat APP payment: `WechatPay`
- Alipay APP payment: `AlipayPay`
- UnionPay payment: `UnionPay`

All payment clients expose `StateFlow<PayState<...>>` and use suspending `start()` methods.

## Integration Steps

### 1. Add dependencies

Include this Android Library in the app module and add coroutines/Lifecycle Compose:

```kotlin
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1")
    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.8.4")
}
```

Add the official WeChat, Alipay, and UnionPay SDKs and complete each provider's app/package/signature configuration.

### 2. Create orders on your server

The client never creates orders or signs requests. Your server must call each provider's order API and return:

- WeChat: `appId`, `partnerId`, `prepayId`, `nonce`, `timestamp`, `sign`
- Alipay: the complete RSA2-signed `orderInfo`
- UnionPay: `transactionNumber`

Keep all private keys on the server.

### 3. Register the WeChat callback

Create the exact callback class in the host app's package:

```kotlin
package your.application.wxapi

class WXPayEntryActivity : android.china.pay.wxapi.WechatPayActivity()
```

Register `.wxapi.WXPayEntryActivity` in the manifest. On Android 13+, do not add an intent-filter. The package name and signing certificate must match the WeChat Open Platform configuration.

### 4. Start WeChat payment from Compose

```kotlin
val payment = remember(order) { WechatPay(context, order) }
val state by payment.state.collectAsStateWithLifecycle()

Button(onClick = { scope.launch { payment.start() } }) {
    Text("Pay with WeChat")
}

DisposableEffect(Unit) { onDispose { payment.close() } }
```

Render `Launching`, `Pending`, `Cancelled`, `Failure`, and `Success` from the state. A WeChat `errCode == 0` callback is not final proof of payment; query your server and call `payment.confirmSuccess(result)` only after server confirmation.

### 5. Start Alipay APP payment

```kotlin
val payment = AlipayPay(
    activity,
    AlipayPayRequest(orderInfo = signedOrderInfo)
)
scope.launch { payment.start() }
```

`orderInfo` must be fully RSA2-signed by your server. SDK statuses `9000`, `8000`, and `5000` enter `Pending`; use server notification or order query for the final result.

### 6. Start UnionPay

```kotlin
val payment = UnionPay(
    activity,
    UnionPayRequest(transactionNumber, testMode = BuildConfig.DEBUG)
)
scope.launch { payment.start() }
```

Use test mode only with the UnionPay test environment. Production must use `testMode = false`.

### 7. Confirm the final result

For every provider:

1. Start the provider SDK from the client.
2. Treat the client callback as `Pending`, `Cancelled`, or `Failure`.
3. Receive the provider notification or query the order on your server.
4. Call `confirmSuccess` or `confirmFailure`.
5. Render the final state in Compose.

Never ship goods, credit a balance, or mark an order paid from a client callback alone.

## Requirements

- Android API 19+
- Kotlin and Java 8+
- AndroidX
- A provider application configured on the corresponding open platform

## Compose Usage

```kotlin
val payment = remember {
    WechatPay(
        context = context,
        request = WechatAppPayRequest(
            appId = appId,
            partnerId = partnerId,
            prepayId = prepayId,
            nonce = nonce,
            timestamp = timestamp,
            sign = sign
        )
    )
}
val state by payment.state.collectAsStateWithLifecycle()

LaunchedEffect(Unit) { payment.start() }

when (state) {
    PayState.Idle -> Unit
    PayState.Launching -> Loading()
    PayState.Pending -> AwaitingServerConfirmation()
    PayState.Cancelled -> Cancelled()
    is PayState.Success -> Success((state as PayState.Success<*>).result)
    is PayState.Failure -> Failure((state as PayState.Failure).error)
}

DisposableEffect(Unit) { onDispose { payment.close() } }

```
After the merchant server verifies the payment, complete the state transition:

```kotlin
payment.confirmSuccess(verifiedResult)
// or payment.confirmFailure(PayFailure.Provider(...))
```

## WeChat APP Payment

The merchant server creates the order and signs the APP parameters. The client only calls the WeChat Android SDK with `PayReq`.

The host app must declare an exact `wxapi.WXPayEntryActivity` in its own package:

```kotlin
class WXPayEntryActivity : android.china.pay.wxapi.WechatPayActivity()
```

On Android 13+, do not add an intent-filter to this callback Activity. A client callback with `errCode == 0` is not final proof of payment; query the merchant server or process its payment notification before showing success.

## Alipay APP Payment

```kotlin
val payment = AlipayPay(
    activity = activity,
    request = AlipayPayRequest(orderInfo = signedOrderInfo)
)
payment.start()
```

`orderInfo` must be signed by the merchant server. `PayTask.payV2` runs on an IO dispatcher. SDK statuses `9000`, `8000`, and `5000` enter `Pending`; final success comes from the server notification or order query.

## UnionPay

```kotlin
UnionPay(
    activity = activity,
    request = UnionPayRequest(transactionNumber = tn, testMode = false)
).start()
```

## Security Boundary

The SDK never creates merchant orders, stores private keys, or treats a client callback as authoritative payment proof. Order creation, signing, notification verification, and order queries belong to the merchant server.

## Official Documentation

- [WeChat APP payment](https://pay.weixin.qq.com/doc/v2/merchant/4011936836.md)
- [WeChat APP payment API](https://pay.weixin.qq.com/doc/v2/merchant/4011937148.md)
- [Alipay Open Platform](https://opendocs.alipay.com/open/llms.txt)

china-pay-android

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README