Shop Pay Confirmation

Author: toluo-stripe

paymentsheet/src/main/java/com/stripe/android/paymentelement/confirmation/shoppay/ShopPayConfirmationDefinition.kt

@@ -0,0 +1,67 @@
+package com.stripe.android.paymentelement.confirmation.shoppay
+
+import androidx.activity.result.ActivityResultCaller
+import com.stripe.android.core.strings.resolvableString
+import com.stripe.android.paymentelement.confirmation.ConfirmationDefinition
+import com.stripe.android.paymentelement.confirmation.ConfirmationHandler
+import com.stripe.android.paymentelement.confirmation.intent.DeferredIntentConfirmationType
+import com.stripe.android.shoppay.ShopPayActivityResult
+import com.stripe.android.shoppay.ShopPayLauncher
+import javax.inject.Inject
+
+internal class ShopPayConfirmationDefinition @Inject constructor(
+    private val shopPayLauncher: ShopPayLauncher
+) : ConfirmationDefinition<ShopPayConfirmationOption, ShopPayLauncher, Unit, ShopPayActivityResult> {
+    override val key = "ShopPay"
+
+    override fun option(confirmationOption: ConfirmationHandler.Option): ShopPayConfirmationOption? {
+        return confirmationOption as? ShopPayConfirmationOption
+    }
+
+    override fun toResult(
+        confirmationOption: ShopPayConfirmationOption,
+        confirmationParameters: ConfirmationDefinition.Parameters,
+        deferredIntentConfirmationType: DeferredIntentConfirmationType?,
+        result: ShopPayActivityResult
+    ): ConfirmationDefinition.Result {
+        val error = Throwable("ShopPay is not supported yet")
+        return ConfirmationDefinition.Result.Failed(
+            cause = error,
+            message = error.message.orEmpty().resolvableString,
+            type = ConfirmationHandler.Result.Failed.ErrorType.Payment,
+        )
+    }
+
+    override fun createLauncher(
+        activityResultCaller: ActivityResultCaller,
+        onResult: (ShopPayActivityResult) -> Unit
+    ): ShopPayLauncher {
+        return shopPayLauncher.apply {
+            register(activityResultCaller, onResult)
+        }
+    }
+
+    override fun launch(
+        launcher: ShopPayLauncher,
+        arguments: Unit,
+        confirmationOption: ShopPayConfirmationOption,
+        confirmationParameters: ConfirmationDefinition.Parameters
+    ) {
+        launcher.present(confirmationOption.checkoutUrl)
+    }
+
+    override suspend fun action(
+        confirmationOption: ShopPayConfirmationOption,
+        confirmationParameters: ConfirmationDefinition.Parameters
+    ): ConfirmationDefinition.Action<Unit> {
+        return ConfirmationDefinition.Action.Launch(
+            launcherArguments = Unit,
+            receivesResultInProcess = false,
+            deferredIntentConfirmationType = null,
+        )
+    }
+
+    override fun unregister(launcher: ShopPayLauncher) {
+        launcher.unregister()
+    }
+}

paymentsheet/src/main/java/com/stripe/android/paymentelement/confirmation/shoppay/ShopPayConfirmationOption.kt

@@ -0,0 +1,9 @@
+package com.stripe.android.paymentelement.confirmation.shoppay
+
+import com.stripe.android.paymentelement.confirmation.ConfirmationHandler
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class ShopPayConfirmationOption(
+    val checkoutUrl: String,
+) : ConfirmationHandler.Option

paymentsheet/src/main/java/com/stripe/android/shoppay/ShopPayActivity.kt

@@ -0,0 +1,128 @@
+package com.stripe.android.shoppay
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.Button
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.core.os.BundleCompat
+import androidx.core.os.bundleOf
+import com.stripe.android.common.ui.BottomSheetScaffold
+import com.stripe.android.common.ui.ElementsBottomSheetLayout
+import com.stripe.android.link.theme.AppBarHeight
+import com.stripe.android.paymentsheet.R
+import com.stripe.android.uicore.elements.bottomsheet.rememberStripeBottomSheetState
+
+/**
+ * Activity that handles Shop Pay authentication via WebView.
+ */
+internal class ShopPayActivity : ComponentActivity() {
+    private var args: ShopPayArgs? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        args = intent.extras?.let { args ->
+            BundleCompat.getParcelable(args, EXTRA_ARGS, ShopPayArgs::class.java)
+        }
+
+        if (args == null) {
+            dismissWithResult(ShopPayActivityResult.Failed(Throwable("No args")))
+            return
+        }
+
+        setContent {
+            Content()
+        }
+    }
+
+    @Composable
+    private fun Content() {
+        val bottomSheetState = rememberStripeBottomSheetState()
+
+        ElementsBottomSheetLayout(
+            state = bottomSheetState,
+            onDismissed = {
+                dismissWithResult(ShopPayActivityResult.Canceled)
+            }
+        ) {
+            BottomSheetScaffold(
+                topBar = {
+                    Box(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(AppBarHeight)
+                    ) {
+                        IconButton(
+                            modifier = Modifier.align(Alignment.CenterStart),
+                            onClick = {
+                                dismissWithResult(ShopPayActivityResult.Canceled)
+                            }
+                        ) {
+                            Icon(
+                                painter = painterResource(R.drawable.stripe_ic_paymentsheet_close),
+                                contentDescription = "Close"
+                            )
+                        }
+                    }
+                },
+                content = {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxSize()
+                    ) {
+                        Button(
+                            onClick = {
+                                dismissWithResult(ShopPayActivityResult.Completed("pm_1234"))
+                            }
+                        ) {
+                            Text("Complete")
+                        }
+
+                        Button(
+                            onClick = {
+                                dismissWithResult(ShopPayActivityResult.Canceled)
+                            }
+                        ) {
+                            Text("Cancel")
+                        }
+                    }
+                }
+            )
+        }
+    }
+
+    private fun dismissWithResult(result: ShopPayActivityResult) {
+        val bundle = bundleOf(
+            ShopPayActivityContract.EXTRA_RESULT to result
+        )
+        setResult(RESULT_COMPLETE, Intent().putExtras(bundle))
+        finish()
+    }
+
+    companion object {
+        internal const val EXTRA_ARGS = "shop_pay_args"
+        internal const val RESULT_COMPLETE = 63636
+
+        internal fun createIntent(
+            context: Context,
+            args: ShopPayArgs
+        ): Intent {
+            return Intent(context, ShopPayActivity::class.java)
+                .putExtra(EXTRA_ARGS, args)
+        }
+    }
+}

