Préparation entretien Android

Questions d'entretien Android

20 questions fréquemment posées en entretien Android. Le développement Android est un domaine très recherché axé sur les apps mobiles en Kotlin, Android SDK et Jetpack, avec des sujets de lifecycle, performance, réseau, stockage, tests et release. Les questions couvrent plusieurs niveaux, et vous pouvez vous entraîner à y répondre à voix haute dans notre simulateur d'entretien.

Commencer un entretien IA AndroidAucune carte bancaire requise. 1 session gratuite disponible.
Préparation aux entretiens techniques en anglaisUn mode où les non-natifs peuvent s'entraîner à passer des entretiens techniques.

Questions pour débutants

1Comment choisir entre lazy et lateinit pour une propriété Kotlin dont la valeur manque à la construction ?

val by lazy exécute un initialiseur au premier accès et réutilise le résultat. Cela diffère un calcul coûteux, sans attendre une affectation asynchrone extérieure. lateinit var permet une affectation explicite ultérieure, après injection ou lors d’un rappel du cycle de vie, puis une réaffectation. Le type référence doit être compatible et non nullable, les types primitifs sont exclus. Une lecture prématurée lève UninitializedPropertyAccessException. Pour lazy, je vérifie le mode de sûreté entre threads et le thread d’exécution. Pour la vue d’un Fragment détruite puis recréée, je prévois un détenteur nullable ou réinitialisable qui libère l’ancienne référence.

Essayer de répondre à cette question avec un coach IA

2Quels sont les quatre composants principaux d'une application Android, et sur quels threads s'exécutent leurs rappels par défaut ?

Une `Activity` fournit une interface utilisateur ; un `Service` exécute un travail sans interface dédiée ; un `BroadcastReceiver` reçoit des diffusions de l'application ou du système ; un `ContentProvider` gère et expose des données structurées. Les principaux rappels d'activité (`onCreate`, `onStart`, `onResume`), de service (`onCreate`, `onStartCommand`, `onBind`) et de récepteur (`onReceive`) s'exécutent par défaut sur le thread principal. Pour un fournisseur, `onCreate` s'exécute aussi sur le thread principal, tandis que des opérations distantes comme `query` ou `insert` peuvent être appelées sur des threads du pool Binder. Les traitements bloquants de réseau ou de disque sur le thread principal bloquent l'interface et peuvent provoquer une erreur d'application qui ne répond pas (ANR). Un service ne crée pas à lui seul un thread de fond.

class DataSyncService : Service() {
    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // onStartCommand runs on the Main Thread; heavy work must be offloaded
        serviceScope.launch {
            performDiskAndNetworkSync()
            stopSelf(startId)
        }
        return START_NOT_STICKY
    }

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onDestroy() {
        super.onDestroy()
        serviceScope.cancel()
    }

    private fun performDiskAndNetworkSync() {
        // Blocking I/O safely executed on Dispatchers.IO
    }
}
Essayer de répondre à cette question avec un coach IA

3Dans l'architecture MVVM (modèle, vue, modèle de vue) sur Android, quels sont les rôles respectifs d'un ViewModel et des contrôleurs d'interface comme les activités et fragments ? Pourquoi éviter de transmettre un Context au ViewModel ?

Le `ViewModel` conserve l'état de l'interface et coordonne la logique de présentation. Il survit à une recréation due à un changement de configuration, par exemple une rotation. Les activités et fragments affichent cet état, observent ses changements, traitent les interactions directes et gèrent leur cycle de vie. Ne conservez pas de contexte d'activité ni de vue dans le `ViewModel` : celui-ci pourrait retenir l'ancienne activité après sa destruction et empêcher sa récupération par le ramasse-miettes. Si une opération système nécessite vraiment un contexte, utilisez un contexte d'application, par exemple via `AndroidViewModel` ou par injection.

// Bad: Storing Activity context or View reference causes leaks
class LeakyViewModel(private val activityContext: Context) : ViewModel() {
    fun showToast() { Toast.makeText(activityContext, "Hello", Toast.LENGTH_SHORT).show() }
}

// Good: ViewModel manages state; Activity observes and handles context-specific tasks
class SafeViewModel(private val repository: UserRepository) : ViewModel() {
    private val _uiState = MutableStateFlow<UserUiState>(UserUiState.Loading)
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
    
