Préparation entretien Mobile Developer

Questions d'entretien Mobile Developer

20 questions fréquemment posées en entretien pour Mobile Developer. Le développement mobile est un domaine très recherché axé sur des apps iOS, Android et multiplateformes fiables, avec des sujets de produit, performance, release, mode hors ligne et intégration appareil. 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 Mobile DeveloperAucune 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

1Quelle différence existe-t-il entre stocker un jeton dans SharedPreferences ou UserDefaults et utiliser Android Keystore ou iOS Keychain ?

SharedPreferences et UserDefaults sont des préférences, pas des coffres de secrets. Leurs fichiers bénéficient du bac à sable et des protections système, sans chiffrement ni politique spécifiques aux secrets ajoutés par ces API. Keychain stocke des jetons avec accessibilité, synchronisation et contrôles configurables. Keystore stocke et utilise des clés cryptographiques, pas des chaînes de jetons : chiffrez le jeton par une clé gérée et conservez séparément le chiffré. La clé peut être logicielle ou matérielle selon appareil, algorithme et configuration ; vérifiez le niveau plutôt que de supposer la présence d’un environnement d’exécution de confiance (TEE) ou de StrongBox. Une clé matérielle peut être non exportable, mais le jeton déchiffré entre encore en mémoire et une application compromise peut détourner les opérations autorisées. Choisissez explicitement politiques d’authentification et de sauvegarde.

// --- ANDROID ---
// INSECURE (Plain SharedPreferences):
val prefs = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
prefs.edit().putString("auth_token", token).apply() // Plaintext XML on disk

// SECURE (EncryptedSharedPreferences backed by Android Keystore):
val masterKey = MasterKey.Builder(context)
    .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
    .build()
