dependencies {
    implementation("com.braintreepayments.api:venmo:5.8.0")
}

class VenmoActivity : AppCompatActivity() {
    private lateinit var venmoClient: VenmoClient
    private lateinit var venmoLauncher: VenmoLauncher

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // must be initialized on onCreate()
        venmoLauncher = VenmoLauncher()

        // can be initialized outside onCreate() if desired
        venmoClient = VenmoClient(
            context = requireContext(),
            authorization = "TOKENIZATION_KEY or CLIENT_TOKEN",
            appLinkReturnUrl = Uri.parse("https://merchant-app.com") // Merchant App Link
        )
    }

    // ONLY REQUIRED IF YOUR ACTIVITY LAUNCH MODE IS SINGLE_TOP
    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        handleReturnToApp(intent)
    }

    // ALL OTHER ACTIVITY LAUNCH MODES
    override fun onResume() {
        super.onResume()
        handleReturnToApp(intent)
    }

    private fun handleReturnToApp(intent: Intent) {
        super.onResume()
        val pendingRequest: VenmoPendingRequest.Started = pendingRequest
        pendingRequest?.let {
            val paymentAuthResult: VenmoPaymentAuthResult =
                venmoLauncher.handleReturnToApp(
                    pendingRequest = it,
                    intent = intent
                )
            if (paymentAuthResult is VenmoPaymentAuthResult.Success) {
                // complete the venmo flow with the successful paymentAuthResult
                completeVenmoFlow(paymentAuthResult)
            } else {
                // handle error - user did not complete Venmo flow
            }
            // clear pendingRequest
        }
    }

    private fun startVenmoFlow(venmoRequest: VenmoRequest) {
        venmoClient.createPaymentAuthRequest(
            context = requireActivity(),
            request = venmoRequest
        ) { paymentAuthRequest ->
            if (paymentAuthRequest is VenmoPaymentAuthRequest.Failure) {
                // handle paymentAuthRequest.error
            } else if (paymentAuthRequest is VenmoPaymentAuthRequest.ReadyToLaunch) {
                val pendingRequest: VenmoPendingRequest = venmoLauncher.launch(
                    activity = requireActivity(),
                    paymentAuthRequest = paymentAuthRequest
                )
                if (pendingRequest is VenmoPendingRequest.Started) {
                    // store pendingRequest for future use
                } else if (pendingRequest is VenmoPendingRequest.Failure) {
                    // handle pendingRequest.error
                }
            }
        }
    }

    private fun completeVenmoFlow(paymentAuthResult: VenmoPaymentAuthResult.Success) {
        venmoClient.tokenize(paymentAuthResult) { result: VenmoResult ->
            this.handleVenmoResult(result)
        }
    }

    private fun handleVenmoResult(result: VenmoResult) {
        when (result) {
            is VenmoResult.Success -> { /* handle result.nonce) */ }
            is VenmoResult.Failure -> { /* handle result.error */ }
            is VenmoResult.Cancel -> { /* handle user canceled */ }
        }
    }

    private fun storePendingRequest(request: VenmoPendingRequest.Started) {
        // store pending request
    }

    private val pendingRequest: VenmoPendingRequest.Started
        get() = { /* fetch stored pending request */ }

    private fun clearPendingRequest() {
        // clear/reset pending request
    }
}

val request = VenmoRequest(VenmoPaymentMethodUsage.MULTI_USE)

    venmoClient.tokenizeVenmoAccount(this, request)

dataCollector.collectDeviceData(this@MyActivity) { deviceData, dataCollectorError ->
  // send venmoAccountNonce.string and deviceData to server
}