Mon Ordinateur

Comment réduire la latence de votre application mobile

800 ms de latence qui ne viennent ni du réseau ni du serveur : voilà pourquoi votre app semble lente. Découvrez comment décomposer la latence en trois couches et attaquer la bonne — les appels API en cascade étant souvent les premiers coupables.

Comment réduire la latence de votre application mobile

Une application qui met une seconde et demie à s'ouvrir, c'est une seconde et demie pendant laquelle l'utilisateur se demande s'il n'a pas tapé à côté. Il retape. Il râle. Parfois il désinstalle. Et quand on regarde les logs, on découvre que 800 ms de ce délai ne viennent ni du réseau ni du serveur, mais de trois appels API lancés en cascade alors qu'ils auraient pu partir ensemble.

La latence d'une application mobile, c'est comme la douleur : tant qu'on ne sait pas d'où elle vient, on traite au hasard. Cet article part de ce constat. Réduire la latence, ce n'est pas « optimiser » en général — c'est mesurer, décomposer, puis attaquer le bon étage de la pile.

Points clés à retenir

  • La latence se décompose en trois couches distinctes : réseau, backend/API, rendu côté appareil. Optimiser sans savoir laquelle pèse le plus est une perte de temps.
  • Les appels API en cascade sont la première cause de latence applicative que je rencontre sur le terrain — souvent 40 à 60 % du temps d'ouverture d'un écran.
  • Un budget de latence chiffré (par exemple : premier rendu utile sous 1 s, réponse API sous 300 ms) vaut mieux que n'importe quel outil de profiling.
  • Le cache côté client et la pagination côté serveur rapportent plus, en général, que le micro-optimisation d'une boucle.
  • Un appareil lent peut donner l'illusion d'une app lente. Distinguer les deux avant de toucher au code.

Réduire la latence d'une application mobile : d'abord savoir ce qu'on mesure

« Mon app est lente » ne veut rien dire. Ce que vous devez obtenir, c'est une décomposition. Un écran qui s'ouvre en 1,4 s, ça peut être 200 ms de réseau, 900 ms d'API et 300 ms de rendu. Ou l'inverse. Et selon la réponse, le travail à faire n'a strictement rien à voir.

Les trois latences à ne jamais confondre

  • Latence réseau : temps de trajet jusqu'au serveur, DNS, poignée de main TLS, éventuellement TTFB. Souvent subie, partiellement réductible.
  • Latence applicative : temps de réponse de votre API, nombre d'appels, taille du payload, traitement côté serveur.
  • Latence de rendu : temps que met l'interface à peindre, dépend de la surcharge du thread principal, des images non dimensionnées, des listes mal recyclées.

La plupart des articles que j'ai lus sur le sujet mélangent les trois. Résultat : des développeurs qui compressent des images à 85 % alors que leur problème était une requête SQL non indexée. J'ai fait exactement cette erreur sur un projet de suivi d'activité sportive en 2024. Trois semaines passées à revoir les assets graphiques, à réduire le poids du bundle de 30 %. Gain réel sur l'ouverture d'écran : 120 ms. Pas nul, mais ridicule au regard de l'effort. Le vrai coupable était un appel API qui chargeait l'historique complet de l'utilisateur à chaque ouverture.

Fixer un budget de latence, pas un objectif vague

Un budget de latence, c'est un contrat chiffré que vous vous donnez, par écran. Par exemple, pour l'écran d'accueil d'une app de messagerie :

  • Affichage du squelette de chargement : moins de 100 ms après le tap.
  • Premier contenu utile (les 20 derniers messages) : sous 600 ms.
  • Chargement du reste, en tâche de fond : peu importe, l'utilisateur a déjà de quoi lire.

Avouons-le : sans chiffres, on ne sait pas quand on a fini. Et on continue à « optimiser » des choses qui n'ont plus d'impact.

Comment optimiser les applications sur Android (côté développement)

Android ajoute sa propre couche de complexité. Le rendu dépend de l'appareil, de sa version, de la surcouche constructeur, et d'un thread principal qui n'aime pas du tout être bousculé. Voilà ce qui marche, dans l'ordre d'impact.

Comment optimiser les applications sur Android (côté développement)

Le thread principal est sacré

Toute opération qui dépasse quelques millisecondes sur le thread UI se voit immédiatement. Un parsing JSON, un accès disque, un décodage d'image — ça dégage. Le mécanisme existe depuis longtemps (coroutines, exécuteurs, isolate selon la plateforme) et pourtant je vois encore des appels synchrones dans des callbacks d'interface. Chaque fois, c'est la même sanction : des micro-freezes qui font « ramer » l'app alors que le CPU est à 20 %.

Arrêter d'enchaîner les appels API en cascade

C'est mon cheval de bataille, et je vais défendre cette position : dans la très grande majorité des apps que j'ai auditées, le chargement d'un écran ressemble à ça — appel du profil, puis appel des paramètres, puis appel des notifications, chacun attendant le précédent. Pourquoi ? Parce que le premier appel renvoie un identifiant utilisé par le second. Sauf que dans neuf cas sur dix, les données pourraient être demandées en parallèle avec un seul point d'entrée côté serveur. Sur une app de gestion de tâches, passer de 4 appels séquentiels à 2 appels parallèles a fait tomber le temps d'ouverture de 1,9 s à 740 ms. Même réseau, même serveur, juste moins de tours de manège.

Le détail qui m'a coûté une après-midi

