Collect card payments while offlineBeta

curl https://api.stripe.com/v1/terminal/configurations \
  -u "
sk_test_4eC39HqLyjWDarjtT1zdp7dc
:" \
  -d "offline[enabled]"=true

class CustomOfflineListener : OfflineListener {
    override fun onOfflineStatusChange(offlineStatus: OfflineStatus) {
        // Check the value of `offlineStatus` and update your UI accordingly. For instance,
        // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`.
        //
        // You can also check the SDK's current offline status using
        // `Terminal::offlineStatus`.
    }

    override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) {
        // The PaymentIntent was successfully forwarded, or an error occurred.
        // Reconcile any local state using the backend-generated `PaymentIntent::id`
        // and the metadata you supplied when creating the PaymentIntent.
        //
        // Note that the `PaymentIntent::id` may still be null if creating the
        // PaymentIntent in the backend failed.
    }

    override fun onForwardingFailure(e: TerminalException) {
        // A non-specific error occurred while forwarding a PaymentIntent.
        // Check the error message and your integration implementation to
        // troubleshoot.
    }
}

Terminal.initTerminal(
    context = applicationContext,
    logLevel = LogLevel.VERBOSE,
    tokenProvider = CustomConnectionTokenProvider(),
    listener = CustomTerminalListener(),
    offlineListener = CustomOfflineListener(),
)

private const val TAG = "PaymentActivity"

class PaymentActivity : AppCompatActivity() {
    // Action for a "Checkout" button
    private fun onCheckout(cart: Cart) {
        // Build up parameters for creating a `PaymentIntent`
        val params = PaymentIntentParameters.Builder()
            .setAmount(cart.total)
            .setCurrency(cart.currency)
            .setMetadata(mapOf("unique-id" to UUID.randomUUID().toString()))
            .build()

        // Your app might want to prevent offline payments for too large an amount.
        // Here, we require a network connection if the payment if the amount is over 1000 usd.
        // Otherwise, we allow collecting offline if the network connection is unavailable.
        val offlineBehavior = if (cart.total > 1000000) {
            OfflineBehavior.REQUIRE_ONLINE
        } else {
            OfflineBehavior.PREFER_ONLINE
        }
        val createConfig = CreateConfiguration(offlineBehavior)
        val createPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback {
            override fun onSuccess(paymentIntent: PaymentIntent) {
                Log.d(TAG, "createPaymentIntent succeeded")
                // If the `PaymentIntent` was created offline, its `id` field will be null.
                if (paymentIntent.id != null) {
                    Log.d(TAG, "created online")
                } else {
                    Log.d(TAG, "created offline")
                }
                // ... Collect a PaymentMethod
            }

            override fun onFailure(e: TerminalException) {
                Log.e(TAG, "createPaymentIntent failed", e)
                // Handle offline-specific errors in your application (for example,
                // `offlineBehavior` was set to REQUIRE_ONLINE and the SDK is offline).
            }
        }
        Terminal.getInstance().createPaymentIntent(params, createPaymentCallback, createConfig)
    }
}

private const val TAG = "PaymentActivity"

class PaymentActivity : AppCompatActivity() {
    // Action for a "Checkout" button
    private fun onCheckout(cart: Cart) {
        val collectPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback {
            override fun onSuccess(paymentIntent: PaymentIntent) {
                Log.d(TAG, "collectPaymentMethod succeeded")
                // ... Confirm the payment
            }

            override fun onFailure(e: TerminalException) {
                // Handle offline-specific errors in your application (for example,
                // unsupported payment method).
                Log.d(TAG, "collectPaymentMethod failed:", e)
            }
        }
        val collectConfig = CollectConfiguration.Builder().build()
        Terminal.getInstance().collectPaymentMethod(paymentIntent, collectPaymentCallback, collectConfig)
    }
}

private const val TAG = "PaymentActivity"

class PaymentActivity : AppCompatActivity() {
    // Action for a "Checkout" button
    private fun onCheckout(cart: Cart) {
        val confirmPaymentIntentCallback: PaymentIntentCallback = object : PaymentIntentCallback {
            override fun onSuccess(paymentIntent: PaymentIntent) {
                Log.d(TAG, "confirmPaymentIntent succeeded")
                // If the `PaymentIntent` was confirmed offline, `paymentIntent.offlineDetails` will be defined
                if (paymentIntent.offlineDetails != null) {
                    Log.d(TAG, "confirmed offline")
                } else {
                    Log.d(TAG, "confirmed online")
                }
            }

            override fun onFailure(e: TerminalException) {
                // Handle offline-specific errors in your application (for example,
                // unsupported payment method).
                Log.e(TAG, "confirmPaymentIntent failed:", e)
            }
        }
        Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback)
    }
}

private const val TAG = "PaymentActivity"

class PaymentActivity : AppCompatActivity() {
    // Action for a "Checkout" button
    private fun onCheckout(cart: Cart) {
        val callback: PaymentIntentCallback = object : PaymentIntentCallback {
            override fun onSuccess(paymentIntent: PaymentIntent) {
                Log.d(TAG, "confirmPaymentIntent succeeded")
                if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) {
                    val offlineDetails = paymentIntent.offlineDetails
                    if (offlineDetails?.requiresUpload == true) {
                        // Offline payment, wait for `onPaymentIntentForwarded` (see snippet below)
                    } else {
                        // Online payment, can be captured now
                    }
                } else {
                    // Handle other status results here
                }
            }

            override fun onFailure(e: TerminalException) {
                // Handle offline-specific errors in your application (for example,
                // unsupported payment method).
                Log.e(TAG, "confirmPaymentIntent failed:", e)
            }
        }

        Terminal.getInstance().confirmPaymentIntent(paymentIntent, callback)
    }
}

class CustomOfflineListener : OfflineListener {
    // ...

    override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) {
        if (e != null) {
            // Handle the error appropriate for your application
        } else if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) {
            // The paymentIntent is ready to be captured
        } else {
            // Handle other status results here
        }
    }

    // ...
}