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.
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)
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
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)
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.
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.
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.
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
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)")
}
}
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
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.
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.
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.
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.
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.
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.
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()
}
}
}
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
}
}
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()
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.
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.