    fun loadUser(id: String) {
        viewModelScope.launch {
            _uiState.value = UserUiState.Success(repository.getUser(id))
        }
    }
}
Essayer de répondre à cette question avec un coach IA

4En quoi les permissions normales et dangereuses diffèrent-elles sur Android, et que se passe-t-il lors d'une demande à l'exécution ?

Une permission normale, comme `ACCESS_NETWORK_STATE`, est accordée sans demander l'avis de l'utilisateur si elle est déclarée dans `AndroidManifest.xml`. Une permission dangereuse concerne un accès sensible, par exemple à l'appareil photo, au microphone, à la localisation ou aux contacts. Vérifiez l'autorisation actuelle avant de la demander. Android peut afficher un dialogue système et renvoie le résultat à l'application ; une demande ne garantit pas qu'un dialogue sera affiché. Si l'autorisation est accordée, utilisez la fonction. Si elle est refusée, désactivez-la ou proposez un fonctionnement dégradé, sans faire planter l'application, et expliquez le besoin si le contexte s'y prête.

val requestPermissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { isGranted: Boolean ->
    if (isGranted) {
        accessCameraFeature()
    } else {
        showPermissionDeniedExplanation()
    }
}

fun checkAndRequestPermission() {
    when {
        ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED -> {
            accessCameraFeature()
        }
        shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
            showRationaleDialog { requestPermissionLauncher.launch(Manifest.permission.CAMERA) }
        }
        else -> {
            requestPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }
}
Essayer de répondre à cette question avec un coach IA

5En quoi diffèrent les builds Android debug et release, et comment les types de build et les variantes de produit se combinent-ils ?

Les types de build règlent l'empaquetage et l'exécution. En général, `debug` autorise le débogage, utilise une clé de débogage et ne réduit pas le code pour accélérer les itérations. Le type `release` désactive normalement le débogage ; réduction, optimisation et obfuscation dépendent de sa configuration. Une version distribuée doit être signée selon le canal prévu. Les variantes de produit distinguent par exemple les environnements `staging` et `production` ou les éditions gratuite et payante. Gradle combine un choix de chaque dimension de produit avec un type de build, sous réserve des combinaisons désactivées. Avec ces deux environnements et `debug` et `release`, on obtient `stagingDebug`, `stagingRelease`, `productionDebug` et `productionRelease`.