paymentsheet/src/main/java/com/stripe/android/shoppay/ShopPayActivityContract.kt

@@ -0,0 +1,28 @@
+package com.stripe.android.shoppay
+
+import android.content.Context
+import android.content.Intent
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.core.os.BundleCompat
+import javax.inject.Inject
+
+internal class ShopPayActivityContract @Inject constructor() :
+    ActivityResultContract<ShopPayActivityContract.Args, ShopPayActivityResult>() {
+
+    override fun createIntent(context: Context, input: Args): Intent {
+        return ShopPayActivity.createIntent(context, ShopPayArgs(input.checkoutUrl))
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): ShopPayActivityResult {
+        val result = intent?.extras?.let {
+            BundleCompat.getParcelable(it, EXTRA_RESULT, ShopPayActivityResult::class.java)
+        }
+        return result ?: ShopPayActivityResult.Failed(Throwable("No result"))
+    }
+
+    data class Args(val checkoutUrl: String)
+
+    companion object {
+        internal const val EXTRA_RESULT = "com.stripe.android.shoppay.ShopPayActivityContract.extra_result"
+    }
+}

paymentsheet/src/main/java/com/stripe/android/shoppay/ShopPayActivityResult.kt

@@ -0,0 +1,17 @@
+package com.stripe.android.shoppay
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+internal sealed interface ShopPayActivityResult : Parcelable {
+    @Parcelize
+    data class Completed(
+        val shopPaymentMethodId: String,
+    ) : ShopPayActivityResult
+
+    @Parcelize
+    data object Canceled : ShopPayActivityResult
+
+    @Parcelize
+    data class Failed(val error: Throwable) : ShopPayActivityResult
+}

paymentsheet/src/main/java/com/stripe/android/shoppay/ShopPayArgs.kt

@@ -0,0 +1,9 @@
+package com.stripe.android.shoppay
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+internal data class ShopPayArgs(
+    val email: String,
+) : Parcelable

paymentsheet/src/main/java/com/stripe/android/shoppay/ShopPayLauncher.kt

@@ -0,0 +1,68 @@
+package com.stripe.android.shoppay
+
+import androidx.activity.result.ActivityResultCaller
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.ActivityResultRegistry
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class ShopPayLauncher @Inject internal constructor(
+    private val shopPayActivityContract: ShopPayActivityContract
+) {
+
+    private var shopPayActivityResultLauncher:
+        ActivityResultLauncher<ShopPayActivityContract.Args>? = null
+
+    fun register(
+        activityResultRegistry: ActivityResultRegistry,
+        callback: (ShopPayActivityResult) -> Unit,
+    ) {
+        shopPayActivityResultLauncher = activityResultRegistry.register(
+            "ShopPayLauncher",
+            shopPayActivityContract,
+        ) { shopPayActivityResult ->
+            handleActivityResult(shopPayActivityResult, callback)
+        }
+    }
+
+    fun register(
+        activityResultCaller: ActivityResultCaller,
+        callback: (ShopPayActivityResult) -> Unit,
+    ) {
+        shopPayActivityResultLauncher = activityResultCaller.registerForActivityResult(
+            shopPayActivityContract
+        ) { shopPayActivityResult ->
+            handleActivityResult(shopPayActivityResult, callback)
+        }
+    }
+
+    private fun handleActivityResult(
+        shopPayActivityResult: ShopPayActivityResult,
+        nextStep: (ShopPayActivityResult) -> Unit
+    ) {
+        when (shopPayActivityResult) {
+            ShopPayActivityResult.Canceled -> Unit
+            is ShopPayActivityResult.Completed -> Unit
+            is ShopPayActivityResult.Failed -> Unit
+        }
+        nextStep(shopPayActivityResult)
+    }
+
+    fun unregister() {
+        shopPayActivityResultLauncher?.unregister()
+        shopPayActivityResultLauncher = null
+    }
+
+    /**
+     * Launch the Link UI to process a payment.
+     *
+     * @param configuration The payment and customer settings
+     */
+    fun present(
+        checkoutUrl: String,
+    ) {
+        val args = ShopPayActivityContract.Args(checkoutUrl)
+        shopPayActivityResultLauncher?.launch(args)
+    }
+}