val securePrefs = EncryptedSharedPreferences.create(
    context,
    "secure_prefs",
    masterKey,
    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
securePrefs.edit().putString("auth_token", token).apply()

// --- IOS (Swift) ---
// INSECURE:
UserDefaults.standard.set(token, forKey: "auth_token") // Plain plist on disk

// SECURE (Keychain Services API):
let query: [String: Any] = [
    kSecClass as String: kSecClassGenericPassword,
    kSecAttrAccount as String: "user_auth_token",
    kSecValueData as String: token.data(using: .utf8)!,
    kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked
]
SecItemAdd(query as CFDictionary, nil)
Essayer de répondre à cette question avec un coach IA

2Quel est l'objectif principal d'un pipeline CI/CD (Continuous Integration / Continuous Delivery) mobile, et quelles étapes et contraintes uniques le distinguent des pipelines de déploiement web ou backend ?

L’intégration continue (CI) compile le code, exécute les analyses statiques et lance les tests. La livraison continue (CD) prépare, signe et distribue les paquets vers les canaux de test ou les boutiques. Une chaîne mobile produit des artefacts installables ou publiables, comme APK, AAB et IPA. La compilation iOS nécessite un environnement macOS avec Xcode. La diffusion publique peut dépendre de la validation d’une boutique et les versions déjà installées ne disparaissent pas lors d’un retour arrière serveur. Une correction peut donc nécessiter une nouvelle version signée, éventuellement précédée de la désactivation distante d’une fonction.

name: Mobile CI/CD Workflow

on:
  pull_request:
    branches: [main]
  push:
    tags:
      - 'v*.*.*'

jobs:
  ci_validation:
    name: Lint & Unit Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Linter
        run: ./gradlew lint
      - name: Run Unit Tests
        run: ./gradlew testDebugUnitTest

  cd_release_ios:
    name: Build & Distribute iOS
    needs: ci_validation
    if: startsWith(github.ref, 'refs/tags/v')
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - name: Install Signing Certificates
        run: fastlane match appstore --readonly
      - name: Build & Upload to TestFlight
        run: fastlane ios beta
Essayer de répondre à cette question avec un coach IA

3Dans une application mobile multiplateforme, quel est le but de séparer les couches de présentation, de domaine et de données, et comment cette structure facilite-t-elle le partage de code entre iOS et Android ?

La présentation affiche l’interface, reçoit les interactions et gère l’état des écrans. Le domaine contient les entités, les règles métier et les cas d’usage sans dépendre de l’interface. La couche de données fournit les implémentations qui lisent ou écrivent via une API, une base locale ou un cache. Le domaine se partage facilement entre iOS et Android. Le code de transformation et d’accès aux données peut aussi être mutualisé lorsque les bibliothèques sont compatibles. Pour le stockage sécurisé ou d’autres services propres au système, utilisez des adaptateurs natifs derrière des interfaces communes. Selon le projet, l’interface est partagée ou réalisée séparément.

[Presentation Layer] (UI, Screens, ViewModels)
         │
         ▼ calls
[Domain Layer]       (Use Cases, Business Rules, Entities)
         ▲
         │ implements interfaces
[Data Layer]         (Repositories, API Clients, Local Storage)
Essayer de répondre à cette question avec un coach IA

4Quelles sont les différences fondamentales entre les paradigmes de développement d'interface utilisateur (UI, User Interface) impératifs et déclaratifs dans l'ingénierie mobile, et comment les widgets Flutter et les composants React Native incarnent-ils le modèle déclaratif ?

En mode impératif, le code indique les opérations à exécuter sur les vues, par exemple chercher une vue puis appeler `setText`. En mode déclaratif, le code décrit l’interface correspondant à l’état courant. Le cadre se charge des mises à jour. Dans Flutter, `setState` planifie une reconstruction et `build` fournit une nouvelle description de widgets. Flutter la rapproche des éléments existants. Dans React Native, un composant produit des éléments JSX à partir de ses propriétés et de son état. React compare les descriptions et le moteur applique les changements nécessaires aux vues natives.

class CounterWidget extends StatefulWidget {
  const CounterWidget({super.key});
  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  int _count = 0;

  void _increment() {
    setState(() {
      _count++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: _increment,
      child: Text('Count: $_count'),
    );
  }
}
Essayer de répondre à cette question avec un coach IA

5Quelle différence y a-t-il entre un démarrage à froid, intermédiaire et à chaud, et pourquoi le démarrage à froid compte-t-il particulièrement dans le budget de performance ?

À froid, le processus doit être créé, le code chargé et le premier écran initialisé. Dans un démarrage intermédiaire, le système réutilise une partie de l’état ou du travail déjà effectué, mais doit par exemple recréer l’activité. À chaud, l’activité et son état sont encore en mémoire et reviennent surtout au premier plan. Le démarrage à froid concentre généralement le plus de travail et pèse sur la première impression. Mesurez le délai jusqu’au premier affichage et jusqu’à un écran utilisable, notamment sur les appareils modestes.

Cold Start: [OS Process Spawn] -> [App Runtime Init] -> [Activity/UI Creation] -> [First Frame Drawn]
Warm Start: [Existing Process]  -> [Activity/UI Recreation] -> [First Frame Drawn]
Hot Start:  [Existing Process]  -> [Bring Existing View to Foreground] (Instant)
Essayer de répondre à cette question avec un coach IA

6Qu'est-ce qu'un pont natif (native bridge) dans une application mobile multiplateforme, et quand l'utiliseriez-vous plutôt que d'écrire la fonctionnalité entièrement en code Flutter ou React Native ?

Un pont natif permet au code partagé d’appeler une implémentation iOS ou Android et de recevoir un résultat ou un événement. Flutter propose des canaux de plateforme et des extensions. React Native utilise notamment des modules et des composants natifs. Employez ce mécanisme pour accéder à une API du système, à un appareil comme la caméra, à un kit de développement natif ou à une implémentation exigeante en performances. Exposez une interface limitée, par exemple `getBatteryLevel`, et gardez les détails propres au système derrière elle.

Cross-platform screen:
  calls NativePayments.openPaymentSheet(orderId)

iOS implementation:
  uses Apple Pay / native payment SDK

Android implementation:
  uses Google Pay / native payment SDK
Essayer de répondre à cette question avec un coach IA

7Que signifie une architecture « offline-first » dans le développement mobile, et en quoi diffère-t-elle fondamentalement de la mise en cache standard des réponses HTTP (Hypertext Transfer Protocol) ?

Une architecture pensée pour fonctionner hors ligne s’appuie sur une base locale pour afficher et modifier les données. Elle conserve les changements et les synchronise avec le serveur lorsque le réseau est disponible. Le cache HTTP stocke des réponses en fonction de la requête et de ses en-têtes, selon les règles de fraîcheur et d’éviction. Il accélère surtout les lectures. Il ne fournit à lui seul ni une file d’écritures hors ligne, ni un modèle local structuré qui se prête aux recherches, index et jointures.

/* Network-First with HTTP Caching */
UI -> Network Request -> [Cache Hit ? Return Cached JSON : Fetch from API -> Save to HTTP Cache] -> UI
// Limitation: Read-only optimization; offline writes fail immediately.

/* Offline-First with Local Source of Truth */
UI <-> Observes Local DB (e.g., Room / Core Data / SQLite)
User Write -> Write to Local DB -> Queue Sync Task
Sync Worker (Background) -> Send queued mutations to Server -> Update Local DB with Server Response
Essayer de répondre à cette question avec un coach IA

8Quelle est la différence entre une notification push distante et une notification locale dans une application mobile ?

Une notification locale est créée sur l’appareil et déclenchée par une condition locale, comme un rappel à une heure donnée. Une connexion réseau n’est pas nécessaire à son affichage. Une notification distante part d’un serveur et transite par un service tel qu’APNs ou FCM. Elle signale par exemple l’arrivée d’un message. La livraison, l’affichage et le réveil éventuel de l’application dépendent du type de message, des autorisations et des règles du système.

let content = UNMutableNotificationContent()
content.title = "Workout Reminder"
content.body = "Time for your daily exercise routine."
content.sound = .default

// Triggers locally after 1 hour (3600 seconds) without any server interaction
let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 3600, repeats: false)
let request = UNNotificationRequest(identifier: "dailyWorkout", content: content, trigger: trigger)

UNUserNotificationCenter.current().add(request) { error in
    if let error = error {
        print("Failed to schedule notification: \(error)")
    }
}
Essayer de répondre à cette question avec un coach IA

9Quelle est la différence structurelle et opérationnelle entre un Android App Bundle (.aab), un APK (Android Package) et une archive iOS IPA (iOS App Store Package) lors de la distribution d'applications via les magasins d'applications ?

Un APK est un paquet Android installable contenant du code, des ressources et éventuellement des bibliothèques natives. Un APK universel regroupe plusieurs configurations. Un AAB est un format de publication : Google Play en dérive les APK adaptés à l’architecture, à la densité ou à la langue. Pour un test local, `bundletool` peut en produire des APK installables. Un IPA est une archive iOS contenant notamment le paquet `.app`. Sa distribution ou son installation dépend de la signature et du provisionnement. L’App Store peut livrer une variante optimisée pour l’appareil.

# 1. Standalone APK installs directly via ADB
adb install myapp-universal.apk

# 2. AAB requires bundletool to generate device-tailored split APKs
bundletool build-apks --bundle=myapp.aab --output=myapp.apks --connected-device

# 3. Install the generated split APK set onto the connected device
bundletool install-apks --apks=myapp.apks
Essayer de répondre à cette question avec un coach IA

10Que protège TLS dans les appels réseau d’une application mobile et comment les systèmes mobiles imposent-ils un transport sécurisé par défaut ?

TLS (sécurité de la couche de transport) chiffre le contenu transmis, détecte son altération et authentifie le serveur par validation du certificat et de son nom. Il protège par exemple les en-têtes et le corps d’une requête HTTPS contre la lecture et la modification sur le réseau. Sur iOS, App Transport Security (ATS) impose des exigences de transport sécurisé aux connexions utilisant les API réseau concernées, comme URLSession. Sur Android, le trafic en clair est interdit par défaut pour les applications ciblant l’API 28 ou une version ultérieure dans les composants qui appliquent cette politique. La configuration de sécurité réseau peut définir des exceptions explicites.

<!-- Android: res/xml/network_security_config.xml -->
<network-security-config>
    <!-- Cleartext HTTP blocked by default. Exceptions require explicit declaration -->
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">api.example.com</domain>
    </domain-config>
</network-security-config>

<!-- iOS: Info.plist ATS configuration -->
<!-- ATS blocks HTTP by default; exceptions must be declared inside NSAppTransportSecurity -->
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <false/>
</dict>
Essayer de répondre à cette question avec un coach IA

Questions intermédiaires

11Quels rôles jouent RTSP, RTMP et HLS dans la diffusion vidéo ?

RTSP commande la session, par exemple préparation, lecture et pause ; les médias passent souvent par RTP. RTMP multiplexe médias et commandes sur une connexion persistante, couramment du diffuseur au serveur d’ingestion. HLS utilise des listes de lecture HTTP et des segments ou parties de segments pour la diffusion par CDN et le débit adaptatif. On peut recevoir du RTMP, transcoder en plusieurs qualités, emballer en HLS et distribuer en HTTP ; une caméra peut fournir une source RTSP/RTP. Ce sont des rôles typiques, pas des codecs ni des usages exclusifs. Encodage, durée des segments, tampons et réseau déterminent aussi la latence.

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

12Comment un point de contrôle DLNA détecte-t-il la disparition d’un lecteur et rétablit-il la connexion ?

Je traiterais les notifications SSDP byebye et ferais expirer les entrées à la fin de la durée annoncée. Les échecs répétés du transport ou du renouvellement d’abonnement sont aussi des indices ; un paquet perdu ne suffit pas pour effacer la sélection. Je signalerais l’indisponibilité, limiterais les commandes et relancerais la découverte avec des délais croissants plafonnés en tenant compte des changements de réseau. Au retour, je reconnaîtrais l’identifiant persistant plutôt que l’ancienne IP, actualiserais les points de service et rétablirais les abonnements aux événements. Avant de proposer la reprise, je lirais l’état de lecture : l’appareil a pu redémarrer ou recevoir une commande ailleurs. Je ne rejouerais que les commandes sans risque.

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

13Après la première image, comment réduire les interruptions répétées sur une connexion lente ou instable ?

Je suivrais la durée lisible en tampon et le débit récent des segments pour choisir une qualité avec une marge sous le débit soutenable. Je baisserais vite si le tampon se vide et remonterais prudemment avec hystérésis. Après un arrêt, j’accumulerais assez de contenu avant la reprise. La vidéo à la demande accepte plus de préchargement ; en direct, il faut aussi limiter le retard sur la diffusion. Ordonnancer les segments, réutiliser les connexions et éviter les téléchargements concurrents aide. Je séparerais temps de téléchargement et de décodage et compterais les images perdues : une baisse de débit réseau ne résout pas forcément la saturation du décodeur. Je mesurerais les secondes d’arrêt en regard de la qualité, du démarrage et du retard en direct.

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

14Comment comparer Weex et React Native pour réaliser une interface mobile native en JavaScript ?

Tous deux décrivent en JavaScript une interface matérialisée par des composants natifs, au-delà d’une page dans une WebView. Weex sépare le moteur de rendu de la syntaxe frontale et a pris en charge Vue et Rax. React Native repose sur les composants React ; son architecture moderne comporte Fabric et des mécanismes natifs différents de l’ancien pont asynchrone. Aucun ne garantit la compatibilité avec tout le CSS du navigateur ni un comportement identique sur iOS et Android. Je comparerais les versions précises, modules natifs, mises en page, outils de débogage, accessibilité et mises à niveau. Mutualiser la logique métier évite des doublons mais laisse des intégrations propres aux plateformes. Un prototype représentatif permet d’évaluer les performances.

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

15Comment définir et mesurer le temps de lancement d’une application iOS pour comparer plusieurs versions ?

Je définis une métrique du déclenchement jusqu’à la première image de l’application selon le point final documenté de l’outil, et un jalon distinct pour l’interactivité ou le contenu utile. L’écran de lancement ne prouve pas la disponibilité. Je sépare lancements de processus et reprises, conditions froides et chaudes, caches et préchauffage. Je compare des builds de distribution sur appareils et OS équivalents, à données, réseau, installation et température contrôlés, sans débogueur perturbateur. Je répète et publie médiane et percentiles élevés. Instruments et XCTest reproduisent les régressions, MetricKit ou Organizer donnent les distributions terrain. Des signposts sur initialisation, chargement et création de scène localisent la variation.

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

16Comment fonctionnent les limites de threads (thread boundaries) lors des appels via des ponts natifs (native bridges), et comment évitez-vous les blocages dus aux changements de threads ou les saccades de l'UI (User Interface) lorsque des modules natifs effectuent un travail lourd en arrière-plan ?

Identifiez le fil sur lequel le cadre appelle chaque gestionnaire natif. Les conventions varient selon le type de canal ou de module et sa configuration. Sur le fil principal, limitez-vous aux opérations qui l’exigent. Déléguez le calcul et les entrées-sorties à un groupe de fils borné, puis renvoyez le résultat selon le contrat du cadre. Évitez les attentes synchrones entre fils, réduisez les copies et nettoyez ou annulez les tâches quand le composant disparaît.

class ImageProcessorPlugin : MethodChannel.MethodCallHandler {
    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
        if (call.method == "applyFilter") {
            val imageBytes = call.argument<ByteArray>("image") ?: return result.error("INVALID_ARG", "Image null", null)
            
            // Dispatch heavy computation off the main UI thread
            scope.launch {
                try {
                    val processed = processBitmapBytes(imageBytes) // CPU heavy work
                    withContext(Dispatchers.Main) {
                        result.success(processed)
                    }
                } catch (e: Exception) {
                    withContext(Dispatchers.Main) {
                        result.error("PROCESSING_FAILED", e.localizedMessage, null)
                    }
                }
            }
        } else {
            result.notImplemented()
        }
    }
}
Essayer de répondre à cette question avec un coach IA