android {
    flavorDimensions += "environment"
    productFlavors {
        create("staging") {
            dimension = "environment"
            applicationIdSuffix = ".staging"
        }
        create("production") {
            dimension = "environment"
        }
    }
    buildTypes {
        getByName("debug") {
            isDebuggable = true
        }
        getByName("release") {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}
Essayer de répondre à cette question avec un coach IA

6Qu'est-ce qu'une coroutine Kotlin, et en quoi sa suspension diffère-t-elle du blocage d'un thread sur Android ?

Une coroutine est une unité légère de concurrence qui permet d'écrire des opérations asynchrones sous forme séquentielle. Plusieurs coroutines peuvent partager un thread ou s'exécuter sur un pool. Un appel bloquant comme `Thread.sleep()` ou une entrée-sortie synchrone immobilise le thread. Sur le thread principal, il fige l'interface et peut provoquer une erreur d'application qui ne répond pas (ANR). Une opération suspensive telle que `delay()` peut mettre la coroutine en pause : son état est conservé dans une continuation et le thread peut traiter autre chose jusqu'à la reprise. Le mot-clé `suspend` n'empêche pas à lui seul un appel bloquant dans le corps de la fonction.

suspend fun fetchUserData(): String {
    delay(1000) // Suspends execution and yields the thread
    return "User Data"
}

fun fetchUserDataBlocking(): String {
    Thread.sleep(1000) // Blocks and locks the underlying thread
    return "User Data"
}
Essayer de répondre à cette question avec un coach IA

7En quoi remember diffère-t-il de rememberSaveable, et comment mutableStateOf déclenche-t-il les mises à jour de l'interface dans Compose ?

`remember` garde un objet en mémoire entre les recompositions tant que son emplacement reste dans la composition. Il ne survit pas à la recréation de l'activité ni à la perte du processus. `rememberSaveable` peut restaurer une valeur à partir de l'état sauvegardé Android lors d'une recréation, y compris après la perte du processus si cet état est disponible. Utilisez un `Saver` pour convertir un type non pris en charge en données sauvegardables. `mutableStateOf` crée un `MutableState` observable. Compose suit les lectures pendant la composition et programme la recomposition des portées concernées lorsqu'un changement est détecté par la politique d'égalité.

@Composable
fun CounterExample() {
    // Resets to 0 on screen rotation
    var localCount by remember { mutableStateOf(0) }

    // Persists across screen rotation and process death
    var persistentCount by rememberSaveable { mutableStateOf(0) }

    Column {
        Button(onClick = { localCount++; persistentCount++ }) {
            Text("Local: $localCount | Saved: $persistentCount")
        }
    }
}
Essayer de répondre à cette question avec un coach IA

8Comment la gestion de null dans Kotlin évite-t-elle des plantages sur Android, et quand choisir un type nullable ou non nullable ?

La possibilité d'être nul fait partie du type. Une valeur `String` est non nullable et autorise `name.length` ; une `String?` peut être nulle et exige un traitement adapté avant l'accès. Cela évite des `NullPointerException` avec des arguments de `Bundle`, des extras d'`Intent` ou des réponses réseau facultatifs, sous réserve de traiter aussi les types de plateforme issus de Java. Utilisez un type non nullable si la valeur est obligatoire et un type nullable si son absence est normale, comme une URL de photo facultative. Employez un appel sûr (`user?.name`), l'opérateur Elvis (`user?.name ?: "Guest"`) ou un test explicite. `!!` lève une exception si la valeur est nulle ; réservez-le aux invariants établis.

val displayName: String? = intent.getStringExtra("display_name")

val greeting = "Hello, ${displayName ?: "Guest"}"
val lengthText = displayName?.length?.toString() ?: "No name provided"

// Risky: crashes if displayName is null
val riskyLength = displayName!!.length
Essayer de répondre à cette question avec un coach IA

9Quelle différence y a-t-il entre transmettre un contexte d'activité et un contexte d'application à un objet de longue durée ? Comment un mauvais choix retient-il de la mémoire ?

Le contexte d'activité est lié à un écran et à ses vues ; celui de l'application dure autant que le processus. Lorsqu'une activité se termine ou est recréée, le ramasse-miettes peut récupérer l'ancienne instance quand elle n'est plus accessible. Si un singleton, un champ statique ou un thread de longue durée garde une référence forte au contexte d'activité, une chaîne depuis une racine du ramasse-miettes peut retenir l'activité détruite, ses vues et ses ressources. Utilisez `applicationContext` pour les opérations de longue durée qui ne dépendent pas d'une activité ou de sa fenêtre.

class LocationRepository private constructor(private val context: Context) {
    companion object {
        @Volatile
        private var INSTANCE: LocationRepository? = null

        fun getInstance(context: Context): LocationRepository {
            return INSTANCE ?: synchronized(this) {
                // SAFE: Using context.applicationContext prevents retaining an Activity reference
                INSTANCE ?: LocationRepository(context.applicationContext).also { INSTANCE = it }
            }
        }
    }
}
Essayer de répondre à cette question avec un coach IA

10Quelle différence y a-t-il entre la clé d'importation et la clé de signature de l'application avec Google Play App Signing ?

Le développeur signe l'Android App Bundle à envoyer à Play Console avec sa clé d'importation. Google vérifie cette signature, puis utilise la clé de signature de l'application qu'il gère pour signer les APK distribués et installés. Perdre la clé d'importation ou la voir compromise permet de demander sa réinitialisation sans modifier la clé qui signe les APK et sans casser la mise à jour de l'application. Sans Play App Signing, perdre la clé privée qui signe les versions distribuées peut rendre impossible de publier une mise à jour compatible.

android {
    signingConfigs {
        create("release") {
            storeFile file("my-upload-key.jks")
            storePassword System.getenv("KEYSTORE_PASSWORD")
            keyAlias "upload-alias"
            keyPassword System.getenv("KEY_PASSWORD")
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.getByName("release")
            minifyEnabled true
        }
    }
}
Essayer de répondre à cette question avec un coach IA

Questions intermédiaires

11Comment implémenter la modification et la suppression dans une application Android de notes existante et vérifier la persistance ?

Utiliser le dépôt de données existant et des identifiants stables, mettre à jour le stockage durable et exposer des résultats observables à l’interface. Préserver les modifications non enregistrées lorsque cela convient et tester la recréation du processus, l’annulation d’une suppression et les erreurs du dépôt.

Essayer de répondre à cette question avec un coach IA

12En quoi la réception des changements de présentation par une vue Android diffère-t-elle entre MVP et MVVM ?

En MVP, le présentateur reçoit les actions, coordonne la logique et appelle une interface de vue, par exemple showLoading ou showItems. Il en détient généralement une référence et gère son attachement et son détachement. En MVVM, le ViewModel expose un état observable via StateFlow ou LiveData. La vue le collecte en respectant son cycle de vie, l’affiche et transmet les actions en retour. Le ViewModel ne conserve aucune référence à une Activity ou à la vue du Fragment. Ces deux modèles peuvent être réactifs. Le choix entre commandes impératives et état observable détermine notamment ce qu’on teste et qui gère le cycle de vie.

Essayer de répondre à cette question avec un coach IA

13Qu’est-ce qui distingue les démarrages Android à froid, tièdes et à chaud, et comment compareriez-vous une optimisation sur ces trois cas ?

À froid, le processus n’existe pas : il faut initialiser l’application et créer l’activité. Au démarrage tiède, il reste un état de processus mais il faut parfois recréer l’activité ou restaurer l’écran. À chaud, une activité existante revient au premier plan. J’isole ces cas car accélérer l’initialisation d’Application peut surtout aider à froid. Des mesures répétables et des traces système distinguent le premier affichage du moment où le contenu est entièrement utilisable. Je fixe appareil, système, type de build, données, état de compilation et profil de référence, ainsi que l’état initial du processus et de l’activité. Je compare les distributions et vérifie que le travail n’a pas simplement été repoussé après la première image et que les autres modes ne régressent pas.

Essayer de répondre à cette question avec un coach IA

14Comment concevoir une demande de permission gérant première demande, justification, refus, refus définitif et réglages sans contraindre l'utilisateur ?

Demandez au moment du besoin, par exemple au clic sur scanner pour la caméra, pas systématiquement au démarrage. Si shouldShowRequestPermissionRationale() est vrai, expliquez clairement l'utilité et le bénéfice avant l'invite système. Respectez le refus, gardez les fonctions indépendantes disponibles et proposez si possible une saisie manuelle. Un résultat false ne prouve pas un refus définitif : il apparaît aussi avant la première demande. Suivez les demandes et résultats et considérez les restrictions de plateforme ou de politique. Si une nouvelle invite est indisponible, expliquez la limitation et proposez un bouton facultatif ouvrant les paramètres de l'application via `Settings.ACTION_APPLICATION_DETAILS_SETTINGS`. L'utilisateur doit pouvoir annuler ou revenir facilement sans être piégé.

fun onScanButtonClicked() {
    when {
        ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED -> {
            openScanner()
        }
        activity.shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
            showRationaleDialog(onConfirm = { cameraPermissionLauncher.launch(Manifest.permission.CAMERA) })
        }
        else -> {
            cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }
}

fun handlePermissionResult(isGranted: Boolean) {
    if (isGranted) {
        openScanner()
    } else if (!activity.shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
        showSettingsRedirectDialog()
    } else {
        showManualEntryFallback()
    }
}
Essayer de répondre à cette question avec un coach IA

15Comment concevoir une chaîne d'intégration et de livraison Android, de la validation des modifications jusqu'aux tests internes et au déploiement progressif ?

Sur une demande de fusion, lancez compilation de débogage, tests unitaires et analyse avec Android Lint, ktlint ou Detekt. Après fusion, produisez un bundle `.aab` candidat avec un code de version approprié, signé à l'aide d'identifiants protégés, et conservez le fichier de correspondance R8 si l'obfuscation est active. Publiez sur la piste interne via un outil tel que Gradle Play Publisher ou Fastlane et testez le build approuvé. Promouvez le même artefact dans les pistes suivantes, sans le reconstruire. En production, élargissez le déploiement par étapes, par exemple 5 %, 20 % puis 100 %, en surveillant les plantages et Android Vitals. Définissez des seuils de pause ; une diffusion par étapes réduit le risque sans garantir le succès.

lane :promote_internal_to_beta do
  upload_to_play_store(
    track: 'internal',
    track_promote_to: 'beta',
    skip_upload_aab: true, # Promotes existing binary without rebuilding
    skip_upload_metadata: false,
    skip_upload_changelogs: false
  )
end
Essayer de répondre à cette question avec un coach IA

16Pourquoi intercepter Exception ou Throwable sans relancer CancellationException perturbe-t-il l'annulation des coroutines, et comment diagnostiquer le problème ?

Les opérations suspensives annulables signalent l'annulation du `Job` par `CancellationException`. Si un traitement général l'avale, du code peut continuer malgré un job annulé, garder des ressources ou agir sur une interface détruite. Le job ne redevient pas actif : une suspension annulable suivante peut encore échouer. Interceptez seulement les erreurs que vous savez traiter ou relancez explicitement `CancellationException`. Inspectez les coroutines avec les outils de débogage et journalisez `job.isActive`, `job.isCancelled` ou le résultat d'`invokeOnCompletion`. Vérifiez aussi les boucles de calcul et appels bloquants qui ne coopèrent pas.

import kotlinx.coroutines.CancellationException

// ANTI-PATTERN: Swallows cancellation, creating a zombie coroutine
try {
    doSuspendingWork()
} catch (e: Exception) {
    logError(e)
}

// CORRECT: Preserves cancellation propagation
try {
    doSuspendingWork()
} catch (e: Exception) {
    if (e is CancellationException) throw e
    logError(e)
}
Essayer de répondre à cette question avec un coach IA

17Comment fonctionne la remontée d'état dans le flux unidirectionnel de Compose, et comment choisir entre un composable feuille, un parent et un ViewModel ?

Faites descendre l'état par paramètres et remonter les événements par rappels. Un état purement visuel, utilisé par un seul composable, peut rester local avec `remember`. Si plusieurs enfants le partagent ou si le parent doit contrôler ou valider une valeur, remontez-le au plus proche propriétaire commun et passez par exemple `value` et `onValueChange` à l'enfant. Un `ViewModel` convient à l'état d'écran qui doit survivre à une rotation ou coordonner des règles et des dépôts ; il peut l'exposer via `StateFlow`. Choisissez la portée la plus petite qui couvre les lecteurs, les écritures et la durée de vie requises.

// Stateless Leaf Composable
@Composable
fun SearchBar(query: String, onQueryChange: (String) -> Unit) {
    TextField(value = query, onValueChange = onQueryChange)
}

// Stateful Screen / ViewModel Owner
@Composable
fun SearchScreen(viewModel: SearchViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    SearchBar(
        query = uiState.query,
        onQueryChange = { newQuery -> viewModel.onQueryChanged(newQuery) }
    )
}
Essayer de répondre à cette question avec un coach IA

Questions avancées

18Comment concevriez-vous le client Android d’une messagerie de type Gmail, de l’ouverture de la boîte de réception à la lecture d’un message ?

Une base locale observable alimente la liste paginée. Un dépôt coordonne la synchronisation authentifiée et le stockage. Le ViewModel expose les états chargement, contenu, vide et erreur. La navigation transmet un identifiant stable et la vue détaillée affiche le contenu local pendant le téléchargement des données manquantes. Le changement lu/non lu peut être optimiste et placé dans une file persistante avec reprises et résolution des conflits. Des jetons de synchronisation incrémentale et des tâches de fond évitent de recharger toute la boîte. Je restaure compte, dossier et sélection sans passer les corps dans les arguments de navigation. Les pièces jointes sont téléchargées à la demande, avec limites et annulation. Je restreins scripts, liens dangereux et ressources distantes dans les courriels HTML. Je teste le mode hors ligne, l’expiration de l’autorisation, la mort du processus et les événements en double.

Essayer de répondre à cette question avec un coach IA

19Comment Doze, App Standby et les gestionnaires OEM (propres aux fabricants d'appareils) affectent-ils la planification, et comment concevoir une synchronisation robuste avec WorkManager ?

Doze limite l'utilisation du CPU (processeur central), du réseau et tâches pendant l'inactivité, reportant beaucoup de travail ordinaire aux fenêtres de maintenance, avec exceptions documentées. Les catégories App Standby réduisent fréquence et réseau selon l'usage récent, d'Active à Restricted ou Never. Des gestionnaires OEM (propres aux fabricants d'appareils) agressifs, comme MIUI ou OneUI, peuvent tuer les processus, ignorer des alarmes et retirer les autorisations de démarrage automatique indépendamment du comportement d'AOSP (projet Android à code source ouvert). WorkManager planifie durablement avec les contraintes de plateforme, sans contourner Doze, quotas, force-stop ou limitations du fabricant. Des préconditions comme `NetworkType.CONNECTED` et `requiresBatteryNotLow(true)` reportent le travail jusqu'aux conditions et fenêtres permises. Pour résister aux morts et coupures, combinez politique de réessai adaptée, souvent exponentielle, variation aléatoire des délais et respect des limites serveur : le délai exponentiel seul n'empêche pas une vague synchronisée. Utilisez aussi checkpoints locaux atomiques et opérations distantes idempotentes, avec identifiants déterministes, états locaux et clés serveur de déduplication. Ne supposez pas une transaction atomique commune au stockage local et au serveur. Un worker tué puis replanifié doit pouvoir reprendre sans doublon ni corruption.

val syncConstraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .build()

val syncWorkRequest = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(syncConstraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        WorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .addTag("data_sync_tag")
    .build()

WorkManager.getInstance(context).enqueueUniqueWork(
    "unique_data_sync",
    ExistingWorkPolicy.KEEP,
    syncWorkRequest
)
Essayer de répondre à cette question avec un coach IA

20Comment organiser une architecture Android multiéquipes avec séparation API (interface de programmation)-implémentation pour optimiser Gradle et imposer des contrats ?

Séparez chaque domaine en un module `:feature:api` léger, contenant interfaces, modèles publics et navigation, et un module `:feature:impl` contenant la logique, l'interface utilisateur et les implémentations internes des dépôts de données. Les consommateurs ne dépendent que de l'API (interface de programmation) avec `implementation project(':feature:api')` ; `:app` ou une racine de composition assemble les implémentations via Dagger/Hilt. Des ABI (interfaces binaires applicatives) stables et des chemins de classes de compilation plus petits peuvent réduire recompilation, à mesurer face au coût des modules et du câblage. Un changement interne à impl laisse l'ABI d'api intacte : les consommateurs aux entrées inchangées peuvent éviter de recompiler. Impl et packaging restent affectés, et processeurs d'annotations, code généré ou types divulgués peuvent élargir l'invalidation. Le cache de compilation réutilise les sorties des tâches ; le cache de configuration réutilise le graphe configuré : ce sont deux mécanismes distincts. CODEOWNERS et contrôles de dépendances rendent les frontières d'équipe explicites et réduisent le couplage accidentel. Les modules API peuvent toutefois eux aussi former des cycles si le graphe n'est pas gouverné.

// :feature:checkout:api/src/main/java/com/example/checkout/api/CheckoutApi.kt
package com.example.checkout.api

interface CheckoutLauncher {
    fun launchCheckoutFlow(cartId: String)
}

// :feature:checkout:impl/src/main/java/com/example/checkout/impl/CheckoutLauncherImpl.kt
package com.example.checkout.impl

import com.example.checkout.api.CheckoutLauncher
import javax.inject.Inject

internal class CheckoutLauncherImpl @Inject constructor(
    private val paymentGateway: PaymentGateway
) : CheckoutLauncher {
    override fun launchCheckoutFlow(cartId: String) {
        // Concrete checkout implementation
    }
}

// :feature:checkout:impl/src/main/java/com/example/checkout/impl/di/CheckoutModule.kt
package com.example.checkout.impl.di

import com.example.checkout.api.CheckoutLauncher
import com.example.checkout.impl.CheckoutLauncherImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent

@Module
@InstallIn(SingletonComponent::class)
internal abstract class CheckoutBindingModule {
    @Binds
    abstract fun bindCheckoutLauncher(impl: CheckoutLauncherImpl): CheckoutLauncher
}
Essayer de répondre à cette question avec un coach IA

Préparez vos entretiens sur mobile : Développeur Android

Répondez à voix haute et recevez les retours de l’IA dans l’app Android.

Télécharger EngineerSpeak sur Google Play
Scannez pour télécharger