Quick start

import androidx.activity.compose.rememberLauncherForActivityResult
import com.chmod.kyc.api.ChmodKycContract
import com.chmod.kyc.api.ChmodKycRequest
import com.chmod.kyc.api.VerificationResult

@Composable
fun VerificationScreen(viewModel: VerificationViewModel = viewModel()) {

    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    // Registered during composition, well before STARTED — the launcher is
    // ready by the time the user can tap anything.
    val verification = rememberLauncherForActivityResult(ChmodKycContract()) { result ->
        viewModel.onVerificationResult(result)
    }

    // The ViewModel fetches the token off the main thread; when it lands, launch.
    LaunchedEffect(Unit) {
        viewModel.requests.collect { request -> verification.launch(request) }
    }

    Column(verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Button(
            onClick = viewModel::startVerification,
            enabled = !uiState.isLoading
        ) {
            Text("Verify my identity")
        }

        if (uiState.isLoading) CircularProgressIndicator()
        uiState.message?.let { Text(it) }
    }
}

class VerificationViewModel(private val backend: KycBackend) : ViewModel() {

    private val _uiState = MutableStateFlow(UiState())
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    private val _requests = MutableSharedFlow<ChmodKycRequest>()
    val requests: SharedFlow<ChmodKycRequest> = _requests.asSharedFlow()

    fun startVerification() {
        if (_uiState.value.isLoading) return          // Avoids launching the flow twice
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }
            runCatching { backend.createKycTransaction() }
                .onSuccess { token ->
                    _requests.emit(
                        ChmodKycRequest(
                            baseUrl = "https://api.chmod.com",
                            sdkToken = token,
                            sdkConfig = KycConfiguration.default
                        )
                    )
                }
                .onFailure {
                    _uiState.update { s -> s.copy(message = "We couldn't start the verification.") }
                }
            _uiState.update { it.copy(isLoading = false) }
        }
    }
}

class VerificationActivity : AppCompatActivity() {

    // Registered as a field initializer, so it exists before onStart().
    // Registering after STARTED throws.
    private val verification = registerForActivityResult(ChmodKycContract()) { result ->
        handle(result)   // Always called on the main thread
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding.verifyButton.setOnClickListener {
            lifecycleScope.launch {
                val token = backend.createKycTransaction()
                verification.launch(
                    ChmodKycRequest(baseUrl = "https://api.chmod.com", sdkToken = token)
                )
            }
        }
    }
}

class KycBackend(private val client: OkHttpClient) {

    suspend fun createKycTransaction(): String = withContext(Dispatchers.IO) {
        val request = Request.Builder()
            .url("https://api.example.com/kyc/start")
            .post(EMPTY_BODY)
            .header("Authorization", "Bearer ${session.accessToken}")
            .build()

        client.newCall(request).execute().use { response ->
            if (!response.isSuccessful) error("Token request failed: ${response.code}")
            json.decodeFromString<StartResponse>(response.body!!.string()).sdkToken
        }
    }
}

val request = ChmodKycRequest(
    baseUrl = baseUrl,
    sdkToken = token,
    sdkConfig = SdkConfig(
        appearance = appearance,
        showWelcomeScreen = true,
        showResultScreen = false
    )
)