17Comment concevriez-vous une stratégie de mise en cache et d'invalidation pour des écrans de listes et de flux en utilisant Stale-While-Revalidate et des en-têtes HTTP (Hypertext Transfer Protocol) conditionnels ?

Affichez d’abord la copie locale, puis revalidez en arrière-plan lorsque la politique le prévoit. Associez `ETag` et curseurs à la représentation exacte, notamment au compte, aux filtres et à la page. Envoyez `If-None-Match` avec le validateur connu. Un `304 Not Modified` renouvelle la validation sans nouveau corps. Un `200 OK` remplace les données et les métadonnées en une transaction. Une action locale ou un changement de filtre peut invalider des pages. Une actualisation manuelle déclenche la revalidation sans devoir renoncer à une requête conditionnelle.

fun getFeed(): Flow<List<FeedItem>> = flow {
    val cached = feedDao.getFeedItems()
    if (cached.isNotEmpty()) emit(cached)
    
    val lastEtag = feedDao.getFeedEtag()
    try {
        val response = api.fetchFeed(ifNoneMatch = lastEtag)
        if (response.code() == 200 && response.body() != null) {
            feedDao.updateFeedTransaction(response.body()!!, response.headers()["ETag"])
            emit(feedDao.getFeedItems())
        }
    } catch (e: Exception) {
        if (cached.isEmpty()) throw e
    }
}
Essayer de répondre à cette question avec un coach IA