Les appels parallèles partaient bien ensemble, mais l'écran attendait le plus lent des quatre pour s'afficher, y compris quand trois données sur quatre étaient déjà là. Résultat : un temps perçu supérieur à la somme réelle. La solution a été d'afficher progressivement, section par section, plutôt que d'attendre le join complet.

Ce qui se joue côté serveur et qu'on oublie

Compresser les payloads (un JSON de 400 Ko qui pourrait en faire 60 après sélection des champs utiles), paginer par défaut au lieu de renvoyer tout l'historique, mettre en cache les réponses stables à faible fréquence de changement, et compresser la réponse HTTP elle-même. Ces quatre leviers, appliqués ensemble, m'ont donné sur un projet de catalogue produit une réduction du temps de réponse API de l'ordre de 65 % — sans toucher une ligne de code côté mobile.

LevierGain typique constatéEffort
Appels API en parallèle40–60 % du temps d'ouvertureMoyen (refonte côté API)
Réduction du payload (champs utiles uniquement)50–80 % de la taille transféréeFaible
Cache côté clientQuasi instantané au 2e accèsFaible à moyen
Compression des images10–20 % du temps d'ouvertureFaible
Réduction du nombre d'images chargées à l'ouvertureVariable, souvent sous-estiméFaible

Quand c'est l'appareil qui rame, pas l'application

Une question revient sans cesse : est-ce que mon app est lente, ou est-ce que le téléphone l'est ? Les deux se ressemblent à s'y méprendre. Un appareil saturé en stockage, dont la mémoire est pleine d'apps en arrière-plan, fera ramer n'importe quelle application, même la mieux optimisée du monde. Avant de sortir le profiler, faites le test sur un appareil neuf ou réinitialisé. Si l'app est fluide, le problème n'est pas dans votre code.

Quand c'est l'appareil qui rame, pas l'application

Comment nettoyer mon téléphone qui rame ?

Trois gestes, dans cet ordre, et honnêtement ils suffisent dans la majorité des cas : désinstaller les applications dont vous ne vous servez pas depuis six mois, vider le cache des applications les plus gourmandes (souvent les réseaux sociaux et les navigateurs — ça peut représenter plusieurs gigaoctets), et vérifier l'espace libre restant (en dessous de 10 % de libre, un appareil Android commence sérieusement à tirer la langue). Les « applications miracles » qui prétendent nettoyer et accélérer le téléphone sont, pour la plupart, elles-mêmes des consommatrices de ressources. J'en ai testé plusieurs sur un appareil de test : aucune n'a apporté de gain mesurable après une semaine d'utilisation.

Comment nettoyer les applications sur Android ?

Allez dans les paramètres, section Applications, et traitez les plus lourdes une par une : effacer le cache (pas les données, sauf si vous voulez repartir de zéro), désactiver les notifications inutiles qui réveillent l'app en permanence, et limiter l'activité en arrière-plan pour celles que vous utilisez rarement. Sur un appareil de milieu de gamme, cette passe m'a rendu une fluidité perceptible en une dizaine de minutes.

« Mon téléphone rame en 4G » : pourquoi ce n'est pas toujours le réseau

Quand une app est fluide en Wi-Fi et lente en 4G, l'instinct dit « mauvais réseau ». Parfois c'est vrai. Mais dans plusieurs cas que j'ai examinés, l'app faisait un fallback silencieux vers une version dégradée de ses requêtes quand la connexion lui semblait mauvaise, avec un timeout mal calibré qui multipliait les tentatives. Une app mal écrite sur réseau instable peut donc transformer une 4G correcte en cauchemar perçu. Vérifiez vos timeouts avant d'accuser l'opérateur.

Comment prioriser sans se disperser

Trois règles que j'applique systématiquement.

  1. Mesurer sur un appareil réel de milieu de gamme, pas sur votre téléphone haut de gamme ni sur émulateur. J'ai vu des apps déclarées « fluides » s'effondrer sur un appareil d'entrée de gamme.
  2. Attaquer la couche la plus lourde d'abord — vous l'avez déjà comprise, c'est celle qui pèse le plus dans la décomposition.
  3. Refaire la mesure après chaque changement. Parce qu'un gain de 200 ms peut en cacher un autre, ou révéler que le prochain goulot était juste derrière.

Spoiler : dans presque tous mes audits, le classement était le même — API en cascade, payload trop gros, rendu, images. Les images arrivent toujours en dernier, alors que c'est ce que tout le monde optimise en premier.

La vraie question n'est pas « comment rendre mon application plus rapide ». C'est « qu'est-ce que je suis prêt à sacrifier pour gagner ces 500 ms ». Une seconde de moins, ça peut vouloir dire un écran qui s'affiche par morceaux, une fonctionnalité repoussée, ou un serveur à réécrire. La latence, ce n'est pas un problème technique à résoudre une fois pour toutes. C'est une négociation permanente entre ce que l'utilisateur perçoit et ce que vous pouvez vous permettre de construire.

Fanny Delaunay

Fanny Delaunay

Fanny Delaunay est une développeuse web reconnue pour son expertise en JavaScript, les frameworks modernes et l'architecture logicielle. Elle accompagne des équipes techniques dans la conception de solutions robustes et évolutives, en mettant l'accent sur les bonnes pratiques et la qualité du code. Passionnée par la transmission, elle intervient régulièrement pour partager sa vision d'un développement web à la fois performant et accessible.

Voir tous les articles →

Articles similaires