Ajouter la connexion à votre application Kotlin Multiplatform avec le SDK Auth0 Kotlin Multiplatform

kotlin {
    sourceSets {
        commonMain.dependencies {
            // Module parapluie — regroupe Web Auth, l'authentication et les credentials
            implementation("com.auth0.kmp:auth0:1.0.0-beta.0")
        }
    }
}

android {
    defaultConfig {
        
        manifestPlaceholders["auth0Scheme"] = "{yourScheme}" // par défaut : l'ID de votre application
        manifestPlaceholders["auth0Domain"] = "{yourDomain}"
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleTypeRole</key>
        <string>Editor</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <!-- Doit correspondre à votre ID de bundle -->
            <string>com.example.app</string>
        </array>
    </dict>
</array>

import com.auth0.kmp.Auth0
import com.auth0.kmp.core.Auth0Account

// Code partagé — un seul compte fonctionne pour Android et iOS
val account = Auth0Account(
    clientId = "YOUR_AUTH0_CLIENT_ID", // Depuis Paramètres de l'application → Client ID
    domain = "{yourDomain}",           // Depuis Paramètres de l'application → Domaine
)

val auth0 = Auth0(account)

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.auth0.kmp.core.result.Result
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch

sealed interface AuthState {
    data object LoggedOut : AuthState
    data object Loading : AuthState
    data class LoggedIn(val accessToken: String) : AuthState
    data class Error(val message: String) : AuthState
}

class AuthViewModel(val auth0: Auth0) : ViewModel() {
    
    // Enregistre et renouvelle automatiquement les jetons (Keystore/DataStore sur Android, Keychain sur iOS)
    private val credentialsManager = auth0.credentials()

    private val _state = MutableStateFlow<AuthState>(AuthState.LoggedOut)
    val state: StateFlow<AuthState> = _state.asStateFlow()

    fun login() {
        viewModelScope.launch {
            _state.value = AuthState.Loading
            // Ouvre Universal Login dans le navigateur du système
            when (val result = auth0.webAuth.login()) {
                is Result.Success -> {
                    credentialsManager.saveCredentials(result.data)
                    _state.value = AuthState.LoggedIn(result.data.accessToken)
                }
                is Result.Failure -> {
                    _state.value = AuthState.Error(result.error.toString())
                }
            }
        }
    }

    fun logout() {
        viewModelScope.launch {
            // Efface la session du navigateur, puis les credentials stockés localement
            when (val result = auth0.webAuth.logout()) {
                is Result.Success -> {
                    credentialsManager.clearCredentials()
                    _state.value = AuthState.LoggedOut
                }
                is Result.Failure -> {
                    _state.value = AuthState.Error(result.error.toString())
                }
            }
        }
    }
}

import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel

@Composable
fun App(viewModel: AuthViewModel = viewModel { AuthViewModel() }) {
    MaterialTheme {
        val state by viewModel.state.collectAsStateWithLifecycle()
        when (val current = state) {
            is AuthState.Loading -> CircularProgressIndicator()
            is AuthState.LoggedIn -> Button(onClick = viewModel::logout) { Text("Log Out") }
            is AuthState.Error -> Text("Something went wrong: ${current.message}")
            AuthState.LoggedOut -> Button(onClick = viewModel::login) { Text("Log In") }
        }
    }
}

import com.auth0.kmp.authentication.UserInfo

suspend fun fetchProfile(accessToken: String): UserInfo? {
    return when (val result = auth0.authentication.userInfo(accessToken)) {
        is Result.Success -> result.data // .name, .email, .picture, .customClaims, ...
        is Result.Failure -> null
    }
}