Questions avancées

18Une application financière doit protéger ses jetons de renouvellement, permettre le déverrouillage biométrique, traverser les mises à jour système et des sessions hors ligne temporaires. Quelle architecture de stockage et d’accès choisissez-vous ?

Utilisez Keychain avec accessibilité et biométrie explicites, ou chiffrez les jetons avec une clé Keystore exigeant la biométrie. AfterFirstUnlockThisDeviceOnly règle accès et migration, sans exiger seul la biométrie. Vérifiez le matériel au lieu de supposer StrongBox ou stockage universel dans Secure Enclave. Gardez les jetons d’accès à courte durée de vie et de préférence en mémoire, sérialisez les renouvellements et persistez atomiquement les rotations. Testez mises à jour, changement d’enregistrement, verrouillage, réinstallation, sauvegarde-restauration et invalidation, avec réauthentification de secours plutôt qu’une survie garantie. Hors ligne, n’exposez qu’un ensemble local chiffré limité, pour une durée bornée et une politique explicite ; réautorisez les actions en attente à la reconnexion. Un client déconnecté ignore les révocations récentes et l’horloge locale seule n’est pas une protection forte contre l’altération. Différez renouvellement et opérations serveur de valeur jusqu’au réseau. En cas d’invalidation confirmée, révoquez les sessions concernées et effacez les données d’authentification et les données locales associées.

val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
val spec = KeyGenParameterSpec.Builder(
    "refreshTokenKeyAlias",
    KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
)
    .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
    .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
    .setUserAuthenticationRequired(true)
    .setUserAuthenticationParameters(0, KeyProperties.AUTH_BIOMETRIC_STRONG)
    .setInvalidatedByBiometricEnrollment(true)
    .build()
keyGenerator.init(spec)
keyGenerator.generateKey()
Essayer de répondre à cette question avec un coach IA

19Comment concevriez-vous une infrastructure CI/CD (Continuous Integration/Continuous Deployment) scalable pour un monorepo mobile multiplateforme prenant en charge plusieurs équipes, tout en gérant une capacité limitée et coûteuse d'exécuteurs (runners) macOS ?

Calculez les modules touchés et leurs dépendants à partir du graphe de compilation. Réutilisez les résultats par un cache distant avec des clés qui incluent outils et dépendances. Exécutez l’analyse, les tests indépendants et les compilations Android sur des agents Linux. Réservez macOS à Xcode, à la signature et aux simulateurs iOS. Isolez les tâches dans des agents éphémères avec une image préconfigurée, puis dimensionnez la capacité selon la file. Fixez des priorités entre équipes et isolez la signature et les secrets dans les seules tâches autorisées.

name: Cross-Platform Monorepo CI
on: [pull_request]
jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      ios_affected: ${{ steps.filter.outputs.ios }}
      android_affected: ${{ steps.filter.outputs.android }}
    steps:
      - uses: actions/checkout@v4
      - id: filter
        run: |
          # Determine affected targets via monorepo tool (e.g. nx / bazel)
          echo "ios=$(./tools/affected.sh ios)" >> $GITHUB_OUTPUT
          echo "android=$(./tools/affected.sh android)" >> $GITHUB_OUTPUT

  build-android:
    needs: detect-changes
    if: needs.detect-changes.outputs.android_affected == 'true'
    runs-on: ubuntu-latest-16core
    steps:
      - uses: actions/checkout@v4
      - run: ./gradlew assembleRelease

  build-ios:
    needs: detect-changes
    if: needs.detect-changes.outputs.ios_affected == 'true'
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - run: bundle exec fastlane ios build_and_test
Essayer de répondre à cette question avec un coach IA

20Comment concevriez-vous une architecture mobile multiplateforme pour un produit devant partager la majeure partie de sa logique métier entre iOS et Android, tout en permettant à l'interface utilisateur (UI, User Interface), à la navigation et aux intégrations natives spécifiques à chaque plateforme d'évoluer de manière indépendante ?

Placez les règles, validations, cas d’usage et contrats de données dans un noyau partagé organisé par fonctionnalité. L’application de chaque plateforme compose ses vues, sa navigation et son cycle de vie. Le noyau dépend d’interfaces ciblées pour le stockage sécurisé, les paiements ou les services natifs. Chaque plateforme fournit ses adaptateurs et gère ses autorisations et erreurs. Partagez une machine à états ou une logique de présentation lorsque son contrat ne dépend pas du cadre d’interface. Gardez les vues et le parcours de navigation sous la responsabilité de chaque plateforme. Renforcez ces limites avec des règles de dépendance, un point de composition clair, des tests de contrat et des responsables identifiés.

shared-core/
  checkout/
    domain/          # Money, Cart, CheckoutRules, PlaceOrderUseCase
    ports/           # PaymentGateway, TaxRepository, Analytics
    state/           # CheckoutStateMachine or ViewModel contract

ios-app/
  checkout-ui/       # SwiftUI/UIKit screens and iOS navigation
  adapters/          # ApplePayPaymentGateway, KeychainStorage

android-app/
  checkout-ui/       # Compose/XML screens and Android navigation
  adapters/          # GooglePayPaymentGateway, EncryptedSharedPrefsStorage
Essayer de répondre à cette question avec un coach IA

Préparez vos entretiens sur mobile : Développeur d’applications mobiles

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